diff --git a/evennia/tests/test_commands_cmdhandler.py b/evennia/tests/test_commands_cmdhandler.py deleted file mode 100644 index 4bc11b7e4b..0000000000 --- a/evennia/tests/test_commands_cmdhandler.py +++ /dev/null @@ -1,14 +0,0 @@ -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/evennia/tests/test_commands_cmdparser.py b/evennia/tests/test_commands_cmdparser.py deleted file mode 100644 index d6bf2e26d3..0000000000 --- a/evennia/tests/test_commands_cmdparser.py +++ /dev/null @@ -1,24 +0,0 @@ -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/evennia/tests/test_commands_cmdset.py b/evennia/tests/test_commands_cmdset.py deleted file mode 100644 index e5bf82445e..0000000000 --- a/evennia/tests/test_commands_cmdset.py +++ /dev/null @@ -1,74 +0,0 @@ -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/evennia/tests/test_commands_cmdsethandler.py b/evennia/tests/test_commands_cmdsethandler.py deleted file mode 100644 index 8a84b95010..0000000000 --- a/evennia/tests/test_commands_cmdsethandler.py +++ /dev/null @@ -1,64 +0,0 @@ -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/evennia/tests/test_commands_command.py b/evennia/tests/test_commands_command.py deleted file mode 100644 index 540002b373..0000000000 --- a/evennia/tests/test_commands_command.py +++ /dev/null @@ -1,69 +0,0 @@ -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/evennia/tests/test_comms_channelhandler.py b/evennia/tests/test_comms_channelhandler.py deleted file mode 100644 index e93edb31b4..0000000000 --- a/evennia/tests/test_comms_channelhandler.py +++ /dev/null @@ -1,45 +0,0 @@ -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/evennia/tests/test_comms_comms.py b/evennia/tests/test_comms_comms.py deleted file mode 100644 index baace85183..0000000000 --- a/evennia/tests/test_comms_comms.py +++ /dev/null @@ -1,90 +0,0 @@ -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/evennia/tests/test_comms_models.py b/evennia/tests/test_comms_models.py deleted file mode 100644 index 8ff6498828..0000000000 --- a/evennia/tests/test_comms_models.py +++ /dev/null @@ -1,84 +0,0 @@ -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/evennia/tests/test_locks_lockfuncs.py b/evennia/tests/test_locks_lockfuncs.py deleted file mode 100644 index 3bb937bcba..0000000000 --- a/evennia/tests/test_locks_lockfuncs.py +++ /dev/null @@ -1,129 +0,0 @@ -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/evennia/tests/test_locks_lockhandler.py b/evennia/tests/test_locks_lockhandler.py deleted file mode 100644 index 93a87b9d2e..0000000000 --- a/evennia/tests/test_locks_lockhandler.py +++ /dev/null @@ -1,59 +0,0 @@ -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)) - 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)) - 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/evennia/tests/test_objects_models.py b/evennia/tests/test_objects_models.py deleted file mode 100644 index 83ee5096f4..0000000000 --- a/evennia/tests/test_objects_models.py +++ /dev/null @@ -1,64 +0,0 @@ -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/evennia/tests/test_objects_objects.py b/evennia/tests/test_objects_objects.py deleted file mode 100644 index a09aa9eb52..0000000000 --- a/evennia/tests/test_objects_objects.py +++ /dev/null @@ -1,302 +0,0 @@ -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(**kwargs)) - 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(**kwargs)) - 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/evennia/tests/test_players_bots.py b/evennia/tests/test_players_bots.py deleted file mode 100644 index c8740a4d63..0000000000 --- a/evennia/tests/test_players_bots.py +++ /dev/null @@ -1,106 +0,0 @@ -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/evennia/tests/test_players_models.py b/evennia/tests/test_players_models.py deleted file mode 100644 index 8328d323b5..0000000000 --- a/evennia/tests/test_players_models.py +++ /dev/null @@ -1,94 +0,0 @@ -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/evennia/tests/test_scripts_models.py b/evennia/tests/test_scripts_models.py index c9d460d9a5..b1d18d6c42 100644 --- a/evennia/tests/test_scripts_models.py +++ b/evennia/tests/test_scripts_models.py @@ -31,12 +31,6 @@ class TestScriptDB(TestCase): self.scr.delete() self.scr.delete() - #@unittest.skip("not implemented") - #def test___init__fails(self): # Users should be told not to do this - # - No they should not; ScriptDB() is required internally. /Griatch - # with self.assertRaises(Exception): - # ScriptDB() - def test_deleted_script_fails_start(self): "Would it ever be necessary to start a deleted script?" self.scr.delete() @@ -49,7 +43,3 @@ class TestScriptDB(TestCase): "Can deleted scripts be said to be valid?" self.scr.delete() self.assertFalse(self.scr.is_valid()) # assertRaises? See issue #509 - - -if __name__ == '__main__': - unittest.main() diff --git a/evennia/tests/test_scripts_scripthandler.py b/evennia/tests/test_scripts_scripthandler.py deleted file mode 100644 index e3fc0b3dbc..0000000000 --- a/evennia/tests/test_scripts_scripthandler.py +++ /dev/null @@ -1,44 +0,0 @@ -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/evennia/tests/test_scripts_scripts.py b/evennia/tests/test_scripts_scripts.py deleted file mode 100644 index c3bfa10d5d..0000000000 --- a/evennia/tests/test_scripts_scripts.py +++ /dev/null @@ -1,181 +0,0 @@ -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/evennia/tests/test_scripts_tickerhandler.py b/evennia/tests/test_scripts_tickerhandler.py deleted file mode 100644 index f301ab637b..0000000000 --- a/evennia/tests/test_scripts_tickerhandler.py +++ /dev/null @@ -1,84 +0,0 @@ -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/evennia/tests/test_server_amp.py b/evennia/tests/test_server_amp.py deleted file mode 100644 index 21b31fbbfe..0000000000 --- a/evennia/tests/test_server_amp.py +++ /dev/null @@ -1,125 +0,0 @@ -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/evennia/tests/test_server_caches.py b/evennia/tests/test_server_caches.py deleted file mode 100644 index 40d366a00b..0000000000 --- a/evennia/tests/test_server_caches.py +++ /dev/null @@ -1,54 +0,0 @@ -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/evennia/tests/test_server_initial_setup.py b/evennia/tests/test_server_initial_setup.py deleted file mode 100644 index 3dda142df5..0000000000 --- a/evennia/tests/test_server_initial_setup.py +++ /dev/null @@ -1,54 +0,0 @@ -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/evennia/tests/test_server_manager.py b/evennia/tests/test_server_manager.py deleted file mode 100644 index 8b8b5fadf3..0000000000 --- a/evennia/tests/test_server_manager.py +++ /dev/null @@ -1,15 +0,0 @@ -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/evennia/tests/test_server_models.py b/evennia/tests/test_server_models.py deleted file mode 100644 index bd053c8f59..0000000000 --- a/evennia/tests/test_server_models.py +++ /dev/null @@ -1,15 +0,0 @@ -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/evennia/tests/test_server_oob_msdp.py b/evennia/tests/test_server_oob_msdp.py deleted file mode 100644 index 51bb5d22ea..0000000000 --- a/evennia/tests/test_server_oob_msdp.py +++ /dev/null @@ -1,49 +0,0 @@ -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/evennia/tests/test_server_oobhandler.py b/evennia/tests/test_server_oobhandler.py deleted file mode 100644 index fc386c1225..0000000000 --- a/evennia/tests/test_server_oobhandler.py +++ /dev/null @@ -1,114 +0,0 @@ -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/evennia/tests/test_server_server.py b/evennia/tests/test_server_server.py deleted file mode 100644 index 66e6080c46..0000000000 --- a/evennia/tests/test_server_server.py +++ /dev/null @@ -1,39 +0,0 @@ -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/evennia/tests/test_server_serversession.py b/evennia/tests/test_server_serversession.py deleted file mode 100644 index b5526b3a32..0000000000 --- a/evennia/tests/test_server_serversession.py +++ /dev/null @@ -1,104 +0,0 @@ -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(**kwargs)) - 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/evennia/tests/test_server_session.py b/evennia/tests/test_server_session.py deleted file mode 100644 index cf96cbaf81..0000000000 --- a/evennia/tests/test_server_session.py +++ /dev/null @@ -1,40 +0,0 @@ -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/evennia/tests/test_server_webserver.py b/evennia/tests/test_server_webserver.py deleted file mode 100644 index c2a9d36029..0000000000 --- a/evennia/tests/test_server_webserver.py +++ /dev/null @@ -1,46 +0,0 @@ -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/evennia/tests/test_typeclasses_models.py b/evennia/tests/test_typeclasses_models.py deleted file mode 100644 index ef4e2b3295..0000000000 --- a/evennia/tests/test_typeclasses_models.py +++ /dev/null @@ -1,266 +0,0 @@ -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/evennia/tests/test_typeclasses_typeclass.py b/evennia/tests/test_typeclasses_typeclass.py deleted file mode 100644 index 7d4ef14df7..0000000000 --- a/evennia/tests/test_typeclasses_typeclass.py +++ /dev/null @@ -1,49 +0,0 @@ -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/evennia/tests/test_utils_ansi.py b/evennia/tests/test_utils_ansi.py deleted file mode 100644 index 35c7417a25..0000000000 --- a/evennia/tests/test_utils_ansi.py +++ /dev/null @@ -1,139 +0,0 @@ -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/evennia/tests/test_utils_ansi_new.py b/evennia/tests/test_utils_ansi_new.py deleted file mode 100644 index c1a1610208..0000000000 --- a/evennia/tests/test_utils_ansi_new.py +++ /dev/null @@ -1,9 +0,0 @@ -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/evennia/tests/test_utils_batchprocessors.py b/evennia/tests/test_utils_batchprocessors.py deleted file mode 100644 index 0bcadebe37..0000000000 --- a/evennia/tests/test_utils_batchprocessors.py +++ /dev/null @@ -1,36 +0,0 @@ -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/evennia/tests/test_utils_create.py b/evennia/tests/test_utils_create.py deleted file mode 100644 index 5bdf15765f..0000000000 --- a/evennia/tests/test_utils_create.py +++ /dev/null @@ -1,44 +0,0 @@ -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/evennia/tests/test_utils_dbserialize.py b/evennia/tests/test_utils_dbserialize.py deleted file mode 100644 index c7af538484..0000000000 --- a/evennia/tests/test_utils_dbserialize.py +++ /dev/null @@ -1,124 +0,0 @@ -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/evennia/tests/test_utils_evform.py b/evennia/tests/test_utils_evform.py deleted file mode 100644 index 80d9d89a31..0000000000 --- a/evennia/tests/test_utils_evform.py +++ /dev/null @@ -1,29 +0,0 @@ -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/evennia/tests/test_utils_evtable.py b/evennia/tests/test_utils_evtable.py deleted file mode 100644 index 2eb7ab446d..0000000000 --- a/evennia/tests/test_utils_evtable.py +++ /dev/null @@ -1,109 +0,0 @@ -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/evennia/tests/test_utils_gametime.py b/evennia/tests/test_utils_gametime.py deleted file mode 100644 index bec50c2cb8..0000000000 --- a/evennia/tests/test_utils_gametime.py +++ /dev/null @@ -1,55 +0,0 @@ -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/evennia/tests/test_utils_logger.py b/evennia/tests/test_utils_logger.py deleted file mode 100644 index ceda404506..0000000000 --- a/evennia/tests/test_utils_logger.py +++ /dev/null @@ -1,29 +0,0 @@ -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/evennia/tests/test_utils_picklefield.py b/evennia/tests/test_utils_picklefield.py deleted file mode 100644 index 7087ffc57a..0000000000 --- a/evennia/tests/test_utils_picklefield.py +++ /dev/null @@ -1,64 +0,0 @@ -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/evennia/tests/test_utils_prettytable.py b/evennia/tests/test_utils_prettytable.py deleted file mode 100644 index 97ec4de1c3..0000000000 --- a/evennia/tests/test_utils_prettytable.py +++ /dev/null @@ -1,134 +0,0 @@ -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/evennia/tests/test_utils_search.py b/evennia/tests/test_utils_search.py deleted file mode 100644 index 40d6e1a281..0000000000 --- a/evennia/tests/test_utils_search.py +++ /dev/null @@ -1,24 +0,0 @@ -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/evennia/tests/test_utils_tests.py b/evennia/tests/test_utils_tests.py deleted file mode 100644 index 9fd6ea5f19..0000000000 --- a/evennia/tests/test_utils_tests.py +++ /dev/null @@ -1,40 +0,0 @@ -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/evennia/tests/test_utils_text2html.py b/evennia/tests/test_utils_text2html.py deleted file mode 100644 index 6cbdc98f84..0000000000 --- a/evennia/tests/test_utils_text2html.py +++ /dev/null @@ -1,55 +0,0 @@ -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/evennia/tests/test_utils_utils.py b/evennia/tests/test_utils_utils.py index 3e2ca519f5..44680c674d 100644 --- a/evennia/tests/test_utils_utils.py +++ b/evennia/tests/test_utils_utils.py @@ -56,141 +56,3 @@ class TestListToString(unittest.TestCase): self.assertEqual('1, 2 and 3', utils.list_to_string([1,2,3])) self.assertEqual('"1", "2" and "3"', utils.list_to_string([1,2,3], endsep="and", addquote=True)) - -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()