Rename test cases

Author: Galarzaa90

tests/tests_character.py

@@ -32,7 +32,7 @@ def _compare_character(self, mock_character, character):
         self.assertEqual(mock_character.sex, character.sex)
 
     # region Tibia.com Character Tests
-    def test_from_content(self):
+    def test_character_from_content(self):
         """Testing parsing a character's HTML content"""
         character = Character.from_content(self._load_resource(FILE_CHARACTER_RESOURCE))
         self._compare_character(Character("Tschas", "Gladera", Vocation.DRUID, 260, Sex.FEMALE), character)
@@ -54,13 +54,13 @@ def test_from_content(self):
         self.assertEqual(5, len(character.other_characters))
         self.assertFalse(character.hidden)
 
-    def test_from_content_not_found(self):
+    def test_character_from_content_not_found(self):
         """Testing parsing a character not found page"""
         content = self._load_resource(FILE_CHARACTER_NOT_FOUND)
         char = Character.from_content(content)
         self.assertIsNone(char)
 
-    def test_from_content_with_former_names(self):
+    def test_character_from_content_with_former_names(self):
         """Testing parsing a character that has former names"""
         content = self._load_resource(FILE_CHARACTER_FORMER_NAMES)
         char = Character.from_content(content)
@@ -74,15 +74,15 @@ def test_from_content_with_former_names(self):
         self.assertEqual(char.house.world, char.world)
         self.assertIsInstance(char.house.paid_until_date, datetime.date)
 
-    def test_from_content_with_position(self):
+    def test_character_from_content_with_position(self):
         """Testing parsing a character with a position"""
         content = self._load_resource(FILE_CHARACTER_SPECIAL_POSITION)
         char = Character.from_content(content)
         self.assertEqual(char.name, "Steve")
         self.assertEqual(char.position, "CipSoft Member")
         self.assertEqual(char.account_information.position, "CipSoft Member")
 
-    def test_from_content_deleted_character(self):
+    def test_character_from_content_deleted_character(self):
         """Testing parsing a character scheduled for deletion"""
         content = self._load_resource(FILE_CHARACTER_DELETION)
         char = Character.from_content(content)
@@ -91,7 +91,7 @@ def test_from_content_deleted_character(self):
         self.assertIsInstance(char.deletion_date, datetime.datetime)
         self.assertEqual(parse_tibia_datetime("Oct 08 2018 22:17:00 CEST"), char.deletion_date)
 
-    def test_from_content_complex_deaths(self):
+    def test_character_from_content_complex_deaths(self):
         """Testing parsing a character with complex deaths (summons, assists, etc)"""
         content = self._load_resource(FILE_CHARACTER_DEATHS_COMPLEX)
         char = Character.from_content(content)
@@ -101,7 +101,7 @@ def test_from_content_complex_deaths(self):
         oldest_death = char.deaths[-1]
         self.assertEqual(oldest_death.killer.summon, "a fire elemental")
 
-    def test_from_content_badges_and_title(self):
+    def test_character_from_content_badges_and_title(self):
         """Testing parsing a character with account badges and a title"""
         content = self._load_resource(FILE_CHARACTER_TITLE_BADGES)
         char = Character.from_content(content)
@@ -117,7 +117,7 @@ def test_from_content_badges_and_title(self):
             self.assertIsInstance(badge.icon_url, str)
             self.assertIsInstance(badge.description, str)
 
-    def test_from_content_unrelated(self):
+    def test_character_from_content_unrelated(self):
         """Testing parsing an unrelated tibia.com section"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         with self.assertRaises(InvalidContent):
@@ -139,7 +139,7 @@ def test_death_types(self):
 
     # region TibiaData Character tests
 
-    def test_from_tibiadata(self):
+    def test_character_from_tibiadata(self):
         """Testing parsing TibiaData content"""
         content = self._load_resource(FILE_CHARACTER_TIBIADATA)
         char = Character.from_tibiadata(content)
@@ -157,7 +157,7 @@ def test_from_tibiadata(self):
 
         self.assertTrue(char.deaths[3].by_player)
 
-    def test_from_tibiadata_unhidden(self):
+    def test_character_from_tibiadata_unhidden(self):
         """Testing parsing an unhidden character"""
         content = self._load_resource(FILE_CHARACTER_TIBIADATA_UNHIDDEN)
         char = Character.from_tibiadata(content)
@@ -172,7 +172,7 @@ def test_from_tibiadata_unhidden(self):
         self.assertEqual(char.house.world, char.world)
         self.assertIsInstance(char.house.paid_until_date, datetime.date)
 
-    def test_from_tibiadata_deleted(self):
+    def test_character_from_tibiadata_deleted(self):
         """Testing parsing a deleted character"""
         content = self._load_resource(FILE_CHARACTER_TIBIADATA_DELETED)
         char = Character.from_tibiadata(content)
@@ -184,15 +184,15 @@ def test_from_tibiadata_deleted(self):
         self.assertIsNone(char.guild_name)
         self.assertIsNone(char.last_login)
 
-    def test_from_tibiadata_position(self):
+    def test_character_from_tibiadata_position(self):
         """Testing parsing a character with position"""
         content = self._load_resource(FILE_CHARACTER_TIBIADATA_SPECIAL_POSITION)
         char = Character.from_tibiadata(content)
         self.assertEqual(char.name, "Steve")
         self.assertEqual(char.position, "CipSoft Member")
         self.assertEqual(char.account_information.position, "CipSoft Member")
 
-    def test_from_tibiadata_summon_deaths(self):
+    def test_character_from_tibiadata_summon_deaths(self):
         """Testing parsing a character with summon deaths"""
         content = self._load_resource(FILE_CHARACTER_TIBIADATA_DEATHS_SUMMON)
         char = Character.from_tibiadata(content)
@@ -202,18 +202,18 @@ def test_from_tibiadata_summon_deaths(self):
         self.assertTrue(summon_death.killers[2].summon, "a fire elemental")
         self.assertTrue(summon_death.killers[2].name, "Hasi Pupsi")
 
-    def test_from_tibiadata_not_found(self):
+    def test_character_from_tibiadata_not_found(self):
         """Testing parsing a not found character"""
         content = self._load_resource(FILE_CHARACTER_TIBIADATA_NOT_FOUND)
         char = Character.from_tibiadata(content)
         self.assertIsNone(char)
 
-    def test_from_tibiadata_invalid_json(self):
+    def test_character_from_tibiadata_invalid_json(self):
         """Testing parsing an invalid JSON string"""
         with self.assertRaises(InvalidContent):
             Character.from_tibiadata("<html><b>Not a json string</b></html>")
 
-    def test_from_tibiadata_unrelated_json(self):
+    def test_character_from_tibiadata_unrelated_json(self):
         """Testing parsing an unrelated TibiaData section"""
         with self.assertRaises(InvalidContent):
             Character.from_tibiadata(self._load_resource(tests.tests_guild.FILE_GUILD_TIBIADATA))

tests/tests_client.py

@@ -23,7 +23,7 @@ def setUp(self):
     async def tearDown(self):
         await self.client.session.close()
 
-    async def test_constructor_pass_session(self):
+    async def test_client_init_pass_session(self):
         """Testing creating an instance passing a session"""
         headers = {"User-Agent": "Python Unit Test"}
         session = aiohttp.ClientSession(headers=headers)
@@ -34,7 +34,7 @@ async def test_constructor_pass_session(self):
         await client.session.close()
 
     @aioresponses()
-    async def test_handle_errors(self, mock):
+    async def test_client_handle_errors(self, mock):
         """Testing error handling"""
         mock.get(WorldOverview.get_url(), status=403)
         with self.assertRaises(Forbidden):
@@ -53,7 +53,7 @@ async def test_handle_errors(self, mock):
             await self.client.fetch_recent_news(30)
 
     @aioresponses()
-    async def test_fetch_character(self, mock):
+    async def test_client_fetch_character(self, mock):
         """Testing fetching a character"""
         name = "Tschas"
         content = self._load_resource(FILE_CHARACTER_RESOURCE)
@@ -63,7 +63,7 @@ async def test_fetch_character(self, mock):
         self.assertIsInstance(character, Character)
 
     @aioresponses()
-    async def test_fetch_character_not_found(self, mock):
+    async def test_client_fetch_character_not_found(self, mock):
         """Testing fetching a non existent character"""
         name = "Nezune"
         content = self._load_resource(FILE_CHARACTER_NOT_FOUND)
@@ -73,7 +73,7 @@ async def test_fetch_character_not_found(self, mock):
         self.assertIsNone(character)
 
     @aioresponses()
-    async def test_fetch_guild(self, mock):
+    async def test_client_fetch_guild(self, mock):
         """Testing fetching a guild"""
         name = "Vitam et Mortem"
         content = self._load_resource(FILE_GUILD_FULL)
@@ -83,7 +83,7 @@ async def test_fetch_guild(self, mock):
         self.assertIsInstance(guild, Guild)
 
     @aioresponses()
-    async def test_fetch_world_guilds(self, mock):
+    async def test_client_fetch_world_guilds(self, mock):
         """Testing fetching a world's guild list"""
         world = "Zuna"
         content = self._load_resource(FILE_GUILD_LIST)
@@ -93,7 +93,7 @@ async def test_fetch_world_guilds(self, mock):
         self.assertIsInstance(guilds[0], ListedGuild)
 
     @aioresponses()
-    async def test_fetch_highscores_page(self, mock):
+    async def test_client_fetch_highscores_page(self, mock):
         """Testing fetching a highscores page"""
         world = "Estela"
         category = Category.MAGIC_LEVEL
@@ -105,7 +105,7 @@ async def test_fetch_highscores_page(self, mock):
         self.assertIsInstance(highscores, Highscores)
 
     @aioresponses()
-    async def test_fetch_house(self, mock):
+    async def test_client_fetch_house(self, mock):
         """Testing fetching a house"""
         world = "Antica"
         house_id = 5236
@@ -116,7 +116,7 @@ async def test_fetch_house(self, mock):
         self.assertIsInstance(house, House)
 
     @aioresponses()
-    async def test_fetch_world_houses(self, mock):
+    async def test_client_fetch_world_houses(self, mock):
         """Testing fetching a world's houses"""
         world = "Antica"
         city = "Edron"
@@ -128,7 +128,7 @@ async def test_fetch_world_houses(self, mock):
         self.assertIsInstance(houses[0], ListedHouse)
 
     @aioresponses()
-    async def test_fetch_kill_statistics(self, mock):
+    async def test_client_fetch_kill_statistics(self, mock):
         """Testing fetching kill statistics"""
         world = "Antica"
         content = self._load_resource(FILE_KILL_STATISTICS_FULL)
@@ -138,7 +138,7 @@ async def test_fetch_kill_statistics(self, mock):
         self.assertIsInstance(kill_statistics, KillStatistics)
 
     @aioresponses()
-    async def test_fetch_recent_news(self, mock):
+    async def test_client_fetch_recent_news(self, mock):
         """Testing fetching recent nows"""
         content = self._load_resource(FILE_NEWS_LIST)
         mock.post(ListedNews.get_list_url(), status=200, body=content)
@@ -147,15 +147,15 @@ async def test_fetch_recent_news(self, mock):
         self.assertIsInstance(recent_news, list)
         self.assertIsInstance(recent_news[0], ListedNews)
 
-    async def test_fetch_news_archive_invalid_dates(self):
+    async def test_client_fetch_news_archive_invalid_dates(self):
         """Testing fetching news archive with invalid dates"""
         today = datetime.date.today()
         yesterday = today - datetime.timedelta(days=1)
         with self.assertRaises(ValueError):
             await self.client.fetch_news_archive(today, yesterday)
 
     @aioresponses()
-    async def test_fetch_news(self, mock):
+    async def test_client_fetch_news(self, mock):
         """Testing fetch news"""
         news_id = 6000
         content = self._load_resource(FILE_NEWS_ARTICLE)
@@ -165,7 +165,7 @@ async def test_fetch_news(self, mock):
         self.assertIsInstance(news, News)
 
     @aioresponses()
-    async def test_fetch_world(self, mock):
+    async def test_client_fetch_world(self, mock):
         """Testing fetching a world"""
         name = "Antica"
         content = self._load_resource(FILE_WORLD_FULL)
@@ -175,7 +175,7 @@ async def test_fetch_world(self, mock):
         self.assertIsInstance(world, World)
 
     @aioresponses()
-    async def test_fetch_world_list(self, mock):
+    async def test_client_fetch_world_list(self, mock):
         """Testing fetching the world list"""
         content = self._load_resource(FILE_WORLD_LIST)
         mock.get(WorldOverview.get_url(), status=200, body=content)
@@ -184,7 +184,7 @@ async def test_fetch_world_list(self, mock):
         self.assertIsInstance(worlds, WorldOverview)
 
     @aioresponses()
-    async def test_fetch_boosted_creature(self, mock):
+    async def test_client_fetch_boosted_creature(self, mock):
         """Testing fetching the boosted creature"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         mock.get(News.get_list_url(), status=200, body=content)

tests/tests_creature.py

@@ -6,14 +6,16 @@
 
 class TestCreature(TestCommons, unittest.TestCase):
     # region Tibia.com Tests
-    def testBoostedCreature(self):
+    def test_creature_from_content(self):
+        """Testing parsing a boosted creature"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         creature = BoostedCreature.from_content(content)
 
         self.assertIsInstance(creature, BoostedCreature)
         self.assertEqual("Skeleton Warrior", creature.name)
 
-    def testBoostedCreatureNotTibiaCom(self):
+    def test_creature_from_content_not_tibiacom(self):
+        """Testing parsing a page that is not Tibia.com"""
         with self.assertRaises(InvalidContent):
             BoostedCreature.from_content("<html><div><p>Nothing</p></div></html>")