diff --git a/src/server/tests.py b/src/server/tests.py index d1051cfcb0..6ad24bf01c 100644 --- a/src/server/tests.py +++ b/src/server/tests.py @@ -17,6 +17,8 @@ Guidelines: """ import sys +import glob + try: from django.utils.unittest import TestCase except ImportError: @@ -28,6 +30,7 @@ except ImportError: from django.conf import settings from django.test.simple import DjangoTestSuiteRunner +from src.utils.utils import mod_import class EvenniaTestSuiteRunner(DjangoTestSuiteRunner): @@ -62,4 +65,12 @@ def suite(): tsuite.addTest(unittest.defaultTestLoader.loadTestsFromModule(commandtests)) tsuite.addTest(unittest.defaultTestLoader.loadTestsFromModule(locktests)) tsuite.addTest(unittest.defaultTestLoader.loadTestsFromModule(utiltests)) + + for path in glob.glob("../src/tests/test_*.py"): + testmod = mod_import(path) + tsuite.addTest(unittest.defaultTestLoader.loadTestsFromModule(testmod)) + + #from src.tests import test_commands_cmdhandler + #tsuite.addTest(unittest.defaultTestLoader.loadTestsFromModule(test_commands_cmdhandler)) + return tsuite diff --git a/src/tests/__init__.py b/src/tests/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/tests/test_commands_cmdhandler.py b/src/tests/test_commands_cmdhandler.py new file mode 100644 index 0000000000..f905036e69 --- /dev/null +++ b/src/tests/test_commands_cmdhandler.py @@ -0,0 +1,14 @@ +import unittest + +class TestGetAndMergeCmdsets(unittest.TestCase): + def test_get_and_merge_cmdsets(self): + # self.assertEqual(expected, get_and_merge_cmdsets(caller, session, player, obj, callertype, sessid)) + assert True # TODO: implement your test here + +class TestCmdhandler(unittest.TestCase): + def test_cmdhandler(self): + # self.assertEqual(expected, cmdhandler(called_by, raw_string, testing, callertype, sessid)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_commands_cmdparser.py b/src/tests/test_commands_cmdparser.py new file mode 100644 index 0000000000..d6bf2e26d3 --- /dev/null +++ b/src/tests/test_commands_cmdparser.py @@ -0,0 +1,24 @@ +import unittest + +class TestCmdparser(unittest.TestCase): + def test_cmdparser(self): + # self.assertEqual(expected, cmdparser(raw_string, cmdset, caller, match_index)) + assert True # TODO: implement your test here + +class TestAtSearchResult(unittest.TestCase): + def test_at_search_result(self): + # self.assertEqual(expected, at_search_result(msg_obj, ostring, results, global_search, nofound_string, multimatch_string)) + assert True # TODO: implement your test here + +class TestAtMultimatchInput(unittest.TestCase): + def test_at_multimatch_input(self): + # self.assertEqual(expected, at_multimatch_input(ostring)) + assert True # TODO: implement your test here + +class TestAtMultimatchCmd(unittest.TestCase): + def test_at_multimatch_cmd(self): + # self.assertEqual(expected, at_multimatch_cmd(caller, matches)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_commands_cmdset.py b/src/tests/test_commands_cmdset.py new file mode 100644 index 0000000000..e5bf82445e --- /dev/null +++ b/src/tests/test_commands_cmdset.py @@ -0,0 +1,74 @@ +import unittest + +class test__CmdSetMeta(unittest.TestCase): + def test___init__(self): + # __cmd_set_meta = _CmdSetMeta(*args, **kwargs) + assert True # TODO: implement your test here + +class TestCmdSet(unittest.TestCase): + def test___add__(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.__add__(cmdset_b)) + assert True # TODO: implement your test here + + def test___contains__(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.__contains__(othercmd)) + assert True # TODO: implement your test here + + def test___init__(self): + # cmd_set = CmdSet(cmdsetobj, key) + assert True # TODO: implement your test here + + def test___iter__(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.__iter__()) + assert True # TODO: implement your test here + + def test___str__(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.__str__()) + assert True # TODO: implement your test here + + def test_add(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.add(cmd)) + assert True # TODO: implement your test here + + def test_at_cmdset_creation(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.at_cmdset_creation()) + assert True # TODO: implement your test here + + def test_count(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.count()) + assert True # TODO: implement your test here + + def test_get(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.get(cmd)) + assert True # TODO: implement your test here + + def test_get_all_cmd_keys_and_aliases(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.get_all_cmd_keys_and_aliases(caller)) + assert True # TODO: implement your test here + + def test_get_system_cmds(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.get_system_cmds()) + assert True # TODO: implement your test here + + def test_make_unique(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.make_unique(caller)) + assert True # TODO: implement your test here + + def test_remove(self): + # cmd_set = CmdSet(cmdsetobj, key) + # self.assertEqual(expected, cmd_set.remove(cmd)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_commands_cmdsethandler.py b/src/tests/test_commands_cmdsethandler.py new file mode 100644 index 0000000000..8a84b95010 --- /dev/null +++ b/src/tests/test_commands_cmdsethandler.py @@ -0,0 +1,64 @@ +import unittest + +class TestImportCmdset(unittest.TestCase): + def test_import_cmdset(self): + # self.assertEqual(expected, import_cmdset(python_path, cmdsetobj, emit_to_obj, no_logging)) + assert True # TODO: implement your test here + +class TestCmdSetHandler(unittest.TestCase): + def test___init__(self): + # cmd_set_handler = CmdSetHandler(obj) + assert True # TODO: implement your test here + + def test___str__(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.__str__()) + assert True # TODO: implement your test here + + def test_add(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.add(cmdset, emit_to_obj, permanent)) + assert True # TODO: implement your test here + + def test_add_default(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.add_default(cmdset, emit_to_obj, permanent)) + assert True # TODO: implement your test here + + def test_all(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.all()) + assert True # TODO: implement your test here + + def test_clear(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.clear()) + assert True # TODO: implement your test here + + def test_delete(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.delete(cmdset)) + assert True # TODO: implement your test here + + def test_delete_default(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.delete_default()) + assert True # TODO: implement your test here + + def test_has_cmdset(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.has_cmdset(cmdset_key, must_be_default)) + assert True # TODO: implement your test here + + def test_reset(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.reset()) + assert True # TODO: implement your test here + + def test_update(self): + # cmd_set_handler = CmdSetHandler(obj) + # self.assertEqual(expected, cmd_set_handler.update(init_mode)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_commands_command.py b/src/tests/test_commands_command.py new file mode 100644 index 0000000000..540002b373 --- /dev/null +++ b/src/tests/test_commands_command.py @@ -0,0 +1,69 @@ +import unittest + +class TestCommandMeta(unittest.TestCase): + def test___init__(self): + # command_meta = CommandMeta(*args, **kwargs) + assert True # TODO: implement your test here + +class TestCommand(unittest.TestCase): + def test___contains__(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.__contains__(query)) + assert True # TODO: implement your test here + + def test___eq__(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.__eq__(cmd)) + assert True # TODO: implement your test here + + def test___init__(self): + # command = Command(**kwargs) + assert True # TODO: implement your test here + + def test___ne__(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.__ne__(cmd)) + assert True # TODO: implement your test here + + def test___str__(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.__str__()) + assert True # TODO: implement your test here + + def test_access(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.access(srcobj, access_type, default)) + assert True # TODO: implement your test here + + def test_at_post_cmd(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.at_post_cmd()) + assert True # TODO: implement your test here + + def test_at_pre_cmd(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.at_pre_cmd()) + assert True # TODO: implement your test here + + def test_func(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.func()) + assert True # TODO: implement your test here + + def test_match(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.match(cmdname)) + assert True # TODO: implement your test here + + def test_msg(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.msg(msg, to_obj, from_obj, sessid, all_sessions, **kwargs)) + assert True # TODO: implement your test here + + def test_parse(self): + # command = Command(**kwargs) + # self.assertEqual(expected, command.parse()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_comms_channelhandler.py b/src/tests/test_comms_channelhandler.py new file mode 100644 index 0000000000..e93edb31b4 --- /dev/null +++ b/src/tests/test_comms_channelhandler.py @@ -0,0 +1,45 @@ +import unittest + +class TestChannelCommand(unittest.TestCase): + def test_func(self): + # channel_command = ChannelCommand() + # self.assertEqual(expected, channel_command.func()) + assert True # TODO: implement your test here + + def test_parse(self): + # channel_command = ChannelCommand() + # self.assertEqual(expected, channel_command.parse()) + assert True # TODO: implement your test here + +class TestChannelHandler(unittest.TestCase): + def test___init__(self): + # channel_handler = ChannelHandler() + assert True # TODO: implement your test here + + def test___str__(self): + # channel_handler = ChannelHandler() + # self.assertEqual(expected, channel_handler.__str__()) + assert True # TODO: implement your test here + + def test_add_channel(self): + # channel_handler = ChannelHandler() + # self.assertEqual(expected, channel_handler.add_channel(channel)) + assert True # TODO: implement your test here + + def test_clear(self): + # channel_handler = ChannelHandler() + # self.assertEqual(expected, channel_handler.clear()) + assert True # TODO: implement your test here + + def test_get_cmdset(self): + # channel_handler = ChannelHandler() + # self.assertEqual(expected, channel_handler.get_cmdset(source_object)) + assert True # TODO: implement your test here + + def test_update(self): + # channel_handler = ChannelHandler() + # self.assertEqual(expected, channel_handler.update()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_comms_comms.py b/src/tests/test_comms_comms.py new file mode 100644 index 0000000000..baace85183 --- /dev/null +++ b/src/tests/test_comms_comms.py @@ -0,0 +1,90 @@ +import unittest + +class TestChannel(unittest.TestCase): + def test_at_channel_create(self): + # channel = Channel() + # self.assertEqual(expected, channel.at_channel_create()) + assert True # TODO: implement your test here + + def test_at_init(self): + # channel = Channel() + # self.assertEqual(expected, channel.at_init()) + assert True # TODO: implement your test here + + def test_channel_prefix(self): + # channel = Channel() + # self.assertEqual(expected, channel.channel_prefix(msg, emit)) + assert True # TODO: implement your test here + + def test_distribute_message(self): + # channel = Channel() + # self.assertEqual(expected, channel.distribute_message(msg, online)) + assert True # TODO: implement your test here + + def test_format_external(self): + # channel = Channel() + # self.assertEqual(expected, channel.format_external(msg, senders, emit)) + assert True # TODO: implement your test here + + def test_format_message(self): + # channel = Channel() + # self.assertEqual(expected, channel.format_message(msg, emit)) + assert True # TODO: implement your test here + + def test_format_senders(self): + # channel = Channel() + # self.assertEqual(expected, channel.format_senders(senders)) + assert True # TODO: implement your test here + + def test_message_transform(self): + # channel = Channel() + # self.assertEqual(expected, channel.message_transform(msg, emit, prefix, sender_strings, external)) + assert True # TODO: implement your test here + + def test_msg(self): + # channel = Channel() + # self.assertEqual(expected, channel.msg(msgobj, header, senders, sender_strings, persistent, online, emit, external)) + assert True # TODO: implement your test here + + def test_pose_transform(self): + # channel = Channel() + # self.assertEqual(expected, channel.pose_transform(msg, sender_string)) + assert True # TODO: implement your test here + + def test_post_join_channel(self): + # channel = Channel() + # self.assertEqual(expected, channel.post_join_channel(joiner)) + assert True # TODO: implement your test here + + def test_post_leave_channel(self): + # channel = Channel() + # self.assertEqual(expected, channel.post_leave_channel(leaver)) + assert True # TODO: implement your test here + + def test_post_send_message(self): + # channel = Channel() + # self.assertEqual(expected, channel.post_send_message(msg)) + assert True # TODO: implement your test here + + def test_pre_join_channel(self): + # channel = Channel() + # self.assertEqual(expected, channel.pre_join_channel(joiner)) + assert True # TODO: implement your test here + + def test_pre_leave_channel(self): + # channel = Channel() + # self.assertEqual(expected, channel.pre_leave_channel(leaver)) + assert True # TODO: implement your test here + + def test_pre_send_message(self): + # channel = Channel() + # self.assertEqual(expected, channel.pre_send_message(msg)) + assert True # TODO: implement your test here + + def test_tempmsg(self): + # channel = Channel() + # self.assertEqual(expected, channel.tempmsg(message, header, senders)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_comms_models.py b/src/tests/test_comms_models.py new file mode 100644 index 0000000000..8ff6498828 --- /dev/null +++ b/src/tests/test_comms_models.py @@ -0,0 +1,84 @@ +import unittest + +class TestMsg(unittest.TestCase): + def test___init__(self): + # msg = Msg(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # msg = Msg(*args, **kwargs) + # self.assertEqual(expected, msg.__str__()) + assert True # TODO: implement your test here + + def test_remove_receiver(self): + # msg = Msg(*args, **kwargs) + # self.assertEqual(expected, msg.remove_receiver(obj)) + assert True # TODO: implement your test here + + def test_remove_sender(self): + # msg = Msg(*args, **kwargs) + # self.assertEqual(expected, msg.remove_sender(value)) + assert True # TODO: implement your test here + +class TestTempMsg(unittest.TestCase): + def test___init__(self): + # temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from) + assert True # TODO: implement your test here + + def test___str__(self): + # temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from) + # self.assertEqual(expected, temp_msg.__str__()) + assert True # TODO: implement your test here + + def test_access(self): + # temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from) + # self.assertEqual(expected, temp_msg.access(accessing_obj, access_type, default)) + assert True # TODO: implement your test here + + def test_remove_receiver(self): + # temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from) + # self.assertEqual(expected, temp_msg.remove_receiver(obj)) + assert True # TODO: implement your test here + + def test_remove_sender(self): + # temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from) + # self.assertEqual(expected, temp_msg.remove_sender(obj)) + assert True # TODO: implement your test here + +class TestChannelDB(unittest.TestCase): + def test___init__(self): + # channel_d_b = ChannelDB(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # channel_d_b = ChannelDB(*args, **kwargs) + # self.assertEqual(expected, channel_d_b.__str__()) + assert True # TODO: implement your test here + + def test_access(self): + # channel_d_b = ChannelDB(*args, **kwargs) + # self.assertEqual(expected, channel_d_b.access(accessing_obj, access_type, default)) + assert True # TODO: implement your test here + + def test_connect(self): + # channel_d_b = ChannelDB(*args, **kwargs) + # self.assertEqual(expected, channel_d_b.connect(player)) + assert True # TODO: implement your test here + + def test_delete(self): + # channel_d_b = ChannelDB(*args, **kwargs) + # self.assertEqual(expected, channel_d_b.delete()) + assert True # TODO: implement your test here + + def test_disconnect(self): + # channel_d_b = ChannelDB(*args, **kwargs) + # self.assertEqual(expected, channel_d_b.disconnect(player)) + assert True # TODO: implement your test here + + def test_has_connection(self): + # channel_d_b = ChannelDB(*args, **kwargs) + # self.assertEqual(expected, channel_d_b.has_connection(player)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_locks_lockfuncs.py b/src/tests/test_locks_lockfuncs.py new file mode 100644 index 0000000000..3bb937bcba --- /dev/null +++ b/src/tests/test_locks_lockfuncs.py @@ -0,0 +1,129 @@ +import unittest + +class TestTrue(unittest.TestCase): + def test_true(self): + # self.assertEqual(expected, true(*args, **kwargs)) + assert True # TODO: implement your test here + +class TestAll(unittest.TestCase): + def test_all(self): + # self.assertEqual(expected, all(*args, **kwargs)) + assert True # TODO: implement your test here + +class TestTrue(unittest.TestCase): + def test_false(self): + # self.assertEqual(expected, false(*args, **kwargs)) + assert True # TODO: implement your test here + +class TestNone(unittest.TestCase): + def test_none(self): + # self.assertEqual(expected, none(*args, **kwargs)) + assert True # TODO: implement your test here + +class TestSelf(unittest.TestCase): + def test_self(self): + # self.assertEqual(expected, self(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestPerm(unittest.TestCase): + def test_perm(self): + # self.assertEqual(expected, perm(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestPermAbove(unittest.TestCase): + def test_perm_above(self): + # self.assertEqual(expected, perm_above(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestPperm(unittest.TestCase): + def test_pperm(self): + # self.assertEqual(expected, pperm(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestPpermAbove(unittest.TestCase): + def test_pperm_above(self): + # self.assertEqual(expected, pperm_above(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestDbref(unittest.TestCase): + def test_dbref(self): + # self.assertEqual(expected, dbref(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestPdbref(unittest.TestCase): + def test_pdbref(self): + # self.assertEqual(expected, pdbref(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestId(unittest.TestCase): + def test_id(self): + # self.assertEqual(expected, id(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestPid(unittest.TestCase): + def test_pid(self): + # self.assertEqual(expected, pid(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttr(unittest.TestCase): + def test_attr(self): + # self.assertEqual(expected, attr(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestObjattr(unittest.TestCase): + def test_objattr(self): + # self.assertEqual(expected, objattr(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestLocattr(unittest.TestCase): + def test_locattr(self): + # self.assertEqual(expected, locattr(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttrEq(unittest.TestCase): + def test_attr_eq(self): + # self.assertEqual(expected, attr_eq(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttrGt(unittest.TestCase): + def test_attr_gt(self): + # self.assertEqual(expected, attr_gt(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttrGe(unittest.TestCase): + def test_attr_ge(self): + # self.assertEqual(expected, attr_ge(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttrLt(unittest.TestCase): + def test_attr_lt(self): + # self.assertEqual(expected, attr_lt(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttrLe(unittest.TestCase): + def test_attr_le(self): + # self.assertEqual(expected, attr_le(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestAttrNe(unittest.TestCase): + def test_attr_ne(self): + # self.assertEqual(expected, attr_ne(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestHolds(unittest.TestCase): + def test_holds(self): + # self.assertEqual(expected, holds(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestSuperuser(unittest.TestCase): + def test_superuser(self): + # self.assertEqual(expected, superuser(*args, **kwargs)) + assert True # TODO: implement your test here + +class TestServersetting(unittest.TestCase): + def test_serversetting(self): + # self.assertEqual(expected, serversetting(accessing_obj, accessed_obj, *args, **kwargs)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_locks_lockhandler.py b/src/tests/test_locks_lockhandler.py new file mode 100644 index 0000000000..e9e209aa27 --- /dev/null +++ b/src/tests/test_locks_lockhandler.py @@ -0,0 +1,59 @@ +import unittest + +class TestLockHandler(unittest.TestCase): + def test___init__(self): + # lock_handler = LockHandler(obj) + assert True # TODO: implement your test here + + def test___str__(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.__str__()) + assert True # TODO: implement your test here + + def test_add(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.add(lockstring, log_obj)) + assert True # TODO: implement your test here + + def test_cache_lock_bypass(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.cache_lock_bypass(obj)) + assert True # TODO: implement your test here + + def test_check(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.check(accessing_obj, access_type, default, no_superuser_bypass)) + assert True # TODO: implement your test here + + def test_check_lockstring(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.check_lockstring(accessing_obj, lockstring, no_superuser_bypass)) + assert True # TODO: implement your test here + + def test_clear(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.clear()) + assert True # TODO: implement your test here + + def test_delete(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.delete(access_type)) + assert True # TODO: implement your test here + + def test_get(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.get(access_type)) + assert True # TODO: implement your test here + + def test_replace(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.replace(lockstring, log_obj)) + assert True # TODO: implement your test here + + def test_reset(self): + # lock_handler = LockHandler(obj) + # self.assertEqual(expected, lock_handler.reset()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_objects_models.py b/src/tests/test_objects_models.py new file mode 100644 index 0000000000..83ee5096f4 --- /dev/null +++ b/src/tests/test_objects_models.py @@ -0,0 +1,64 @@ +import unittest + +class TestObjectDB(unittest.TestCase): + def test___init__(self): + # object_d_b = ObjectDB(*args, **kwargs) + assert True # TODO: implement your test here + + def test_clear_contents(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.clear_contents()) + assert True # TODO: implement your test here + + def test_clear_exits(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.clear_exits()) + assert True # TODO: implement your test here + + def test_contents_get(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.contents_get(exclude)) + assert True # TODO: implement your test here + + def test_copy(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.copy(new_key)) + assert True # TODO: implement your test here + + def test_delete(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.delete()) + assert True # TODO: implement your test here + + def test_execute_cmd(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.execute_cmd(raw_string, sessid)) + assert True # TODO: implement your test here + + def test_move_to(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.move_to(destination, quiet, emit_to_obj, use_destination, to_none)) + assert True # TODO: implement your test here + + def test_msg(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.msg(text, from_obj, sessid, **kwargs)) + assert True # TODO: implement your test here + + def test_msg_contents(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.msg_contents(message, exclude, from_obj, **kwargs)) + assert True # TODO: implement your test here + + def test_search(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.search(searchdata, global_search, use_nicks, typeclass, location, attribute_name, quiet, exact)) + assert True # TODO: implement your test here + + def test_search_player(self): + # object_d_b = ObjectDB(*args, **kwargs) + # self.assertEqual(expected, object_d_b.search_player(searchdata, quiet)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_objects_objects.py b/src/tests/test_objects_objects.py new file mode 100644 index 0000000000..06a7a4917a --- /dev/null +++ b/src/tests/test_objects_objects.py @@ -0,0 +1,302 @@ +import unittest + +class TestObject(unittest.TestCase): + def test___eq__(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.__eq__(other)) + assert True # TODO: implement your test here + + def test___init__(self): + # object = Object(dbobj) + assert True # TODO: implement your test here + + def test_access(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.access(accessing_obj, access_type, default, **kwargs)) + assert True # TODO: implement your test here + + def test_announce_move_from(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.announce_move_from(destination)) + assert True # TODO: implement your test here + + def test_announce_move_to(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.announce_move_to(source_location)) + assert True # TODO: implement your test here + + def test_at_access(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_access(result, accessing_obj, access_type, **kwargs)) + assert True # TODO: implement your test here + + def test_at_access_failure(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_access_failure(accessing_obj, access_type)) + assert True # TODO: implement your test here + + def test_at_access_success(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_access_success(accessing_obj, access_type)) + assert True # TODO: implement your test here + + def test_at_after_move(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_after_move(source_location)) + assert True # TODO: implement your test here + + def test_at_after_traverse(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_after_traverse(traversing_object, source_location)) + assert True # TODO: implement your test here + + def test_at_before_move(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_before_move(destination)) + assert True # TODO: implement your test here + + def test_at_before_traverse(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_before_traverse(traversing_object)) + assert True # TODO: implement your test here + + def test_at_cmdset_get(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_cmdset_get()) + assert True # TODO: implement your test here + + def test_at_desc(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_desc(looker)) + assert True # TODO: implement your test here + + def test_at_drop(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_drop(dropper)) + assert True # TODO: implement your test here + + def test_at_failed_traverse(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_failed_traverse(traversing_object)) + assert True # TODO: implement your test here + + def test_at_get(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_get(getter)) + assert True # TODO: implement your test here + + def test_at_init(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_init()) + assert True # TODO: implement your test here + + def test_at_msg_receive(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_msg_receive(text, **kwargs)) + assert True # TODO: implement your test here + + def test_at_msg_send(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_msg_send(text, to_obj, **kwargs)) + assert True # TODO: implement your test here + + def test_at_object_creation(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_object_creation()) + assert True # TODO: implement your test here + + def test_at_object_delete(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_object_delete()) + assert True # TODO: implement your test here + + def test_at_object_leave(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_object_leave(moved_obj, target_location)) + assert True # TODO: implement your test here + + def test_at_object_receive(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_object_receive(moved_obj, source_location)) + assert True # TODO: implement your test here + + def test_at_post_puppet(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_post_puppet()) + assert True # TODO: implement your test here + + def test_at_post_unpuppet(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_post_unpuppet(player, sessid)) + assert True # TODO: implement your test here + + def test_at_pre_puppet(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_pre_puppet(player, sessid)) + assert True # TODO: implement your test here + + def test_at_pre_unpuppet(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_pre_unpuppet()) + assert True # TODO: implement your test here + + def test_at_say(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_say(speaker, message)) + assert True # TODO: implement your test here + + def test_at_server_reload(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_server_reload()) + assert True # TODO: implement your test here + + def test_at_server_shutdown(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_server_shutdown()) + assert True # TODO: implement your test here + + def test_at_traverse(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.at_traverse(traversing_object, target_location)) + assert True # TODO: implement your test here + + def test_basetype_posthook_setup(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.basetype_posthook_setup()) + assert True # TODO: implement your test here + + def test_basetype_setup(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.basetype_setup()) + assert True # TODO: implement your test here + + def test_check_permstring(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.check_permstring(permstring)) + assert True # TODO: implement your test here + + def test_copy(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.copy(new_key)) + assert True # TODO: implement your test here + + def test_delete(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.delete()) + assert True # TODO: implement your test here + + def test_execute_cmd(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.execute_cmd(raw_string, sessid)) + assert True # TODO: implement your test here + + def test_is_typeclass(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.is_typeclass(typeclass, exact)) + assert True # TODO: implement your test here + + def test_move_to(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.move_to(destination, quiet, emit_to_obj, use_destination, to_none)) + assert True # TODO: implement your test here + + def test_msg(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.msg(text, from_obj, sessid, **kwargs)) + assert True # TODO: implement your test here + + def test_msg_contents(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.msg_contents(text, exclude, from_obj, **kwargs)) + assert True # TODO: implement your test here + + def test_return_appearance(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.return_appearance(pobject)) + assert True # TODO: implement your test here + + def test_search(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.search(ostring, global_search, use_nicks, typeclass, location, attribute_name, quiet, exact)) + assert True # TODO: implement your test here + + def test_swap_typeclass(self): + # object = Object(dbobj) + # self.assertEqual(expected, object.swap_typeclass(new_typeclass, clean_attributes, no_default)) + assert True # TODO: implement your test here + +class TestCharacter(unittest.TestCase): + def test_at_after_move(self): + # character = Character() + # self.assertEqual(expected, character.at_after_move(source_location)) + assert True # TODO: implement your test here + + def test_at_object_creation(self): + # character = Character() + # self.assertEqual(expected, character.at_object_creation()) + assert True # TODO: implement your test here + + def test_at_post_puppet(self): + # character = Character() + # self.assertEqual(expected, character.at_post_puppet()) + assert True # TODO: implement your test here + + def test_at_post_unpuppet(self): + # character = Character() + # self.assertEqual(expected, character.at_post_unpuppet(player, sessid)) + assert True # TODO: implement your test here + + def test_at_pre_puppet(self): + # character = Character() + # self.assertEqual(expected, character.at_pre_puppet(player, sessid)) + assert True # TODO: implement your test here + + def test_basetype_setup(self): + # character = Character() + # self.assertEqual(expected, character.basetype_setup()) + assert True # TODO: implement your test here + +class TestRoom(unittest.TestCase): + def test_basetype_setup(self): + # room = Room() + # self.assertEqual(expected, room.basetype_setup()) + assert True # TODO: implement your test here + +class TestExit(unittest.TestCase): + def test_at_after_traverse(self): + # exit = Exit() + # self.assertEqual(expected, exit.at_after_traverse(traversing_object, source_location)) + assert True # TODO: implement your test here + + def test_at_cmdset_get(self): + # exit = Exit() + # self.assertEqual(expected, exit.at_cmdset_get()) + assert True # TODO: implement your test here + + def test_at_failed_traverse(self): + # exit = Exit() + # self.assertEqual(expected, exit.at_failed_traverse(traversing_object)) + assert True # TODO: implement your test here + + def test_at_object_creation(self): + # exit = Exit() + # self.assertEqual(expected, exit.at_object_creation()) + assert True # TODO: implement your test here + + def test_at_traverse(self): + # exit = Exit() + # self.assertEqual(expected, exit.at_traverse(traversing_object, target_location)) + assert True # TODO: implement your test here + + def test_basetype_setup(self): + # exit = Exit() + # self.assertEqual(expected, exit.basetype_setup()) + assert True # TODO: implement your test here + + def test_create_exit_cmdset(self): + # exit = Exit() + # self.assertEqual(expected, exit.create_exit_cmdset(exidbobj)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_players_bots.py b/src/tests/test_players_bots.py new file mode 100644 index 0000000000..c8740a4d63 --- /dev/null +++ b/src/tests/test_players_bots.py @@ -0,0 +1,106 @@ +import unittest + +class TestBotStarter(unittest.TestCase): + def test_at_repeat(self): + # bot_starter = BotStarter() + # self.assertEqual(expected, bot_starter.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # bot_starter = BotStarter() + # self.assertEqual(expected, bot_starter.at_script_creation()) + assert True # TODO: implement your test here + + def test_at_server_reload(self): + # bot_starter = BotStarter() + # self.assertEqual(expected, bot_starter.at_server_reload()) + assert True # TODO: implement your test here + + def test_at_server_shutdown(self): + # bot_starter = BotStarter() + # self.assertEqual(expected, bot_starter.at_server_shutdown()) + assert True # TODO: implement your test here + + def test_at_start(self): + # bot_starter = BotStarter() + # self.assertEqual(expected, bot_starter.at_start()) + assert True # TODO: implement your test here + +class TestCmdBotListen(unittest.TestCase): + def test_func(self): + # cmd_bot_listen = CmdBotListen() + # self.assertEqual(expected, cmd_bot_listen.func()) + assert True # TODO: implement your test here + +class TestBotCmdSet(unittest.TestCase): + def test_at_cmdset_creation(self): + # bot_cmd_set = BotCmdSet() + # self.assertEqual(expected, bot_cmd_set.at_cmdset_creation()) + assert True # TODO: implement your test here + +class TestBot(unittest.TestCase): + def test_basetype_setup(self): + # bot = Bot() + # self.assertEqual(expected, bot.basetype_setup()) + assert True # TODO: implement your test here + + def test_execute_cmd(self): + # bot = Bot() + # self.assertEqual(expected, bot.execute_cmd(raw_string, sessid)) + assert True # TODO: implement your test here + + def test_msg(self): + # bot = Bot() + # self.assertEqual(expected, bot.msg(text, from_obj, sessid, **kwargs)) + assert True # TODO: implement your test here + + def test_start(self): + # bot = Bot() + # self.assertEqual(expected, bot.start(**kwargs)) + assert True # TODO: implement your test here + +class TestIRCBot(unittest.TestCase): + def test_execute_cmd(self): + # i_rc_bot = IRCBot() + # self.assertEqual(expected, i_rc_bot.execute_cmd(text, sessid)) + assert True # TODO: implement your test here + + def test_msg(self): + # i_rc_bot = IRCBot() + # self.assertEqual(expected, i_rc_bot.msg(text, **kwargs)) + assert True # TODO: implement your test here + + def test_start(self): + # i_rc_bot = IRCBot() + # self.assertEqual(expected, i_rc_bot.start(ev_channel, irc_botname, irc_channel, irc_network, irc_port)) + assert True # TODO: implement your test here + +class TestRSSBot(unittest.TestCase): + def test_execute_cmd(self): + # r_ss_bot = RSSBot() + # self.assertEqual(expected, r_ss_bot.execute_cmd(text, sessid)) + assert True # TODO: implement your test here + + def test_start(self): + # r_ss_bot = RSSBot() + # self.assertEqual(expected, r_ss_bot.start(ev_channel, rss_url, rss_rate)) + assert True # TODO: implement your test here + +class TestIMC2Bot(unittest.TestCase): + def test_execute_cmd(self): + # i_m_c2_bot = IMC2Bot() + # self.assertEqual(expected, i_m_c2_bot.execute_cmd(text, sessid)) + assert True # TODO: implement your test here + + def test_msg(self): + # i_m_c2_bot = IMC2Bot() + # self.assertEqual(expected, i_m_c2_bot.msg(text, **kwargs)) + assert True # TODO: implement your test here + + def test_start(self): + # i_m_c2_bot = IMC2Bot() + # self.assertEqual(expected, i_m_c2_bot.start(ev_channel, imc2_network, imc2_mudname, imc2_port, imc2_client_pwd, imc2_server_pwd)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_players_models.py b/src/tests/test_players_models.py new file mode 100644 index 0000000000..8328d323b5 --- /dev/null +++ b/src/tests/test_players_models.py @@ -0,0 +1,94 @@ +import unittest + +class TestPlayerDB(unittest.TestCase): + def test___init__(self): + # player_d_b = PlayerDB(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.__unicode__()) + assert True # TODO: implement your test here + + def test_cmdset_storage_del(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.cmdset_storage_del()) + assert True # TODO: implement your test here + + def test_cmdset_storage_get(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.cmdset_storage_get()) + assert True # TODO: implement your test here + + def test_cmdset_storage_set(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.cmdset_storage_set(value)) + assert True # TODO: implement your test here + + def test_delete(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.delete(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_disconnect_session_from_player(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.disconnect_session_from_player(sessid)) + assert True # TODO: implement your test here + + def test_execute_cmd(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.execute_cmd(raw_string, sessid)) + assert True # TODO: implement your test here + + def test_get_all_puppets(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.get_all_puppets(return_dbobj)) + assert True # TODO: implement your test here + + def test_get_all_sessions(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.get_all_sessions()) + assert True # TODO: implement your test here + + def test_get_puppet(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.get_puppet(sessid, return_dbobj)) + assert True # TODO: implement your test here + + def test_get_session(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.get_session(sessid)) + assert True # TODO: implement your test here + + def test_msg(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.msg(text, from_obj, sessid, **kwargs)) + assert True # TODO: implement your test here + + def test_puppet_object(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.puppet_object(sessid, obj, normal_mode)) + assert True # TODO: implement your test here + + def test_search(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.search(ostring, return_puppet, return_character, **kwargs)) + assert True # TODO: implement your test here + + def test_unpuppet_all(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.unpuppet_all()) + assert True # TODO: implement your test here + + def test_unpuppet_object(self): + # player_d_b = PlayerDB(*args, **kwargs) + # self.assertEqual(expected, player_d_b.unpuppet_object(sessid)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_scripts_models.py b/src/tests/test_scripts_models.py new file mode 100644 index 0000000000..7c7415b771 --- /dev/null +++ b/src/tests/test_scripts_models.py @@ -0,0 +1,19 @@ +import unittest + +class TestScriptDB(unittest.TestCase): + def test___init__(self): + # script_d_b = ScriptDB(*args, **kwargs) + assert True # TODO: implement your test here + + def test_at_typeclass_error(self): + # script_d_b = ScriptDB(*args, **kwargs) + # self.assertEqual(expected, script_d_b.at_typeclass_error()) + assert True # TODO: implement your test here + + def test_delete(self): + # script_d_b = ScriptDB(*args, **kwargs) + # self.assertEqual(expected, script_d_b.delete()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_scripts_scripthandler.py b/src/tests/test_scripts_scripthandler.py new file mode 100644 index 0000000000..e3fc0b3dbc --- /dev/null +++ b/src/tests/test_scripts_scripthandler.py @@ -0,0 +1,44 @@ +import unittest + +class TestScriptHandler(unittest.TestCase): + def test___init__(self): + # script_handler = ScriptHandler(obj) + assert True # TODO: implement your test here + + def test___str__(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.__str__()) + assert True # TODO: implement your test here + + def test_add(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.add(scriptclass, key, autostart)) + assert True # TODO: implement your test here + + def test_all(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.all(scriptid)) + assert True # TODO: implement your test here + + def test_delete(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.delete(scriptid)) + assert True # TODO: implement your test here + + def test_start(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.start(scriptid)) + assert True # TODO: implement your test here + + def test_stop(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.stop(scriptid)) + assert True # TODO: implement your test here + + def test_validate(self): + # script_handler = ScriptHandler(obj) + # self.assertEqual(expected, script_handler.validate(init_mode)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_scripts_scripts.py b/src/tests/test_scripts_scripts.py new file mode 100644 index 0000000000..c3bfa10d5d --- /dev/null +++ b/src/tests/test_scripts_scripts.py @@ -0,0 +1,181 @@ +import unittest + +class TestExtendedLoopingCall(unittest.TestCase): + def test___call__(self): + # extended_looping_call = ExtendedLoopingCall() + # self.assertEqual(expected, extended_looping_call.__call__()) + assert True # TODO: implement your test here + + def test_force_repeat(self): + # extended_looping_call = ExtendedLoopingCall() + # self.assertEqual(expected, extended_looping_call.force_repeat()) + assert True # TODO: implement your test here + + def test_next_call_time(self): + # extended_looping_call = ExtendedLoopingCall() + # self.assertEqual(expected, extended_looping_call.next_call_time()) + assert True # TODO: implement your test here + + def test_start(self): + # extended_looping_call = ExtendedLoopingCall() + # self.assertEqual(expected, extended_looping_call.start(interval, now, start_delay, count_start)) + assert True # TODO: implement your test here + +class TestScriptBase(unittest.TestCase): + def test___eq__(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.__eq__(other)) + assert True # TODO: implement your test here + + def test_at_init(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.at_init()) + assert True # TODO: implement your test here + + def test_at_repeat(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.at_script_creation()) + assert True # TODO: implement your test here + + def test_at_start(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.at_start()) + assert True # TODO: implement your test here + + def test_at_stop(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.at_stop()) + assert True # TODO: implement your test here + + def test_force_repeat(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.force_repeat()) + assert True # TODO: implement your test here + + def test_is_valid(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.is_valid()) + assert True # TODO: implement your test here + + def test_pause(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.pause()) + assert True # TODO: implement your test here + + def test_remaining_repeats(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.remaining_repeats()) + assert True # TODO: implement your test here + + def test_start(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.start(force_restart)) + assert True # TODO: implement your test here + + def test_stop(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.stop(kill)) + assert True # TODO: implement your test here + + def test_time_until_next_repeat(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.time_until_next_repeat()) + assert True # TODO: implement your test here + + def test_unpause(self): + # script_base = ScriptBase() + # self.assertEqual(expected, script_base.unpause()) + assert True # TODO: implement your test here + +class TestScript(unittest.TestCase): + def test___init__(self): + # script = Script(dbobj) + assert True # TODO: implement your test here + + def test_at_repeat(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.at_script_creation()) + assert True # TODO: implement your test here + + def test_at_server_reload(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.at_server_reload()) + assert True # TODO: implement your test here + + def test_at_server_shutdown(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.at_server_shutdown()) + assert True # TODO: implement your test here + + def test_at_start(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.at_start()) + assert True # TODO: implement your test here + + def test_at_stop(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.at_stop()) + assert True # TODO: implement your test here + + def test_is_valid(self): + # script = Script(dbobj) + # self.assertEqual(expected, script.is_valid()) + assert True # TODO: implement your test here + +class TestDoNothing(unittest.TestCase): + def test_at_script_creation(self): + # do_nothing = DoNothing() + # self.assertEqual(expected, do_nothing.at_script_creation()) + assert True # TODO: implement your test here + +class TestStore(unittest.TestCase): + def test_at_script_creation(self): + # store = Store() + # self.assertEqual(expected, store.at_script_creation()) + assert True # TODO: implement your test here + +class TestCheckSessions(unittest.TestCase): + def test_at_repeat(self): + # check_sessions = CheckSessions() + # self.assertEqual(expected, check_sessions.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # check_sessions = CheckSessions() + # self.assertEqual(expected, check_sessions.at_script_creation()) + assert True # TODO: implement your test here + +class TestValidateScripts(unittest.TestCase): + def test_at_repeat(self): + # validate_scripts = ValidateScripts() + # self.assertEqual(expected, validate_scripts.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # validate_scripts = ValidateScripts() + # self.assertEqual(expected, validate_scripts.at_script_creation()) + assert True # TODO: implement your test here + +class TestValidateChannelHandler(unittest.TestCase): + def test_at_repeat(self): + # validate_channel_handler = ValidateChannelHandler() + # self.assertEqual(expected, validate_channel_handler.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # validate_channel_handler = ValidateChannelHandler() + # self.assertEqual(expected, validate_channel_handler.at_script_creation()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_scripts_tickerhandler.py b/src/tests/test_scripts_tickerhandler.py new file mode 100644 index 0000000000..f301ab637b --- /dev/null +++ b/src/tests/test_scripts_tickerhandler.py @@ -0,0 +1,84 @@ +import unittest + +class TestTicker(unittest.TestCase): + def test___init__(self): + # ticker = Ticker(interval) + assert True # TODO: implement your test here + + def test_add(self): + # ticker = Ticker(interval) + # self.assertEqual(expected, ticker.add(store_key, obj, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_remove(self): + # ticker = Ticker(interval) + # self.assertEqual(expected, ticker.remove(store_key)) + assert True # TODO: implement your test here + + def test_stop(self): + # ticker = Ticker(interval) + # self.assertEqual(expected, ticker.stop()) + assert True # TODO: implement your test here + + def test_validate(self): + # ticker = Ticker(interval) + # self.assertEqual(expected, ticker.validate(start_delay)) + assert True # TODO: implement your test here + +class TestTickerPool(unittest.TestCase): + def test___init__(self): + # ticker_pool = TickerPool() + assert True # TODO: implement your test here + + def test_add(self): + # ticker_pool = TickerPool() + # self.assertEqual(expected, ticker_pool.add(store_key, obj, interval, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_remove(self): + # ticker_pool = TickerPool() + # self.assertEqual(expected, ticker_pool.remove(store_key, interval)) + assert True # TODO: implement your test here + + def test_stop(self): + # ticker_pool = TickerPool() + # self.assertEqual(expected, ticker_pool.stop(interval)) + assert True # TODO: implement your test here + +class TestTickerHandler(unittest.TestCase): + def test___init__(self): + # ticker_handler = TickerHandler(save_name) + assert True # TODO: implement your test here + + def test_add(self): + # ticker_handler = TickerHandler(save_name) + # self.assertEqual(expected, ticker_handler.add(obj, interval, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_all(self): + # ticker_handler = TickerHandler(save_name) + # self.assertEqual(expected, ticker_handler.all(interval)) + assert True # TODO: implement your test here + + def test_clear(self): + # ticker_handler = TickerHandler(save_name) + # self.assertEqual(expected, ticker_handler.clear(interval)) + assert True # TODO: implement your test here + + def test_remove(self): + # ticker_handler = TickerHandler(save_name) + # self.assertEqual(expected, ticker_handler.remove(obj, interval)) + assert True # TODO: implement your test here + + def test_restore(self): + # ticker_handler = TickerHandler(save_name) + # self.assertEqual(expected, ticker_handler.restore()) + assert True # TODO: implement your test here + + def test_save(self): + # ticker_handler = TickerHandler(save_name) + # self.assertEqual(expected, ticker_handler.save()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_amp.py b/src/tests/test_server_amp.py new file mode 100644 index 0000000000..21b31fbbfe --- /dev/null +++ b/src/tests/test_server_amp.py @@ -0,0 +1,125 @@ +import unittest + +class TestGetRestartMode(unittest.TestCase): + def test_get_restart_mode(self): + # self.assertEqual(expected, get_restart_mode(restart_file)) + assert True # TODO: implement your test here + +class TestAmpServerFactory(unittest.TestCase): + def test___init__(self): + # amp_server_factory = AmpServerFactory(server) + assert True # TODO: implement your test here + + def test_buildProtocol(self): + # amp_server_factory = AmpServerFactory(server) + # self.assertEqual(expected, amp_server_factory.buildProtocol(addr)) + assert True # TODO: implement your test here + +class TestAmpClientFactory(unittest.TestCase): + def test___init__(self): + # amp_client_factory = AmpClientFactory(portal) + assert True # TODO: implement your test here + + def test_buildProtocol(self): + # amp_client_factory = AmpClientFactory(portal) + # self.assertEqual(expected, amp_client_factory.buildProtocol(addr)) + assert True # TODO: implement your test here + + def test_clientConnectionFailed(self): + # amp_client_factory = AmpClientFactory(portal) + # self.assertEqual(expected, amp_client_factory.clientConnectionFailed(connector, reason)) + assert True # TODO: implement your test here + + def test_clientConnectionLost(self): + # amp_client_factory = AmpClientFactory(portal) + # self.assertEqual(expected, amp_client_factory.clientConnectionLost(connector, reason)) + assert True # TODO: implement your test here + + def test_startedConnecting(self): + # amp_client_factory = AmpClientFactory(portal) + # self.assertEqual(expected, amp_client_factory.startedConnecting(connector)) + assert True # TODO: implement your test here + +class TestDumps(unittest.TestCase): + def test_dumps(self): + # self.assertEqual(expected, dumps(data)) + assert True # TODO: implement your test here + +class TestLoads(unittest.TestCase): + def test_loads(self): + # self.assertEqual(expected, loads(data)) + assert True # TODO: implement your test here + +class TestAMPProtocol(unittest.TestCase): + def test_amp_function_call(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.amp_function_call(module, function, args, **kwargs)) + assert True # TODO: implement your test here + + def test_amp_msg_portal2server(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.amp_msg_portal2server(sessid, ipart, nparts, msg, data)) + assert True # TODO: implement your test here + + def test_amp_msg_server2portal(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.amp_msg_server2portal(sessid, ipart, nparts, msg, data)) + assert True # TODO: implement your test here + + def test_amp_portal_admin(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.amp_portal_admin(sessid, ipart, nparts, operation, data)) + assert True # TODO: implement your test here + + def test_amp_server_admin(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.amp_server_admin(sessid, ipart, nparts, operation, data)) + assert True # TODO: implement your test here + + def test_call_remote_FunctionCall(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.call_remote_FunctionCall(modulepath, functionname, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_call_remote_MsgPortal2Server(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.call_remote_MsgPortal2Server(sessid, msg, data)) + assert True # TODO: implement your test here + + def test_call_remote_MsgServer2Portal(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.call_remote_MsgServer2Portal(sessid, msg, data)) + assert True # TODO: implement your test here + + def test_call_remote_PortalAdmin(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.call_remote_PortalAdmin(sessid, operation, data)) + assert True # TODO: implement your test here + + def test_call_remote_ServerAdmin(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.call_remote_ServerAdmin(sessid, operation, data)) + assert True # TODO: implement your test here + + def test_connectionMade(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.connectionMade()) + assert True # TODO: implement your test here + + def test_errback(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.errback(e, info)) + assert True # TODO: implement your test here + + def test_safe_recv(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.safe_recv(command, sessid, ipart, nparts, **kwargs)) + assert True # TODO: implement your test here + + def test_safe_send(self): + # a_mp_protocol = AMPProtocol() + # self.assertEqual(expected, a_mp_protocol.safe_send(command, sessid, **kwargs)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_caches.py b/src/tests/test_server_caches.py new file mode 100644 index 0000000000..40d366a00b --- /dev/null +++ b/src/tests/test_server_caches.py @@ -0,0 +1,54 @@ +import unittest + +class TestHashid(unittest.TestCase): + def test_hashid(self): + # self.assertEqual(expected, hashid(obj, suffix)) + assert True # TODO: implement your test here + +class TestFieldPreSave(unittest.TestCase): + def test_field_pre_save(self): + # self.assertEqual(expected, field_pre_save(sender, instance, update_fields, raw, **kwargs)) + assert True # TODO: implement your test here + +class TestFieldPostSave(unittest.TestCase): + def test_field_post_save(self): + # self.assertEqual(expected, field_post_save(sender, instance, update_fields, raw, **kwargs)) + assert True # TODO: implement your test here + +class TestGetAttrCache(unittest.TestCase): + def test_get_attr_cache(self): + # self.assertEqual(expected, get_attr_cache(obj)) + assert True # TODO: implement your test here + +class TestSetAttrCache(unittest.TestCase): + def test_set_attr_cache(self): + # self.assertEqual(expected, set_attr_cache(obj, store)) + assert True # TODO: implement your test here + +class TestGetPropCache(unittest.TestCase): + def test_get_prop_cache(self): + # self.assertEqual(expected, get_prop_cache(obj, propname)) + assert True # TODO: implement your test here + +class TestSetPropCache(unittest.TestCase): + def test_set_prop_cache(self): + # self.assertEqual(expected, set_prop_cache(obj, propname, propvalue)) + assert True # TODO: implement your test here + +class TestDelPropCache(unittest.TestCase): + def test_del_prop_cache(self): + # self.assertEqual(expected, del_prop_cache(obj, propname)) + assert True # TODO: implement your test here + +class TestFlushPropCache(unittest.TestCase): + def test_flush_prop_cache(self): + # self.assertEqual(expected, flush_prop_cache()) + assert True # TODO: implement your test here + +class TestGetCacheSizes(unittest.TestCase): + def test_get_cache_sizes(self): + # self.assertEqual(expected, get_cache_sizes()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_initial_setup.py b/src/tests/test_server_initial_setup.py new file mode 100644 index 0000000000..3dda142df5 --- /dev/null +++ b/src/tests/test_server_initial_setup.py @@ -0,0 +1,54 @@ +import unittest + +class TestCreateConfigValues(unittest.TestCase): + def test_create_config_values(self): + # self.assertEqual(expected, create_config_values()) + assert True # TODO: implement your test here + +class TestGetGodPlayer(unittest.TestCase): + def test_get_god_player(self): + # self.assertEqual(expected, get_god_player()) + assert True # TODO: implement your test here + +class TestCreateObjects(unittest.TestCase): + def test_create_objects(self): + # self.assertEqual(expected, create_objects()) + assert True # TODO: implement your test here + +class TestCreateChannels(unittest.TestCase): + def test_create_channels(self): + # self.assertEqual(expected, create_channels()) + assert True # TODO: implement your test here + +class TestCreateSystemScripts(unittest.TestCase): + def test_create_system_scripts(self): + # self.assertEqual(expected, create_system_scripts()) + assert True # TODO: implement your test here + +class TestStartGameTime(unittest.TestCase): + def test_start_game_time(self): + # self.assertEqual(expected, start_game_time()) + assert True # TODO: implement your test here + +class TestCreateAdminMediaLinks(unittest.TestCase): + def test_create_admin_media_links(self): + # self.assertEqual(expected, create_admin_media_links()) + assert True # TODO: implement your test here + +class TestAtInitialSetup(unittest.TestCase): + def test_at_initial_setup(self): + # self.assertEqual(expected, at_initial_setup()) + assert True # TODO: implement your test here + +class TestResetServer(unittest.TestCase): + def test_reset_server(self): + # self.assertEqual(expected, reset_server()) + assert True # TODO: implement your test here + +class TestHandleSetup(unittest.TestCase): + def test_handle_setup(self): + # self.assertEqual(expected, handle_setup(last_step)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_manager.py b/src/tests/test_server_manager.py new file mode 100644 index 0000000000..8b8b5fadf3 --- /dev/null +++ b/src/tests/test_server_manager.py @@ -0,0 +1,15 @@ +import unittest + +class TestServerConfigManager(unittest.TestCase): + def test_conf(self): + # server_config_manager = ServerConfigManager() + # self.assertEqual(expected, server_config_manager.conf(key, value, delete, default)) + assert True # TODO: implement your test here + + def test_get_mysql_db_version(self): + # server_config_manager = ServerConfigManager() + # self.assertEqual(expected, server_config_manager.get_mysql_db_version()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_models.py b/src/tests/test_server_models.py new file mode 100644 index 0000000000..bd053c8f59 --- /dev/null +++ b/src/tests/test_server_models.py @@ -0,0 +1,15 @@ +import unittest + +class TestServerConfig(unittest.TestCase): + def test___unicode__(self): + # server_config = ServerConfig() + # self.assertEqual(expected, server_config.__unicode__()) + assert True # TODO: implement your test here + + def test_store(self): + # server_config = ServerConfig() + # self.assertEqual(expected, server_config.store(key, value)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_oob_msdp.py b/src/tests/test_server_oob_msdp.py new file mode 100644 index 0000000000..51bb5d22ea --- /dev/null +++ b/src/tests/test_server_oob_msdp.py @@ -0,0 +1,49 @@ +import unittest + +class TestOOBFieldTracker(unittest.TestCase): + def test___init__(self): + # o_ob_field_tracker = OOBFieldTracker(oobhandler, fieldname, sessid, *args, **kwargs) + assert True # TODO: implement your test here + + def test_update(self): + # o_ob_field_tracker = OOBFieldTracker(oobhandler, fieldname, sessid, *args, **kwargs) + # self.assertEqual(expected, o_ob_field_tracker.update(new_value, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestOOBAttributeTracker(unittest.TestCase): + def test___init__(self): + # o_ob_attribute_tracker = OOBAttributeTracker(oobhandler, fieldname, sessid, attrname, *args, **kwargs) + assert True # TODO: implement your test here + + def test_update(self): + # o_ob_attribute_tracker = OOBAttributeTracker(oobhandler, fieldname, sessid, attrname, *args, **kwargs) + # self.assertEqual(expected, o_ob_attribute_tracker.update(new_value, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestOobError(unittest.TestCase): + def test_oob_error(self): + # self.assertEqual(expected, oob_error(oobhandler, session, errmsg, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestList(unittest.TestCase): + def test_list(self): + # self.assertEqual(expected, list(oobhandler, session, mode, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestSend(unittest.TestCase): + def test_send(self): + # self.assertEqual(expected, send(oobhandler, session, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestReport(unittest.TestCase): + def test_report(self): + # self.assertEqual(expected, report(oobhandler, session, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestUnreport(unittest.TestCase): + def test_unreport(self): + # self.assertEqual(expected, unreport(oobhandler, session, vartype, *args, **kwargs)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_oobhandler.py b/src/tests/test_server_oobhandler.py new file mode 100644 index 0000000000..fc386c1225 --- /dev/null +++ b/src/tests/test_server_oobhandler.py @@ -0,0 +1,114 @@ +import unittest + +class TestTrackerHandler(unittest.TestCase): + def test___init__(self): + # tracker_handler = TrackerHandler(obj) + assert True # TODO: implement your test here + + def test_add(self): + # tracker_handler = TrackerHandler(obj) + # self.assertEqual(expected, tracker_handler.add(fieldname, tracker)) + assert True # TODO: implement your test here + + def test_remove(self): + # tracker_handler = TrackerHandler(obj) + # self.assertEqual(expected, tracker_handler.remove(fieldname, trackerclass, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_update(self): + # tracker_handler = TrackerHandler(obj) + # self.assertEqual(expected, tracker_handler.update(fieldname, new_value)) + assert True # TODO: implement your test here + +class TestTrackerBase(unittest.TestCase): + def test___init__(self): + # tracker_base = TrackerBase(*args, **kwargs) + assert True # TODO: implement your test here + + def test_at_remove(self): + # tracker_base = TrackerBase(*args, **kwargs) + # self.assertEqual(expected, tracker_base.at_remove(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_update(self): + # tracker_base = TrackerBase(*args, **kwargs) + # self.assertEqual(expected, tracker_base.update(*args, **kwargs)) + assert True # TODO: implement your test here + +class TestOOBTicker(unittest.TestCase): + def test___init__(self): + # o_ob_ticker = OOBTicker(interval) + assert True # TODO: implement your test here + +class TestOOBHandler(unittest.TestCase): + def test___init__(self): + # o_ob_handler = OOBHandler() + assert True # TODO: implement your test here + + def test_execute_cmd(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.execute_cmd(session, func_key, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_get_all_tracked(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.get_all_tracked(session)) + assert True # TODO: implement your test here + + def test_msg(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.msg(sessid, funcname, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_repeat(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.repeat(obj, sessid, func_key, interval, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_restore(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.restore()) + assert True # TODO: implement your test here + + def test_save(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.save()) + assert True # TODO: implement your test here + + def test_track(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.track(obj, sessid, fieldname, trackerclass, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_track_attribute(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.track_attribute(obj, sessid, attr_name, trackerclass)) + assert True # TODO: implement your test here + + def test_track_field(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.track_field(obj, sessid, field_name, trackerclass)) + assert True # TODO: implement your test here + + def test_unrepeat(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.unrepeat(obj, sessid, func_key, interval)) + assert True # TODO: implement your test here + + def test_untrack(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.untrack(obj, sessid, fieldname, trackerclass, *args, **kwargs)) + assert True # TODO: implement your test here + + def test_untrack_attribute(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.untrack_attribute(obj, sessid, attr_name, trackerclass)) + assert True # TODO: implement your test here + + def test_untrack_field(self): + # o_ob_handler = OOBHandler() + # self.assertEqual(expected, o_ob_handler.untrack_field(obj, sessid, field_name)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_server.py b/src/tests/test_server_server.py new file mode 100644 index 0000000000..66e6080c46 --- /dev/null +++ b/src/tests/test_server_server.py @@ -0,0 +1,39 @@ +import unittest + +class TestEvennia(unittest.TestCase): + def test___init__(self): + # evennia = Evennia(application) + assert True # TODO: implement your test here + + def test_run_init_hooks(self): + # evennia = Evennia(application) + # self.assertEqual(expected, evennia.run_init_hooks()) + assert True # TODO: implement your test here + + def test_run_initial_setup(self): + # evennia = Evennia(application) + # self.assertEqual(expected, evennia.run_initial_setup()) + assert True # TODO: implement your test here + + def test_set_restart_mode(self): + # evennia = Evennia(application) + # self.assertEqual(expected, evennia.set_restart_mode(mode)) + assert True # TODO: implement your test here + + def test_shutdown(self): + # evennia = Evennia(application) + # self.assertEqual(expected, evennia.shutdown(mode, _reactor_stopping)) + assert True # TODO: implement your test here + + def test_sqlite3_prep(self): + # evennia = Evennia(application) + # self.assertEqual(expected, evennia.sqlite3_prep()) + assert True # TODO: implement your test here + + def test_update_defaults(self): + # evennia = Evennia(application) + # self.assertEqual(expected, evennia.update_defaults()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_serversession.py b/src/tests/test_server_serversession.py new file mode 100644 index 0000000000..8696886f35 --- /dev/null +++ b/src/tests/test_server_serversession.py @@ -0,0 +1,104 @@ +import unittest + +class TestServerSession(unittest.TestCase): + def test___eq__(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.__eq__(other)) + assert True # TODO: implement your test here + + def test___init__(self): + # server_session = ServerSession() + assert True # TODO: implement your test here + + def test___str__(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.__unicode__()) + assert True # TODO: implement your test here + + def test_access(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.access(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_at_cmdset_get(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.at_cmdset_get()) + assert True # TODO: implement your test here + + def test_at_disconnect(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.at_disconnect()) + assert True # TODO: implement your test here + + def test_at_login(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.at_login(player)) + assert True # TODO: implement your test here + + def test_at_sync(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.at_sync()) + assert True # TODO: implement your test here + + def test_data_in(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.data_in(text, **kwargs)) + assert True # TODO: implement your test here + + def test_data_out(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.data_out(text, **kwargs)) + assert True # TODO: implement your test here + + def test_get_player(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.get_player()) + assert True # TODO: implement your test here + + def test_get_puppet(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.get_puppet()) + assert True # TODO: implement your test here + + def test_get_puppet_or_player(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.get_puppet_or_player()) + assert True # TODO: implement your test here + + def test_log(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.log(message, channel)) + assert True # TODO: implement your test here + + def test_msg(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.msg(text, **kwargs)) + assert True # TODO: implement your test here + + def test_ndb_del(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.ndb_del()) + assert True # TODO: implement your test here + + def test_ndb_get(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.ndb_get()) + assert True # TODO: implement your test here + + def test_ndb_set(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.ndb_set(value)) + assert True # TODO: implement your test here + + def test_update_session_counters(self): + # server_session = ServerSession() + # self.assertEqual(expected, server_session.update_session_counters(idle)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_session.py b/src/tests/test_server_session.py new file mode 100644 index 0000000000..cf96cbaf81 --- /dev/null +++ b/src/tests/test_server_session.py @@ -0,0 +1,40 @@ +import unittest + +class TestSession(unittest.TestCase): + def test_at_sync(self): + # session = Session() + # self.assertEqual(expected, session.at_sync()) + assert True # TODO: implement your test here + + def test_data_in(self): + # session = Session() + # self.assertEqual(expected, session.data_in(text, **kwargs)) + assert True # TODO: implement your test here + + def test_data_out(self): + # session = Session() + # self.assertEqual(expected, session.data_out(text, **kwargs)) + assert True # TODO: implement your test here + + def test_disconnect(self): + # session = Session() + # self.assertEqual(expected, session.disconnect(reason)) + assert True # TODO: implement your test here + + def test_get_sync_data(self): + # session = Session() + # self.assertEqual(expected, session.get_sync_data()) + assert True # TODO: implement your test here + + def test_init_session(self): + # session = Session() + # self.assertEqual(expected, session.init_session(protocol_key, address, sessionhandler)) + assert True # TODO: implement your test here + + def test_load_sync_data(self): + # session = Session() + # self.assertEqual(expected, session.load_sync_data(sessdata)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_server_webserver.py b/src/tests/test_server_webserver.py new file mode 100644 index 0000000000..c2a9d36029 --- /dev/null +++ b/src/tests/test_server_webserver.py @@ -0,0 +1,46 @@ +import unittest + +class TestHTTPChannelWithXForwardedFor(unittest.TestCase): + def test_allHeadersReceived(self): + # h_ttp_channel_with_x_forwarded_for = HTTPChannelWithXForwardedFor() + # self.assertEqual(expected, h_ttp_channel_with_x_forwarded_for.allHeadersReceived()) + assert True # TODO: implement your test here + +class TestEvenniaReverseProxyResource(unittest.TestCase): + def test_getChild(self): + # evennia_reverse_proxy_resource = EvenniaReverseProxyResource() + # self.assertEqual(expected, evennia_reverse_proxy_resource.getChild(path, request)) + assert True # TODO: implement your test here + + def test_render(self): + # evennia_reverse_proxy_resource = EvenniaReverseProxyResource() + # self.assertEqual(expected, evennia_reverse_proxy_resource.render(request)) + assert True # TODO: implement your test here + +class TestDjangoWebRoot(unittest.TestCase): + def test___init__(self): + # django_web_root = DjangoWebRoot(pool) + assert True # TODO: implement your test here + + def test_getChild(self): + # django_web_root = DjangoWebRoot(pool) + # self.assertEqual(expected, django_web_root.getChild(path, request)) + assert True # TODO: implement your test here + +class TestWSGIWebServer(unittest.TestCase): + def test___init__(self): + # w_sgi_web_server = WSGIWebServer(pool, *args, **kwargs) + assert True # TODO: implement your test here + + def test_startService(self): + # w_sgi_web_server = WSGIWebServer(pool, *args, **kwargs) + # self.assertEqual(expected, w_sgi_web_server.startService()) + assert True # TODO: implement your test here + + def test_stopService(self): + # w_sgi_web_server = WSGIWebServer(pool, *args, **kwargs) + # self.assertEqual(expected, w_sgi_web_server.stopService()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_typeclasses_models.py b/src/tests/test_typeclasses_models.py new file mode 100644 index 0000000000..ef4e2b3295 --- /dev/null +++ b/src/tests/test_typeclasses_models.py @@ -0,0 +1,266 @@ +import unittest + +class TestAttribute(unittest.TestCase): + def test___init__(self): + # attribute = Attribute(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # attribute = Attribute(*args, **kwargs) + # self.assertEqual(expected, attribute.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # attribute = Attribute(*args, **kwargs) + # self.assertEqual(expected, attribute.__unicode__()) + assert True # TODO: implement your test here + + def test_access(self): + # attribute = Attribute(*args, **kwargs) + # self.assertEqual(expected, attribute.access(accessing_obj, access_type, default, **kwargs)) + assert True # TODO: implement your test here + + def test_at_set(self): + # attribute = Attribute(*args, **kwargs) + # self.assertEqual(expected, attribute.at_set(new_value)) + assert True # TODO: implement your test here + +class TestAttributeHandler(unittest.TestCase): + def test___init__(self): + # attribute_handler = AttributeHandler(obj) + assert True # TODO: implement your test here + + def test_add(self): + # attribute_handler = AttributeHandler(obj) + # self.assertEqual(expected, attribute_handler.add(key, value, category, lockstring, strattr, accessing_obj, default_access)) + assert True # TODO: implement your test here + + def test_all(self): + # attribute_handler = AttributeHandler(obj) + # self.assertEqual(expected, attribute_handler.all(accessing_obj, default_access)) + assert True # TODO: implement your test here + + def test_clear(self): + # attribute_handler = AttributeHandler(obj) + # self.assertEqual(expected, attribute_handler.clear(category, accessing_obj, default_access)) + assert True # TODO: implement your test here + + def test_get(self): + # attribute_handler = AttributeHandler(obj) + # self.assertEqual(expected, attribute_handler.get(key, category, default, return_obj, strattr, raise_exception, accessing_obj, default_access, not_found_none)) + assert True # TODO: implement your test here + + def test_has(self): + # attribute_handler = AttributeHandler(obj) + # self.assertEqual(expected, attribute_handler.has(key, category)) + assert True # TODO: implement your test here + + def test_remove(self): + # attribute_handler = AttributeHandler(obj) + # self.assertEqual(expected, attribute_handler.remove(key, raise_exception, category, accessing_obj, default_access)) + assert True # TODO: implement your test here + +class TestNickHandler(unittest.TestCase): + def test_add(self): + # nick_handler = NickHandler() + # self.assertEqual(expected, nick_handler.add(key, replacement, category, **kwargs)) + assert True # TODO: implement your test here + + def test_get(self): + # nick_handler = NickHandler() + # self.assertEqual(expected, nick_handler.get(key, category, **kwargs)) + assert True # TODO: implement your test here + + def test_has(self): + # nick_handler = NickHandler() + # self.assertEqual(expected, nick_handler.has(key, category)) + assert True # TODO: implement your test here + + def test_nickreplace(self): + # nick_handler = NickHandler() + # self.assertEqual(expected, nick_handler.nickreplace(raw_string, categories, include_player)) + assert True # TODO: implement your test here + + def test_remove(self): + # nick_handler = NickHandler() + # self.assertEqual(expected, nick_handler.remove(key, category, **kwargs)) + assert True # TODO: implement your test here + +class TestNAttributeHandler(unittest.TestCase): + def test___init__(self): + # n_attribute_handler = NAttributeHandler(obj) + assert True # TODO: implement your test here + + def test_add(self): + # n_attribute_handler = NAttributeHandler(obj) + # self.assertEqual(expected, n_attribute_handler.add(key, value)) + assert True # TODO: implement your test here + + def test_all(self): + # n_attribute_handler = NAttributeHandler(obj) + # self.assertEqual(expected, n_attribute_handler.all()) + assert True # TODO: implement your test here + + def test_get(self): + # n_attribute_handler = NAttributeHandler(obj) + # self.assertEqual(expected, n_attribute_handler.get(key)) + assert True # TODO: implement your test here + + def test_has(self): + # n_attribute_handler = NAttributeHandler(obj) + # self.assertEqual(expected, n_attribute_handler.has(key)) + assert True # TODO: implement your test here + + def test_remove(self): + # n_attribute_handler = NAttributeHandler(obj) + # self.assertEqual(expected, n_attribute_handler.remove(key)) + assert True # TODO: implement your test here + +class TestTag(unittest.TestCase): + def test___str__(self): + # tag = Tag() + # self.assertEqual(expected, tag.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # tag = Tag() + # self.assertEqual(expected, tag.__unicode__()) + assert True # TODO: implement your test here + +class TestTagHandler(unittest.TestCase): + def test___init__(self): + # tag_handler = TagHandler(obj) + assert True # TODO: implement your test here + + def test___str__(self): + # tag_handler = TagHandler(obj) + # self.assertEqual(expected, tag_handler.__str__()) + assert True # TODO: implement your test here + + def test_add(self): + # tag_handler = TagHandler(obj) + # self.assertEqual(expected, tag_handler.add(tag, category, data)) + assert True # TODO: implement your test here + + def test_all(self): + # tag_handler = TagHandler(obj) + # self.assertEqual(expected, tag_handler.all(category, return_key_and_category)) + assert True # TODO: implement your test here + + def test_clear(self): + # tag_handler = TagHandler(obj) + # self.assertEqual(expected, tag_handler.clear()) + assert True # TODO: implement your test here + + def test_get(self): + # tag_handler = TagHandler(obj) + # self.assertEqual(expected, tag_handler.get(key, category, return_tagobj)) + assert True # TODO: implement your test here + + def test_remove(self): + # tag_handler = TagHandler(obj) + # self.assertEqual(expected, tag_handler.remove(key, category)) + assert True # TODO: implement your test here + +class TestTypedObject(unittest.TestCase): + def test___eq__(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.__eq__(other)) + assert True # TODO: implement your test here + + def test___getattribute__(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.__getattribute__(propname)) + assert True # TODO: implement your test here + + def test___init__(self): + # typed_object = TypedObject(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.__unicode__()) + assert True # TODO: implement your test here + + def test_access(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.access(accessing_obj, access_type, default, **kwargs)) + assert True # TODO: implement your test here + + def test_attr(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.attr(attribute_name, value, delete)) + assert True # TODO: implement your test here + + def test_check_permstring(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.check_permstring(permstring)) + assert True # TODO: implement your test here + + def test_del_attribute(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.del_attribute(attribute_name, raise_exception)) + assert True # TODO: implement your test here + + def test_delete(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.delete(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_flush_from_cache(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.flush_from_cache()) + assert True # TODO: implement your test here + + def test_get_all_attributes(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.get_all_attributes()) + assert True # TODO: implement your test here + + def test_get_attribute(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.get_attribute(attribute_name, default, raise_exception)) + assert True # TODO: implement your test here + + def test_get_attribute_obj(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.get_attribute_obj(attribute_name, default)) + assert True # TODO: implement your test here + + def test_has_attribute(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.has_attribute(attribute_name)) + assert True # TODO: implement your test here + + def test_is_typeclass(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.is_typeclass(typeclass, exact)) + assert True # TODO: implement your test here + + def test_nattr(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.nattr(attribute_name, value, delete)) + assert True # TODO: implement your test here + + def test_secure_attr(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.secure_attr(accessing_object, attribute_name, value, delete, default_access_read, default_access_edit, default_access_create)) + assert True # TODO: implement your test here + + def test_set_attribute(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.set_attribute(attribute_name, new_value, lockstring)) + assert True # TODO: implement your test here + + def test_swap_typeclass(self): + # typed_object = TypedObject(*args, **kwargs) + # self.assertEqual(expected, typed_object.swap_typeclass(new_typeclass, clean_attributes, no_default)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_typeclasses_typeclass.py b/src/tests/test_typeclasses_typeclass.py new file mode 100644 index 0000000000..7d4ef14df7 --- /dev/null +++ b/src/tests/test_typeclasses_typeclass.py @@ -0,0 +1,49 @@ +import unittest + +class TestMetaTypeClass(unittest.TestCase): + def test___init__(self): + # meta_type_class = MetaTypeClass(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # meta_type_class = MetaTypeClass(*args, **kwargs) + # self.assertEqual(expected, meta_type_class.__str__()) + assert True # TODO: implement your test here + +class TestTypeClass(unittest.TestCase): + def test___delattr__(self): + # type_class = TypeClass(dbobj) + # self.assertEqual(expected, type_class.__delattr__(propname)) + assert True # TODO: implement your test here + + def test___eq__(self): + # type_class = TypeClass(dbobj) + # self.assertEqual(expected, type_class.__eq__(other)) + assert True # TODO: implement your test here + + def test___getattribute__(self): + # type_class = TypeClass(dbobj) + # self.assertEqual(expected, type_class.__getattribute__(propname)) + assert True # TODO: implement your test here + + def test___init__(self): + # type_class = TypeClass(dbobj) + assert True # TODO: implement your test here + + def test___setattr__(self): + # type_class = TypeClass(dbobj) + # self.assertEqual(expected, type_class.__setattr__(propname, value)) + assert True # TODO: implement your test here + + def test___str__(self): + # type_class = TypeClass(dbobj) + # self.assertEqual(expected, type_class.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # type_class = TypeClass(dbobj) + # self.assertEqual(expected, type_class.__unicode__()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_ansi.py b/src/tests/test_utils_ansi.py new file mode 100644 index 0000000000..35c7417a25 --- /dev/null +++ b/src/tests/test_utils_ansi.py @@ -0,0 +1,139 @@ +import unittest + +class TestANSIParser(unittest.TestCase): + def test_parse_ansi(self): + # a_nsi_parser = ANSIParser() + # self.assertEqual(expected, a_nsi_parser.parse_ansi(string, strip_ansi, xterm256)) + assert True # TODO: implement your test here + + def test_strip_raw_codes(self): + # a_nsi_parser = ANSIParser() + # self.assertEqual(expected, a_nsi_parser.strip_raw_codes(string)) + assert True # TODO: implement your test here + + def test_sub_ansi(self): + # a_nsi_parser = ANSIParser() + # self.assertEqual(expected, a_nsi_parser.sub_ansi(ansimatch)) + assert True # TODO: implement your test here + + def test_sub_xterm256(self): + # a_nsi_parser = ANSIParser() + # self.assertEqual(expected, a_nsi_parser.sub_xterm256(rgbmatch)) + assert True # TODO: implement your test here + + def test_parse_rgb(self): + # a_nsi_parser = ANSIParser() + # self.assertEqual(expected, a_nsi_parser.parse_rgb(rgbmatch)) + assert True # TODO: implement your test here + +class TestParseAnsi(unittest.TestCase): + def test_parse_ansi(self): + # self.assertEqual(expected, parse_ansi(string, strip_ansi, parser, xterm256)) + assert True # TODO: implement your test here + +class TestRaw(unittest.TestCase): + def test_raw(self): + # self.assertEqual(expected, raw(string)) + assert True # TODO: implement your test here + +class TestGroup(unittest.TestCase): + def test_group(self): + # self.assertEqual(expected, group(lst, n)) + assert True # TODO: implement your test here + +class TestANSIMeta(unittest.TestCase): + def test___init__(self): + # a_nsi_meta = ANSIMeta(*args, **kwargs) + assert True # TODO: implement your test here + +class TestANSIString(unittest.TestCase): + def test___add__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__add__(other)) + assert True # TODO: implement your test here + + def test___getitem__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__getitem__(item)) + assert True # TODO: implement your test here + + def test___getslice__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__getslice__(i, j)) + assert True # TODO: implement your test here + + def test___init__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + assert True # TODO: implement your test here + + def test___new__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + assert True # TODO: implement your test here + + def test___radd__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__radd__(other)) + assert True # TODO: implement your test here + + def test___repr__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__repr__()) + assert True # TODO: implement your test here + + def test___str__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.__unicode__()) + assert True # TODO: implement your test here + + def test_center(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.center(width, fillchar, difference)) + assert True # TODO: implement your test here + + def test_clean(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.clean()) + assert True # TODO: implement your test here + + def test_join(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.join(iterable)) + assert True # TODO: implement your test here + + def test_ljust(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.ljust(width, fillchar, difference)) + assert True # TODO: implement your test here + + def test_partition(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.partition(sep, reverse)) + assert True # TODO: implement your test here + + def test_raw(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.raw()) + assert True # TODO: implement your test here + + def test_rjust(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.rjust(width, fillchar, difference)) + assert True # TODO: implement your test here + + def test_rsplit(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.rsplit(by, maxsplit)) + assert True # TODO: implement your test here + + def test_split(self): + # a_nsi_string = ANSIString(*args, **kwargs) + # self.assertEqual(expected, a_nsi_string.split(by, maxsplit)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_ansi_new.py b/src/tests/test_utils_ansi_new.py new file mode 100644 index 0000000000..c1a1610208 --- /dev/null +++ b/src/tests/test_utils_ansi_new.py @@ -0,0 +1,9 @@ +import unittest + +class TestSubMeth(unittest.TestCase): + def test_sub_meth(self): + # self.assertEqual(expected, sub_meth(obj, function)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_batchprocessors.py b/src/tests/test_utils_batchprocessors.py new file mode 100644 index 0000000000..0bcadebe37 --- /dev/null +++ b/src/tests/test_utils_batchprocessors.py @@ -0,0 +1,36 @@ +import unittest + +class TestReadBatchfile(unittest.TestCase): + def test_read_batchfile(self): + # self.assertEqual(expected, read_batchfile(pythonpath, file_ending)) + assert True # TODO: implement your test here + +class TestBatchCommandProcessor(unittest.TestCase): + def test_parse_file(self): + # batch_command_processor = BatchCommandProcessor() + # self.assertEqual(expected, batch_command_processor.parse_file(pythonpath)) + assert True # TODO: implement your test here + +class TestTbFilename(unittest.TestCase): + def test_tb_filename(self): + # self.assertEqual(expected, tb_filename(tb)) + assert True # TODO: implement your test here + +class TestTbIter(unittest.TestCase): + def test_tb_iter(self): + # self.assertEqual(expected, tb_iter(tb)) + assert True # TODO: implement your test here + +class TestBatchCodeProcessor(unittest.TestCase): + def test_code_exec(self): + # batch_code_processor = BatchCodeProcessor() + # self.assertEqual(expected, batch_code_processor.code_exec(codedict, extra_environ, debug)) + assert True # TODO: implement your test here + + def test_parse_file(self): + # batch_code_processor = BatchCodeProcessor() + # self.assertEqual(expected, batch_code_processor.parse_file(pythonpath)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_create.py b/src/tests/test_utils_create.py new file mode 100644 index 0000000000..5bdf15765f --- /dev/null +++ b/src/tests/test_utils_create.py @@ -0,0 +1,44 @@ +import unittest + +class TestHandleDbref(unittest.TestCase): + def test_handle_dbref(self): + # self.assertEqual(expected, handle_dbref(inp, objclass, raise_errors)) + assert True # TODO: implement your test here + +class TestCreateObject(unittest.TestCase): + def test_create_object(self): + # self.assertEqual(expected, create_object(typeclass, key, location, home, permissions, locks, aliases, destination, report_to, nohome)) + assert True # TODO: implement your test here + +class TestCreateScript(unittest.TestCase): + def test_create_script(self): + # self.assertEqual(expected, create_script(typeclass, key, obj, player, locks, interval, start_delay, repeats, persistent, autostart, report_to)) + assert True # TODO: implement your test here + +class TestCreateHelpEntry(unittest.TestCase): + def test_create_help_entry(self): + # self.assertEqual(expected, create_help_entry(key, entrytext, category, locks)) + assert True # TODO: implement your test here + +class TestCreateMessage(unittest.TestCase): + def test_create_message(self): + # self.assertEqual(expected, create_message(senderobj, message, channels, receivers, locks, header)) + assert True # TODO: implement your test here + +class TestCreateChannel(unittest.TestCase): + def test_create_channel(self): + # self.assertEqual(expected, create_channel(key, aliases, desc, locks, keep_log, typeclass)) + assert True # TODO: implement your test here + +class TestCreateTag(unittest.TestCase): + def test_create_tag(self): + # self.assertEqual(expected, create_tag(self, key, category, data)) + assert True # TODO: implement your test here + +class TestCreatePlayer(unittest.TestCase): + def test_create_player(self): + # self.assertEqual(expected, create_player(key, email, password, typeclass, is_superuser, locks, permissions, report_to)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_dbserialize.py b/src/tests/test_utils_dbserialize.py new file mode 100644 index 0000000000..c7af538484 --- /dev/null +++ b/src/tests/test_utils_dbserialize.py @@ -0,0 +1,124 @@ +import unittest + +class test__SaverMutable(unittest.TestCase): + def test___delitem__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + # self.assertEqual(expected, __saver_mutable.__delitem__(key)) + assert True # TODO: implement your test here + + def test___getitem__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + # self.assertEqual(expected, __saver_mutable.__getitem__(key)) + assert True # TODO: implement your test here + + def test___init__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + assert True # TODO: implement your test here + + def test___iter__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + # self.assertEqual(expected, __saver_mutable.__iter__()) + assert True # TODO: implement your test here + + def test___len__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + # self.assertEqual(expected, __saver_mutable.__len__()) + assert True # TODO: implement your test here + + def test___repr__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + # self.assertEqual(expected, __saver_mutable.__repr__()) + assert True # TODO: implement your test here + + def test___setitem__(self): + # __saver_mutable = _SaverMutable(*args, **kwargs) + # self.assertEqual(expected, __saver_mutable.__setitem__(key, value)) + assert True # TODO: implement your test here + +class test__SaverList(unittest.TestCase): + def test___add__(self): + # __saver_list = _SaverList(*args, **kwargs) + # self.assertEqual(expected, __saver_list.__add__(otherlist)) + assert True # TODO: implement your test here + + def test___init__(self): + # __saver_list = _SaverList(*args, **kwargs) + assert True # TODO: implement your test here + + def test_insert(self): + # __saver_list = _SaverList(*args, **kwargs) + # self.assertEqual(expected, __saver_list.insert(index, value)) + assert True # TODO: implement your test here + +class test__SaverDict(unittest.TestCase): + def test___init__(self): + # __saver_dict = _SaverDict(*args, **kwargs) + assert True # TODO: implement your test here + + def test_has_key(self): + # __saver_dict = _SaverDict(*args, **kwargs) + # self.assertEqual(expected, __saver_dict.has_key(key)) + assert True # TODO: implement your test here + +class test__SaverSet(unittest.TestCase): + def test___contains__(self): + # __saver_set = _SaverSet(*args, **kwargs) + # self.assertEqual(expected, __saver_set.__contains__(value)) + assert True # TODO: implement your test here + + def test___init__(self): + # __saver_set = _SaverSet(*args, **kwargs) + assert True # TODO: implement your test here + + def test_add(self): + # __saver_set = _SaverSet(*args, **kwargs) + # self.assertEqual(expected, __saver_set.add(value)) + assert True # TODO: implement your test here + + def test_discard(self): + # __saver_set = _SaverSet(*args, **kwargs) + # self.assertEqual(expected, __saver_set.discard(value)) + assert True # TODO: implement your test here + +class TestPackDbobj(unittest.TestCase): + def test_pack_dbobj(self): + # self.assertEqual(expected, pack_dbobj(item)) + assert True # TODO: implement your test here + +class TestUnpackDbobj(unittest.TestCase): + def test_unpack_dbobj(self): + # self.assertEqual(expected, unpack_dbobj(item)) + assert True # TODO: implement your test here + +class TestToPickle(unittest.TestCase): + def test_to_pickle(self): + # self.assertEqual(expected, to_pickle(data)) + assert True # TODO: implement your test here + +class TestFromPickle(unittest.TestCase): + def test_from_pickle(self): + # self.assertEqual(expected, from_pickle(data, db_obj)) + assert True # TODO: implement your test here + +class TestDoPickle(unittest.TestCase): + def test_do_pickle(self): + # self.assertEqual(expected, do_pickle(data)) + assert True # TODO: implement your test here + +class TestDoUnpickle(unittest.TestCase): + def test_do_unpickle(self): + # self.assertEqual(expected, do_unpickle(data)) + assert True # TODO: implement your test here + +class TestDbserialize(unittest.TestCase): + def test_dbserialize(self): + # self.assertEqual(expected, dbserialize(data)) + assert True # TODO: implement your test here + +class TestDbunserialize(unittest.TestCase): + def test_dbunserialize(self): + # self.assertEqual(expected, dbunserialize(data, db_obj)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_evform.py b/src/tests/test_utils_evform.py new file mode 100644 index 0000000000..80d9d89a31 --- /dev/null +++ b/src/tests/test_utils_evform.py @@ -0,0 +1,29 @@ +import unittest + +class TestEvForm(unittest.TestCase): + def test___init__(self): + # ev_form = EvForm(filename, cells, tables, form, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # ev_form = EvForm(filename, cells, tables, form, **kwargs) + # self.assertEqual(expected, ev_form.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # ev_form = EvForm(filename, cells, tables, form, **kwargs) + # self.assertEqual(expected, ev_form.__unicode__()) + assert True # TODO: implement your test here + + def test_map(self): + # ev_form = EvForm(filename, cells, tables, form, **kwargs) + # self.assertEqual(expected, ev_form.map(cells, tables, **kwargs)) + assert True # TODO: implement your test here + + def test_reload(self): + # ev_form = EvForm(filename, cells, tables, form, **kwargs) + # self.assertEqual(expected, ev_form.reload(filename, form, **kwargs)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_evtable.py b/src/tests/test_utils_evtable.py new file mode 100644 index 0000000000..2eb7ab446d --- /dev/null +++ b/src/tests/test_utils_evtable.py @@ -0,0 +1,109 @@ +import unittest + +class TestMakeIter(unittest.TestCase): + def test_make_iter(self): + # self.assertEqual(expected, make_iter(obj)) + assert True # TODO: implement your test here + +class TestWrap(unittest.TestCase): + def test_wrap(self): + # self.assertEqual(expected, wrap(text, width, **kwargs)) + assert True # TODO: implement your test here + +class TestFill(unittest.TestCase): + def test_fill(self): + # self.assertEqual(expected, fill(text, width, **kwargs)) + assert True # TODO: implement your test here + +class TestCell(unittest.TestCase): + def test___init__(self): + # cell = Cell(data, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.__unicode__()) + assert True # TODO: implement your test here + + def test_get(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.get()) + assert True # TODO: implement your test here + + def test_get_height(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.get_height()) + assert True # TODO: implement your test here + + def test_get_min_height(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.get_min_height()) + assert True # TODO: implement your test here + + def test_get_min_width(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.get_min_width()) + assert True # TODO: implement your test here + + def test_get_width(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.get_width()) + assert True # TODO: implement your test here + + def test_reformat(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.reformat(**kwargs)) + assert True # TODO: implement your test here + + def test_replace_data(self): + # cell = Cell(data, **kwargs) + # self.assertEqual(expected, cell.replace_data(data, **kwargs)) + assert True # TODO: implement your test here + +class TestEvTable(unittest.TestCase): + def test___init__(self): + # ev_table = EvTable(*args, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.__unicode__()) + assert True # TODO: implement your test here + + def test_add_column(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.add_column(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_add_header(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.add_header(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_add_row(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.add_row(*args, **kwargs)) + assert True # TODO: implement your test here + + def test_get(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.get()) + assert True # TODO: implement your test here + + def test_reformat(self): + # ev_table = EvTable(*args, **kwargs) + # self.assertEqual(expected, ev_table.reformat(**kwargs)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_gametime.py b/src/tests/test_utils_gametime.py new file mode 100644 index 0000000000..bec50c2cb8 --- /dev/null +++ b/src/tests/test_utils_gametime.py @@ -0,0 +1,55 @@ +import unittest + +class TestGameTime(unittest.TestCase): + def test_at_repeat(self): + # game_time = GameTime() + # self.assertEqual(expected, game_time.at_repeat()) + assert True # TODO: implement your test here + + def test_at_script_creation(self): + # game_time = GameTime() + # self.assertEqual(expected, game_time.at_script_creation()) + assert True # TODO: implement your test here + + def test_at_start(self): + # game_time = GameTime() + # self.assertEqual(expected, game_time.at_start()) + assert True # TODO: implement your test here + +class TestSave(unittest.TestCase): + def test_save(self): + # self.assertEqual(expected, save()) + assert True # TODO: implement your test here + +class TestRuntime(unittest.TestCase): + def test_runtime(self): + # self.assertEqual(expected, runtime(format)) + assert True # TODO: implement your test here + +class TestUptime(unittest.TestCase): + def test_uptime(self): + # self.assertEqual(expected, uptime(format)) + assert True # TODO: implement your test here + +class TestGametime(unittest.TestCase): + def test_gametime(self): + # self.assertEqual(expected, gametime(format)) + assert True # TODO: implement your test here + +class TestGametimeToRealtime(unittest.TestCase): + def test_gametime_to_realtime(self): + # self.assertEqual(expected, gametime_to_realtime(secs, mins, hrs, days, weeks, months, yrs, format)) + assert True # TODO: implement your test here + +class TestRealtimeToGametime(unittest.TestCase): + def test_realtime_to_gametime(self): + # self.assertEqual(expected, realtime_to_gametime(secs, mins, hrs, days, weeks, months, yrs, format)) + assert True # TODO: implement your test here + +class TestInitGametime(unittest.TestCase): + def test_init_gametime(self): + # self.assertEqual(expected, init_gametime()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_logger.py b/src/tests/test_utils_logger.py new file mode 100644 index 0000000000..ceda404506 --- /dev/null +++ b/src/tests/test_utils_logger.py @@ -0,0 +1,29 @@ +import unittest + +class TestLogTrace(unittest.TestCase): + def test_log_trace(self): + # self.assertEqual(expected, log_trace(errmsg)) + assert True # TODO: implement your test here + +class TestLogErrmsg(unittest.TestCase): + def test_log_errmsg(self): + # self.assertEqual(expected, log_errmsg(errmsg)) + assert True # TODO: implement your test here + +class TestLogWarnmsg(unittest.TestCase): + def test_log_warnmsg(self): + # self.assertEqual(expected, log_warnmsg(warnmsg)) + assert True # TODO: implement your test here + +class TestLogInfomsg(unittest.TestCase): + def test_log_infomsg(self): + # self.assertEqual(expected, log_infomsg(infomsg)) + assert True # TODO: implement your test here + +class TestLogDepmsg(unittest.TestCase): + def test_log_depmsg(self): + # self.assertEqual(expected, log_depmsg(depmsg)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_picklefield.py b/src/tests/test_utils_picklefield.py new file mode 100644 index 0000000000..7087ffc57a --- /dev/null +++ b/src/tests/test_utils_picklefield.py @@ -0,0 +1,64 @@ +import unittest + +class test__ObjectWrapper(unittest.TestCase): + def test___init__(self): + # __object_wrapper = _ObjectWrapper(obj) + assert True # TODO: implement your test here + +class TestWrapConflictualObject(unittest.TestCase): + def test_wrap_conflictual_object(self): + # self.assertEqual(expected, wrap_conflictual_object(obj)) + assert True # TODO: implement your test here + +class TestDbsafeEncode(unittest.TestCase): + def test_dbsafe_encode(self): + # self.assertEqual(expected, dbsafe_encode(value, compress_object, pickle_protocol)) + assert True # TODO: implement your test here + +class TestDbsafeDecode(unittest.TestCase): + def test_dbsafe_decode(self): + # self.assertEqual(expected, dbsafe_decode(value, compress_object)) + assert True # TODO: implement your test here + +class TestPickledObjectField(unittest.TestCase): + def test___init__(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + assert True # TODO: implement your test here + + def test_get_db_prep_lookup(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.get_db_prep_lookup(lookup_type, value, connection, prepared)) + assert True # TODO: implement your test here + + def test_get_db_prep_value(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.get_db_prep_value(value, connection, prepared)) + assert True # TODO: implement your test here + + def test_get_default(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.get_default()) + assert True # TODO: implement your test here + + def test_get_internal_type(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.get_internal_type()) + assert True # TODO: implement your test here + + def test_pre_save(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.pre_save(model_instance, add)) + assert True # TODO: implement your test here + + def test_to_python(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.to_python(value)) + assert True # TODO: implement your test here + + def test_value_to_string(self): + # pickled_object_field = PickledObjectField(*args, **kwargs) + # self.assertEqual(expected, pickled_object_field.value_to_string(obj)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_prettytable.py b/src/tests/test_utils_prettytable.py new file mode 100644 index 0000000000..97ec4de1c3 --- /dev/null +++ b/src/tests/test_utils_prettytable.py @@ -0,0 +1,134 @@ +import unittest + +class TestPrettyTable(unittest.TestCase): + def test___getattr__(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.__getattr__(name)) + assert True # TODO: implement your test here + + def test___getitem__(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.__getitem__(index)) + assert True # TODO: implement your test here + + def test___init__(self): + # pretty_table = PrettyTable(field_names, **kwargs) + assert True # TODO: implement your test here + + def test___str__(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.__str__()) + assert True # TODO: implement your test here + + def test___str___case_2(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.__str__()) + assert True # TODO: implement your test here + + def test___unicode__(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.__unicode__()) + assert True # TODO: implement your test here + + def test_add_column(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.add_column(fieldname, column, align, valign)) + assert True # TODO: implement your test here + + def test_add_row(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.add_row(row)) + assert True # TODO: implement your test here + + def test_clear(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.clear()) + assert True # TODO: implement your test here + + def test_clear_rows(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.clear_rows()) + assert True # TODO: implement your test here + + def test_copy(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.copy()) + assert True # TODO: implement your test here + + def test_del_row(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.del_row(row_index)) + assert True # TODO: implement your test here + + def test_get_html_string(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.get_html_string(**kwargs)) + assert True # TODO: implement your test here + + def test_get_string(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.get_string(**kwargs)) + assert True # TODO: implement your test here + + def test_set_style(self): + # pretty_table = PrettyTable(field_names, **kwargs) + # self.assertEqual(expected, pretty_table.set_style(style)) + assert True # TODO: implement your test here + +class TestFromCsv(unittest.TestCase): + def test_from_csv(self): + # self.assertEqual(expected, from_csv(fp, field_names, **kwargs)) + assert True # TODO: implement your test here + +class TestFromDbCursor(unittest.TestCase): + def test_from_db_cursor(self): + # self.assertEqual(expected, from_db_cursor(cursor, **kwargs)) + assert True # TODO: implement your test here + +class TestTableHandler(unittest.TestCase): + def test___init__(self): + # table_handler = TableHandler(**kwargs) + assert True # TODO: implement your test here + + def test_generate_table(self): + # table_handler = TableHandler(**kwargs) + # self.assertEqual(expected, table_handler.generate_table(rows)) + assert True # TODO: implement your test here + + def test_handle_data(self): + # table_handler = TableHandler(**kwargs) + # self.assertEqual(expected, table_handler.handle_data(data)) + assert True # TODO: implement your test here + + def test_handle_endtag(self): + # table_handler = TableHandler(**kwargs) + # self.assertEqual(expected, table_handler.handle_endtag(tag)) + assert True # TODO: implement your test here + + def test_handle_starttag(self): + # table_handler = TableHandler(**kwargs) + # self.assertEqual(expected, table_handler.handle_starttag(tag, attrs)) + assert True # TODO: implement your test here + + def test_make_fields_unique(self): + # table_handler = TableHandler(**kwargs) + # self.assertEqual(expected, table_handler.make_fields_unique(fields)) + assert True # TODO: implement your test here + +class TestFromHtml(unittest.TestCase): + def test_from_html(self): + # self.assertEqual(expected, from_html(html_code, **kwargs)) + assert True # TODO: implement your test here + +class TestFromHtmlOne(unittest.TestCase): + def test_from_html_one(self): + # self.assertEqual(expected, from_html_one(html_code, **kwargs)) + assert True # TODO: implement your test here + +class TestMain(unittest.TestCase): + def test_main(self): + # self.assertEqual(expected, main()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_search.py b/src/tests/test_utils_search.py new file mode 100644 index 0000000000..40d6e1a281 --- /dev/null +++ b/src/tests/test_utils_search.py @@ -0,0 +1,24 @@ +import unittest + +class TestSearchObjectTag(unittest.TestCase): + def test_search_object_tag(self): + # self.assertEqual(expected, search_object_tag(key, category)) + assert True # TODO: implement your test here + +class TestSearchPlayerTag(unittest.TestCase): + def test_search_player_tag(self): + # self.assertEqual(expected, search_player_tag(key, category)) + assert True # TODO: implement your test here + +class TestSearchScriptTag(unittest.TestCase): + def test_search_script_tag(self): + # self.assertEqual(expected, search_script_tag(key, category)) + assert True # TODO: implement your test here + +class TestSearchChannelTag(unittest.TestCase): + def test_search_channel_tag(self): + # self.assertEqual(expected, search_channel_tag(key, category)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_tests.py b/src/tests/test_utils_tests.py new file mode 100644 index 0000000000..9fd6ea5f19 --- /dev/null +++ b/src/tests/test_utils_tests.py @@ -0,0 +1,40 @@ +import unittest + +class TestANSIStringTestCase(unittest.TestCase): + def test_checker(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.checker(ansi, raw, clean)) + assert True # TODO: implement your test here + + def test_table_check(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.table_check(ansi, char, code)) + assert True # TODO: implement your test here + + def test_test_instance(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.test_instance()) + assert True # TODO: implement your test here + + def test_test_join(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.test_join()) + assert True # TODO: implement your test here + + def test_test_len(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.test_len()) + assert True # TODO: implement your test here + + def test_test_slice(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.test_slice()) + assert True # TODO: implement your test here + + def test_test_split(self): + # a_nsi_string_test_case = ANSIStringTestCase() + # self.assertEqual(expected, a_nsi_string_test_case.test_split()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_text2html.py b/src/tests/test_utils_text2html.py new file mode 100644 index 0000000000..6cbdc98f84 --- /dev/null +++ b/src/tests/test_utils_text2html.py @@ -0,0 +1,55 @@ +import unittest + +class TestTextToHTMLparser(unittest.TestCase): + def test_convert_linebreaks(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.convert_linebreaks(text)) + assert True # TODO: implement your test here + + def test_convert_urls(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.convert_urls(text)) + assert True # TODO: implement your test here + + def test_do_sub(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.do_sub(m)) + assert True # TODO: implement your test here + + def test_parse(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.parse(text, strip_ansi)) + assert True # TODO: implement your test here + + def test_re_bold(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.re_bold(text)) + assert True # TODO: implement your test here + + def test_re_color(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.re_color(text)) + assert True # TODO: implement your test here + + def test_re_underline(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.re_underline(text)) + assert True # TODO: implement your test here + + def test_remove_backspaces(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.remove_backspaces(text)) + assert True # TODO: implement your test here + + def test_remove_bells(self): + # text_to_htm_lparser = TextToHTMLparser() + # self.assertEqual(expected, text_to_htm_lparser.remove_bells(text)) + assert True # TODO: implement your test here + +class TestParseHtml(unittest.TestCase): + def test_parse_html(self): + # self.assertEqual(expected, parse_html(string, strip_ansi, parser)) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main() diff --git a/src/tests/test_utils_utils.py b/src/tests/test_utils_utils.py new file mode 100644 index 0000000000..36f201bda6 --- /dev/null +++ b/src/tests/test_utils_utils.py @@ -0,0 +1,159 @@ +import unittest + +class TestIsIter(unittest.TestCase): + def test_is_iter(self): + # self.assertEqual(expected, is_iter(iterable)) + assert True # TODO: implement your test here + +class TestCrop(unittest.TestCase): + def test_crop(self): + # self.assertEqual(expected, crop(text, width, suffix)) + assert True # TODO: implement your test here + +class TestDedent(unittest.TestCase): + def test_dedent(self): + # self.assertEqual(expected, dedent(text)) + assert True # TODO: implement your test here + +class TestListToString(unittest.TestCase): + def test_list_to_string(self): + # self.assertEqual(expected, list_to_string(inlist, endsep, addquote)) + assert True # TODO: implement your test here + +class TestWildcardToRegexp(unittest.TestCase): + def test_wildcard_to_regexp(self): + # self.assertEqual(expected, wildcard_to_regexp(instring)) + assert True # TODO: implement your test here + +class TestTimeFormat(unittest.TestCase): + def test_time_format(self): + # self.assertEqual(expected, time_format(seconds, style)) + assert True # TODO: implement your test here + +class TestDatetimeFormat(unittest.TestCase): + def test_datetime_format(self): + # self.assertEqual(expected, datetime_format(dtobj)) + assert True # TODO: implement your test here + +class TestHostOsIs(unittest.TestCase): + def test_host_os_is(self): + # self.assertEqual(expected, host_os_is(osname)) + assert True # TODO: implement your test here + +class TestGetEvenniaVersion(unittest.TestCase): + def test_get_evennia_version(self): + # self.assertEqual(expected, get_evennia_version()) + assert True # TODO: implement your test here + +class TestPypathToRealpath(unittest.TestCase): + def test_pypath_to_realpath(self): + # self.assertEqual(expected, pypath_to_realpath(python_path, file_ending)) + assert True # TODO: implement your test here + +class TestToUnicode(unittest.TestCase): + def test_to_unicode(self): + # self.assertEqual(expected, to_unicode(obj, encoding, force_string)) + assert True # TODO: implement your test here + +class TestToStr(unittest.TestCase): + def test_to_str(self): + # self.assertEqual(expected, to_str(obj, encoding, force_string)) + assert True # TODO: implement your test here + +class TestValidateEmailAddress(unittest.TestCase): + def test_validate_email_address(self): + # self.assertEqual(expected, validate_email_address(emailaddress)) + assert True # TODO: implement your test here + +class TestInheritsFrom(unittest.TestCase): + def test_inherits_from(self): + # self.assertEqual(expected, inherits_from(obj, parent)) + assert True # TODO: implement your test here + +class TestServerServices(unittest.TestCase): + def test_server_services(self): + # self.assertEqual(expected, server_services()) + assert True # TODO: implement your test here + +class TestUsesDatabase(unittest.TestCase): + def test_uses_database(self): + # self.assertEqual(expected, uses_database(name)) + assert True # TODO: implement your test here + +class TestDelay(unittest.TestCase): + def test_delay(self): + # self.assertEqual(expected, delay(delay, callback, retval)) + assert True # TODO: implement your test here + +class TestCleanObjectCaches(unittest.TestCase): + def test_clean_object_caches(self): + # self.assertEqual(expected, clean_object_caches(obj)) + assert True # TODO: implement your test here + +class TestRunAsync(unittest.TestCase): + def test_run_async(self): + # self.assertEqual(expected, run_async(to_execute, *args, **kwargs)) + assert True # TODO: implement your test here + +class TestCheckEvenniaDependencies(unittest.TestCase): + def test_check_evennia_dependencies(self): + # self.assertEqual(expected, check_evennia_dependencies()) + assert True # TODO: implement your test here + +class TestHasParent(unittest.TestCase): + def test_has_parent(self): + # self.assertEqual(expected, has_parent(basepath, obj)) + assert True # TODO: implement your test here + +class TestModImport(unittest.TestCase): + def test_mod_import(self): + # self.assertEqual(expected, mod_import(module)) + assert True # TODO: implement your test here + +class TestAllFromModule(unittest.TestCase): + def test_all_from_module(self): + # self.assertEqual(expected, all_from_module(module)) + assert True # TODO: implement your test here + +class TestVariableFromModule(unittest.TestCase): + def test_variable_from_module(self): + # self.assertEqual(expected, variable_from_module(module, variable, default)) + assert True # TODO: implement your test here + +class TestStringFromModule(unittest.TestCase): + def test_string_from_module(self): + # self.assertEqual(expected, string_from_module(module, variable, default)) + assert True # TODO: implement your test here + +class TestInitNewPlayer(unittest.TestCase): + def test_init_new_player(self): + # self.assertEqual(expected, init_new_player(player)) + assert True # TODO: implement your test here + +class TestStringSimilarity(unittest.TestCase): + def test_string_similarity(self): + # self.assertEqual(expected, string_similarity(string1, string2)) + assert True # TODO: implement your test here + +class TestStringSuggestions(unittest.TestCase): + def test_string_suggestions(self): + # self.assertEqual(expected, string_suggestions(string, vocabulary, cutoff, maxnum)) + assert True # TODO: implement your test here + +class TestStringPartialMatching(unittest.TestCase): + def test_string_partial_matching(self): + # self.assertEqual(expected, string_partial_matching(alternatives, inp, ret_index)) + assert True # TODO: implement your test here + +class TestFormatTable(unittest.TestCase): + def test_format_table(self): + # self.assertEqual(expected, format_table(table, extra_space)) + assert True # TODO: implement your test here + +class TestGetEvenniaPids(unittest.TestCase): + def test_get_evennia_pids(self): + # self.assertEqual(expected, get_evennia_pids()) + assert True # TODO: implement your test here + +if __name__ == '__main__': + unittest.main()