From 37e70cc7fa713bf87d37e8d4966b91bdd1dac49b Mon Sep 17 00:00:00 2001 From: ChrisLR Date: Tue, 2 Jan 2024 11:35:11 -0500 Subject: [PATCH] Rewrote test assertions to django style --- .../contrib/base_systems/components/tests.py | 156 +++++++++--------- 1 file changed, 78 insertions(+), 78 deletions(-) diff --git a/evennia/contrib/base_systems/components/tests.py b/evennia/contrib/base_systems/components/tests.py index c4ff6a95c9..79ccf1bbbd 100644 --- a/evennia/contrib/base_systems/components/tests.py +++ b/evennia/contrib/base_systems/components/tests.py @@ -68,28 +68,28 @@ class TestComponents(EvenniaTest): character_typeclass = CharacterWithComponents def test_character_has_class_components(self): - assert self.char1.test_a - assert self.char1.test_b + self.assertTrue(self.char1.test_a) + self.assertTrue(self.char1.test_b) def test_inherited_typeclass_does_not_include_child_class_components(self): char_with_c = create.create_object( InheritedTCWithComponents, key="char_with_c", location=self.room1, home=self.room1 ) - assert self.char1.test_a - assert not self.char1.cmp.get("test_c") - assert char_with_c.test_c + self.assertTrue(self.char1.test_a) + self.assertFalse(self.char1.cmp.get("test_c")) + self.assertTrue(char_with_c.test_c) def test_character_instances_components_properly(self): - assert isinstance(self.char1.test_a, ComponentTestA) - assert isinstance(self.char1.test_b, ComponentTestB) + self.assertIsInstance(self.char1.test_a, ComponentTestA) + self.assertIsInstance(self.char1.test_b, ComponentTestB) def test_character_assigns_default_value(self): - assert self.char1.test_a.my_int == 1 - assert self.char1.test_a.my_list == [] + self.assertEquals(self.char1.test_a.my_int, 1) + self.assertEquals(self.char1.test_a.my_list, []) def test_character_assigns_default_provided_values(self): - assert self.char1.test_b.my_int == 3 - assert self.char1.test_b.my_list == [1, 2, 3] + self.assertEquals(self.char1.test_b.my_int, 3) + self.assertEquals(self.char1.test_b.my_list, [1, 2, 3]) def test_component_inheritance_assigns_proper_values(self): self.assertEquals(self.char1.ic_a.my_int, 1) @@ -103,25 +103,25 @@ class TestComponents(EvenniaTest): self.char1.components.add(rct) test_c = self.char1.components.get("test_c") - assert test_c - assert test_c.my_int == 6 - assert test_c.my_dict == {} + self.assertTrue(test_c) + self.assertEquals(test_c.my_int, 6) + self.assertEquals(test_c.my_dict, {}) def test_handler_can_add_default_component(self): self.char1.components.add_default("test_c") test_c = self.char1.components.get("test_c") - assert test_c - assert test_c.my_int == 6 + self.assertTrue(test_c) + self.assertEquals(test_c.my_int, 6) def test_handler_has_returns_true_for_any_components(self): rct = RuntimeComponentTestC.create(self.char1) handler = self.char1.components handler.add(rct) - assert handler.has("test_a") - assert handler.has("test_b") - assert handler.has("test_c") + self.assertTrue(handler.has("test_a")) + self.assertTrue(handler.has("test_b")) + self.assertTrue(handler.has("test_c")) def test_can_remove_component(self): rct = RuntimeComponentTestC.create(self.char1) @@ -129,9 +129,9 @@ class TestComponents(EvenniaTest): handler.add(rct) handler.remove(rct) - assert handler.has("test_a") - assert handler.has("test_b") - assert not handler.has("test_c") + self.assertTrue(handler.has("test_a")) + self.assertTrue(handler.has("test_b")) + self.assertFalse(handler.has("test_c")) def test_can_remove_component_by_name(self): rct = RuntimeComponentTestC.create(self.char1) @@ -139,9 +139,9 @@ class TestComponents(EvenniaTest): handler.add(rct) handler.remove_by_name("test_c") - assert handler.has("test_a") - assert handler.has("test_b") - assert not handler.has("test_c") + self.assertTrue(handler.has("test_a")) + self.assertTrue(handler.has("test_b")) + self.assertFalse(handler.has("test_c")) def test_cannot_replace_component(self): with self.assertRaises(Exception): @@ -152,76 +152,76 @@ class TestComponents(EvenniaTest): handler = self.char1.components handler.add(rct) - assert handler.get("test_c") is rct + self.assertIs(handler.get("test_c"), rct) def test_can_access_component_regular_get(self): - assert self.char1.cmp.test_a is self.char1.components.get("test_a") + self.assertIs(self.char1.cmp.test_a, self.char1.components.get("test_a")) def test_returns_none_with_regular_get_when_no_attribute(self): - assert self.char1.cmp.does_not_exist is None + self.assertIs(self.char1.cmp.does_not_exist, None) def test_host_has_class_component_tags(self): - assert self.char1.tags.has(key="test_a", category="components") - assert self.char1.tags.has(key="test_b", category="components") - assert self.char1.tags.has(key="initial_value", category="test_b::default_tag") - assert self.char1.test_b.default_tag == "initial_value" - assert not self.char1.tags.has(key="test_c", category="components") - assert not self.char1.tags.has(category="test_b::single_tag") - assert not self.char1.tags.has(category="test_b::multiple_tags") + self.assertTrue(self.char1.tags.has(key="test_a", category="components")) + self.assertTrue(self.char1.tags.has(key="test_b", category="components")) + self.assertTrue(self.char1.tags.has(key="initial_value", category="test_b::default_tag")) + self.assertTrue(self.char1.test_b.default_tag == "initial_value") + self.assertFalse(self.char1.tags.has(key="test_c", category="components")) + self.assertFalse(self.char1.tags.has(category="test_b::single_tag")) + self.assertFalse(self.char1.tags.has(category="test_b::multiple_tags")) def test_host_has_added_component_tags(self): rct = RuntimeComponentTestC.create(self.char1) self.char1.components.add(rct) test_c = self.char1.components.get("test_c") - assert self.char1.tags.has(key="test_c", category="components") - assert self.char1.tags.has(key="added_value", category="test_c::added_tag") - assert test_c.added_tag == "added_value" + self.assertTrue(self.char1.tags.has(key="test_c", category="components")) + self.assertTrue(self.char1.tags.has(key="added_value", category="test_c::added_tag")) + self.assertEquals(test_c.added_tag, "added_value") def test_host_has_added_default_component_tags(self): self.char1.components.add_default("test_c") test_c = self.char1.components.get("test_c") - assert self.char1.tags.has(key="test_c", category="components") - assert self.char1.tags.has(key="added_value", category="test_c::added_tag") - assert test_c.added_tag == "added_value" + self.assertTrue(self.char1.tags.has(key="test_c", category="components")) + self.assertTrue(self.char1.tags.has(key="added_value", category="test_c::added_tag")) + self.assertEquals(test_c.added_tag, "added_value") def test_host_remove_component_tags(self): rct = RuntimeComponentTestC.create(self.char1) handler = self.char1.components handler.add(rct) - assert self.char1.tags.has(key="test_c", category="components") + self.assertTrue(self.char1.tags.has(key="test_c", category="components")) handler.remove(rct) - assert not self.char1.tags.has(key="test_c", category="components") - assert not self.char1.tags.has(key="added_value", category="test_c::added_tag") + self.assertFalse(self.char1.tags.has(key="test_c", category="components")) + self.assertFalse(self.char1.tags.has(key="added_value", category="test_c::added_tag")) def test_host_remove_by_name_component_tags(self): rct = RuntimeComponentTestC.create(self.char1) handler = self.char1.components handler.add(rct) - assert self.char1.tags.has(key="test_c", category="components") + self.assertTrue(self.char1.tags.has(key="test_c", category="components")) handler.remove_by_name("test_c") - assert not self.char1.tags.has(key="test_c", category="components") - assert not self.char1.tags.has(key="added_value", category="test_c::added_tag") + self.assertFalse(self.char1.tags.has(key="test_c", category="components")) + self.assertFalse(self.char1.tags.has(key="added_value", category="test_c::added_tag")) def test_component_tags_only_hold_one_value_when_enforce_single(self): test_b = self.char1.components.get("test_b") test_b.single_tag = "first_value" test_b.single_tag = "second value" - assert self.char1.tags.has(key="second value", category="test_b::single_tag") - assert test_b.single_tag == "second value" - assert not self.char1.tags.has(key="first_value", category="test_b::single_tag") + self.assertTrue(self.char1.tags.has(key="second value", category="test_b::single_tag")) + self.assertEquals(test_b.single_tag, "second value") + self.assertFalse(self.char1.tags.has(key="first_value", category="test_b::single_tag")) def test_component_tags_default_value_is_overridden_when_enforce_single(self): test_b = self.char1.components.get("test_b") test_b.default_single_tag = "second value" - assert self.char1.tags.has(key="second value", category="test_b::default_single_tag") - assert test_b.default_single_tag == "second value" - assert not self.char1.tags.has(key="first_value", category="test_b::default_single_tag") + self.assertTrue(self.char1.tags.has(key="second value", category="test_b::default_single_tag")) + self.assertTrue(test_b.default_single_tag == "second value") + self.assertFalse(self.char1.tags.has(key="first_value", category="test_b::default_single_tag")) def test_component_tags_support_multiple_values_by_default(self): test_b = self.char1.components.get("test_b") @@ -229,12 +229,12 @@ class TestComponents(EvenniaTest): test_b.multiple_tags = "second value" test_b.multiple_tags = "third value" - assert all( + self.assertTrue(all( val in test_b.multiple_tags for val in ("first value", "second value", "third value") - ) - assert self.char1.tags.has(key="first value", category="test_b::multiple_tags") - assert self.char1.tags.has(key="second value", category="test_b::multiple_tags") - assert self.char1.tags.has(key="third value", category="test_b::multiple_tags") + )) + self.assertTrue(self.char1.tags.has(key="first value", category="test_b::multiple_tags")) + self.assertTrue(self.char1.tags.has(key="second value", category="test_b::multiple_tags")) + self.assertTrue(self.char1.tags.has(key="third value", category="test_b::multiple_tags")) def test_mutables_are_not_shared_when_autocreate(self): self.char1.test_a.my_list.append(1) @@ -294,14 +294,14 @@ class TestComponentSignals(BaseEvenniaTest): def test_host_can_register_as_listener(self): self.char1.signals.trigger("my_signal") - assert self.char1.my_signal_is_called - assert not getattr(self.char1, "my_other_signal_is_called", None) + self.assertTrue(self.char1.my_signal_is_called) + self.assertFalse(getattr(self.char1, "my_other_signal_is_called", None)) def test_host_can_register_as_responder(self): responses = self.char1.signals.query("my_response") - assert 1 in responses - assert 2 not in responses + self.assertIn(1, responses) + self.assertNotIn(2, responses) def test_component_can_register_as_listener(self): char = self.char1 @@ -309,16 +309,16 @@ class TestComponentSignals(BaseEvenniaTest): char.signals.trigger("my_signal") component = char.cmp.test_signal_a - assert component.my_signal_is_called - assert not getattr(component, "my_other_signal_is_called", None) + self.assertTrue(component.my_signal_is_called) + self.assertFalse(getattr(component, "my_other_signal_is_called", None)) def test_component_can_register_as_responder(self): char = self.char1 char.components.add(ComponentWithSignal.create(char)) responses = char.signals.query("my_response") - assert 1 in responses - assert 2 not in responses + self.assertIn(1, responses) + self.assertNotIn(2, responses) def test_signals_can_add_listener(self): result = [] @@ -329,7 +329,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.add_listener("my_fake_signal", my_fake_listener) self.char1.signals.trigger("my_fake_signal") - assert result + self.assertTrue(result) def test_signals_can_add_responder(self): def my_fake_responder(): @@ -338,7 +338,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.add_responder("my_fake_response", my_fake_responder) responses = self.char1.signals.query("my_fake_response") - assert 1 in responses + self.assertIn(1, responses) def test_signals_can_remove_listener(self): result = [] @@ -350,7 +350,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.remove_listener("my_fake_signal", my_fake_listener) self.char1.signals.trigger("my_fake_signal") - assert not result + self.assertFalse(result) def test_signals_can_remove_responder(self): def my_fake_responder(): @@ -360,7 +360,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.remove_responder("my_fake_response", my_fake_responder) responses = self.char1.signals.query("my_fake_response") - assert not responses + self.assertFalse(responses) def test_signals_can_trigger_with_args(self): result = [] @@ -371,7 +371,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.add_listener("my_fake_signal", my_fake_listener) self.char1.signals.trigger("my_fake_signal", 1, kwarg1=2) - assert (1, 2) in result + self.assertIn((1, 2), result) def test_signals_can_query_with_args(self): def my_fake_responder(arg1, kwarg1): @@ -380,7 +380,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.add_responder("my_fake_response", my_fake_responder) responses = self.char1.signals.query("my_fake_response", 1, kwarg1=2) - assert (1, 2) in responses + self.assertIn((1, 2), responses) def test_signals_trigger_does_not_fail_without_listener(self): self.char1.signals.trigger("some_unknown_signal") @@ -395,7 +395,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.add_responder("my_fake_response", my_fake_responder) responses = self.char1.signals.query("my_fake_response", 1, kwarg1=2) - assert (1, 2) in responses + self.assertIn((1, 2), responses) def test_signals_can_add_object_listeners_and_responders(self): result = [] @@ -408,7 +408,7 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.add_object_listeners_and_responders(FakeObj()) self.char1.signals.trigger("my_signal") - assert result + self.assertTrue(result) def test_signals_can_remove_object_listeners_and_responders(self): result = [] @@ -423,14 +423,14 @@ class TestComponentSignals(BaseEvenniaTest): self.char1.signals.remove_object_listeners_and_responders(obj) self.char1.signals.trigger("my_signal") - assert not result + self.assertFalse(result) def test_component_handler_signals_connected_when_adding_default_component(self): char = self.char1 char.components.add_default("test_signal_a") responses = char.signals.query("my_component_response") - assert 3 in responses + self.assertIn(3, responses) def test_component_handler_signals_disconnected_when_removing_component(self): char = self.char1 @@ -439,7 +439,7 @@ class TestComponentSignals(BaseEvenniaTest): char.components.remove(comp) responses = char.signals.query("my_component_response") - assert not responses + self.assertFalse(responses) def test_component_handler_signals_disconnected_when_removing_component_by_name(self): char = self.char1 @@ -447,4 +447,4 @@ class TestComponentSignals(BaseEvenniaTest): char.components.remove_by_name("test_signal_a") responses = char.signals.query("my_component_response") - assert not responses + self.assertFalse(responses)