Renaming test cases and updated changelog

Author: Galarzaa90

CHANGELOG.rst

@@ -6,6 +6,14 @@ Changelog
     Due to this library relying on external content, older versions are not guaranteed to work.
     Try to always use the latest version.
 
+
+.. _v2.2.0:
+
+2.2.0 (2019-08-08)
+==================
+
+- Added support for account badges and character titles.
+
 .. _v2.1.0:
 
 2.1.0 (2019-06-17)

tests/tests_house.py

@@ -70,7 +70,8 @@ def test_house_parse_status_rented(self):
         self.assertEqual(house.owner, "Thorcen")
         self.assertIsInstance(house.paid_until, datetime.datetime)
 
-    def testHouseStatusWithBids(self):
+    def test_house_parse_status_with_bids(self):
+        """Testing parsing a house status with bids"""
         house = House("Name")
         content = self._load_resource(FILE_HOUSE_STATUS_WITH_BIDS)
         house._parse_status(content)
@@ -80,25 +81,29 @@ def testHouseStatusWithBids(self):
         self.assertEqual(house.highest_bidder, "King of Bosnia")
         self.assertIsInstance(house.auction_end, datetime.datetime)
 
-    def testHouseStatusWithoutBids(self):
+    def test_house_parse_status_without_bids(self):
+        """Testing parsing the status of a house with no bids"""
         house = House("Name")
         content = self._load_resource(FILE_HOUSE_STATUS_NO_BIDS)
         house._parse_status(content)
         self.assertEqual(house.status, HouseStatus.AUCTIONED)
         self.assertIsNone(house.auction_end)
 
-    def testHouseNotFound(self):
+    def test_house_from_content_not_found(self):
+        """Testing parsing a house that doesn't exist"""
         content = self._load_resource(FILE_HOUSE_NOT_FOUND)
         house = House.from_content(content)
 
         self.assertIsNone(house)
 
-    def testHouseUnrelated(self):
+    def test_house_from_content_unrelated(self):
+        """Testing parsing an unrelated section"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         with self.assertRaises(InvalidContent):
             House.from_content(content)
 
-    def testHouseList(self):
+    def test_listed_house_from_content(self):
+        """Testing parsing the house list of a world and city"""
         content = self._load_resource(FILE_HOUSE_LIST)
         houses = ListedHouse.list_from_content(content)
 
@@ -113,24 +118,28 @@ def testHouseList(self):
 
         self.assertEqual(houses[25].status, HouseStatus.RENTED)
 
-    def testHouseListEmpty(self):
+    def test_listed_house_from_content_empty(self):
+        """Testing parsing an empty house list"""
         content = self._load_resource(FILE_HOUSE_LIST_EMPTY)
         houses = ListedHouse.list_from_content(content)
 
         self.assertEqual(len(houses), 0)
 
-    def testHouseListNotFound(self):
+    def test_listed_house_from_content_not_found(self):
+        """Testing parsing an empty house list"""
         content = self._load_resource(FILE_HOUSE_NOT_FOUND)
         houses = ListedHouse.list_from_content(content)
 
         self.assertIsNone(houses)
 
-    def testHouseListUnrelated(self):
+    def test_listed_house_from_content_unrelated(self):
+        """Testing parsing an unrelated section"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         with self.assertRaises(InvalidContent):
             ListedHouse.list_from_content(content)
 
-    def testHouseTibiaData(self):
+    def test_house_from_tibiadata(self):
+        """Testing parsing a house from TibiaData"""
         content = self._load_resource(FILE_HOUSE_TIBIADATA)
         house = House.from_tibiadata(content)
 
@@ -142,22 +151,26 @@ def testHouseTibiaData(self):
         self.assertEqual(house.status, HouseStatus.AUCTIONED)
         self.assertIsNone(house.owner)
 
-    def testHouseTibiaDataNotFound(self):
+    def test_house_from_tibiadata_not_found(self):
+        """Testing parsing a house that doesn't exist"""
         content = self._load_resource(FILE_HOUSE_TIBIADATA_NOT_FOUND)
         house = House.from_tibiadata(content)
 
         self.assertIsNone(house)
 
-    def testHouseTibiaDataInvalid(self):
+    def test_house_from_tibiadata_invalid_json(self):
+        """Testing parsing an invalid json"""
         with self.assertRaises(InvalidContent):
             House.from_tibiadata("<p>Not json</p>")
 
-    def testGuildTibiaDataUnrelated(self):
+    def test_house_from_tibiadata_unrelated(self):
+        """Testing parsing an unrelated section"""
         content = self._load_resource(tests.tests_character.FILE_CHARACTER_TIBIADATA)
         with self.assertRaises(InvalidContent):
             House.from_tibiadata(content)
 
-    def testHouseTibiaDataList(self):
+    def test_listed_house_list_from_tibiadata(self):
+        """Testing parsing a house list from TibiaData"""
         content = self._load_resource(FILE_HOUSE_TIBIADATA_LIST)
         houses = ListedHouse.list_from_tibiadata(content)
 
@@ -170,17 +183,20 @@ def testHouseTibiaDataList(self):
         self.assertIsInstance(houses[0].id, int)
         self.assertIsNotNone(ListedHouse.get_list_url_tibiadata(houses[0].world, houses[0].town))
 
-    def testHouseTibiaDataListNotFound(self):
+    def test_listed_house_list_from_tibiadata_not_found(self):
+        """Testing parsing a list of a world that doesn't exist"""
         content = self._load_resource(FILE_HOUSE_TIBIADATA_LIST_NOT_FOUND)
         houses = ListedHouse.list_from_tibiadata(content)
 
         self.assertIsInstance(houses, list)
         self.assertEqual(len(houses), 0)
 
-    def testHouseTibiaDataListInvalidJson(self):
+    def test_listed_house_list_from_tibiadata_invalid_json(self):
+        """Testing parsing an invalid json"""
         with self.assertRaises(InvalidContent):
             ListedHouse.list_from_tibiadata("nope")
 
-    def testHouseTibiaDataListUnrelated(self):
+    def test_listed_house_list_from_tibiadata_unrelated_section(self):
+        """Testing parsing an unrelated section"""
         with self.assertRaises(InvalidContent):
             ListedHouse.list_from_tibiadata(self._load_resource(tests.tests_character.FILE_CHARACTER_TIBIADATA))

tests/tests_kill_statistics.py

@@ -9,7 +9,8 @@
 
 class TestHighscores(TestCommons, unittest.TestCase):
     # region Tibia.com Tests
-    def testKillStatistics(self):
+    def test_kill_statistics_from_content(self):
+        """Testing parsing kill statistics"""
         content = self._load_resource(FILE_KILL_STATISTICS_FULL)
         kill_statistics = KillStatistics.from_content(content)
 
@@ -25,13 +26,15 @@ def testKillStatistics(self):
         self.assertEqual(kill_statistics.players.last_week_killed, 7)
         self.assertEqual(kill_statistics.players.last_week_killed, kill_statistics.players.last_week_players_killed)
 
-    def testKillStatisticsEmpty(self):
+    def test_kill_statistics_from_content_empty(self):
+        """Testing parsing empty kill statistics"""
         content = self._load_resource(FILE_KILL_STATISTICS_EMPTY)
         kill_statistics = KillStatistics.from_content(content)
 
         self.assertIsNone(kill_statistics)
 
-    def testKillStatisticsUnrelated(self):
+    def test_kill_statistics_from_content_unrelated_section(self):
+        """Testing parsing an unrelated section"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         with self.assertRaises(InvalidContent):
             KillStatistics.from_content(content)

tests/tests_news.py

@@ -14,7 +14,8 @@
 
 class TestNews(TestCommons, unittest.TestCase):
     # region Tibia.com Tests
-    def testNewsList(self):
+    def test_listed_news_from_content(self):
+        """Testing parsing news"""
         content = self._load_resource(FILE_NEWS_LIST)
         news_list = ListedNews.list_from_content(content)
         self.assertGreater(len(news_list), 0)
@@ -28,27 +29,32 @@ def testNewsList(self):
         self.assertIsNotNone(latest_news.url)
         self.assertEqual(latest_news.url, ListedNews.get_url(latest_news.id))
 
-    def testNewsListEmpty(self):
+    def test_listed_news_from_content_empty(self):
+        """Testing parsing a news article that doesn't exist"""
         content = self._load_resource(FILE_NEWS_LIST_EMPTY)
         news_list = ListedNews.list_from_content(content)
         self.assertEqual(len(news_list), 0)
 
-    def testNewsListUnrelated(self):
+    def test_listed_news_from_content_unrelated(self):
+        """Testing parsing an unrelated section"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         with self.assertRaises(InvalidContent):
             ListedNews.list_from_content(content)
 
-    def testNewsEmpty(self):
+    def test_news_from_content_empty(self):
+        """Testing parsing an empty news article"""
         content = self._load_resource(FILE_NEWS_EMPTY)
         news = News.from_content(content)
         self.assertIsNone(news)
 
-    def testNewsUnrelated(self):
+    def test_news_from_content_unrelated(self):
+        """Testing parsing an unrelated section"""
         content = self._load_resource(self.FILE_UNRELATED_SECTION)
         with self.assertRaises(InvalidContent):
             News.from_content(content)
 
-    def testNewsTicker(self):
+    def test_news_from_content_ticker(self):
+        """Testing parsing a news ticker"""
         content = self._load_resource(FILE_NEWS_TICKER)
         news = News.from_content(content)
 
@@ -58,7 +64,8 @@ def testNewsTicker(self):
         self.assertEqual(news.title, "News Ticker")
         self.assertIsNone(news.thread_id)
 
-    def testNewsArticle(self):
+    def test_news_from_content_article(self):
+        """Testing parsing an article"""
         content = self._load_resource(FILE_NEWS_ARTICLE)
         news = News.from_content(content)
 

tests/tests_utils.py

@@ -2,7 +2,6 @@
 import unittest
 
 import tibiapy
-
 from tests.tests_tibiapy import TestCommons
 from tibiapy import enums, utils
 from tibiapy.utils import parse_integer, parse_tibia_money
@@ -35,7 +34,8 @@
 
 
 class TestUtils(TestCommons, unittest.TestCase):
-    def testSerializableGetItem(self):
+    def test_serializable_get_item(self):
+        """Testing the muliple ways to use __get__ for Serializable"""
         # Class inherits from Serializable
         world = tibiapy.World("Calmera")
 
@@ -57,7 +57,7 @@ def testSerializableGetItem(self):
         with self.assertRaises(KeyError):
             world["custom"] = "custom value"
 
-    def testTibiaDateTime(self):
+    def test_parse_tibia_datetime(self):
         time = utils.parse_tibia_datetime(TIBIA_DATETIME_CEST)
         self.assertIsInstance(time, datetime.datetime)
         self.assertEqual(time.month, 7)
@@ -76,33 +76,33 @@ def testTibiaDateTime(self):
         self.assertEqual(time.minute, 13)
         self.assertEqual(time.second, 32)
 
-    def testTibiaDateInvalidTimezone(self):
+    def test_parse_tibia_datetime_invalid_timezone(self):
         time = utils.parse_tibia_datetime(TIBIA_DATETIME_PST)
         self.assertIsNone(time)
 
-    def testTibiaDateTimeInvalid(self):
+    def test_parse_tibia_datetime_invalid_datetime(self):
         time = utils.parse_tibia_datetime(TIBIA_DATETIME_INVALID)
         self.assertIsNone(time)
 
-    def testTibiaDate(self):
+    def test_parse_tibia_date(self):
         date = utils.parse_tibia_date(TIBIA_DATE)
         self.assertIsInstance(date, datetime.date)
         self.assertEqual(date.month, 6)
         self.assertEqual(date.day, 20)
         self.assertEqual(date.year, 2018)
 
-    def testTibiaFullDate(self):
+    def test_parse_tibia_date_full(self):
         date = utils.parse_tibia_full_date(TIBIA_FULL_DATE)
         self.assertIsInstance(date, datetime.date)
         self.assertEqual(date.month, 7)
         self.assertEqual(date.day, 23)
         self.assertEqual(date.year, 2015)
 
-    def testTibiaDateInvalid(self):
+    def test_parse_tibia_date_invalid(self):
         date = utils.parse_tibia_date(TIBIA_DATETIME_INVALID)
         self.assertIsNone(date)
 
-    def testTibiaDataDatetime(self):
+    def test_parse_tibia_datetime_from_datetime(self):
         date = utils.parse_tibiadata_datetime(TIBIADATA_DATETIME_CET)
         self.assertIsInstance(date, datetime.datetime)
 
@@ -117,7 +117,7 @@ def testTibiaDataDatetime(self):
         date = utils.parse_tibiadata_datetime(TIBIA_DATE)
         self.assertIsNone(date)
 
-    def testTryDate(self):
+    def test_try_date(self):
         date = utils.try_date(datetime.datetime.now())
         self.assertIsInstance(date, datetime.date)
 
@@ -134,7 +134,7 @@ def testTryDate(self):
         date = utils.try_date(TIBIADATA_DATE)
         self.assertIsInstance(date, datetime.date)
 
-    def testTryDateTime(self):
+    def test_try_date_time(self):
         date_time = utils.try_datetime(datetime.datetime.now())
         self.assertIsInstance(date_time, datetime.datetime)
 
@@ -144,34 +144,34 @@ def testTryDateTime(self):
         date_time = utils.try_datetime(TIBIADATA_DATETIME_CET)
         self.assertIsInstance(date_time, datetime.datetime)
 
-    def testParseNumberWords(self):
+    def test_parse_number_words(self):
         self.assertEqual(utils.parse_number_words("one"), 1)
         self.assertEqual(utils.parse_number_words("no"), 0)
         self.assertEqual(utils.parse_number_words("..."), 0)
         self.assertEqual(utils.parse_number_words("twenty-one"), 21)
         self.assertEqual(utils.parse_number_words("one hundred two"), 102)
         self.assertEqual(utils.parse_number_words("two thousand forty five"), 2045)
 
-    def testTryEnum(self):
+    def test_try_enum(self):
         self.assertEqual(utils.try_enum(enums.Sex, "male"), enums.Sex.MALE)
         self.assertEqual(utils.try_enum(enums.TransferType, "", enums.TransferType.REGULAR), enums.TransferType.REGULAR)
         self.assertEqual(utils.try_enum(enums.WorldLocation, enums.WorldLocation.EUROPE), enums.WorldLocation.EUROPE)
 
-    def testEnumStr(self):
+    def test_enum_str(self):
         self.assertEqual(str(enums.Sex.MALE), enums.Sex.MALE.value)
         self.assertEqual(enums.VocationFilter.from_name("royal paladin"), enums.VocationFilter.PALADINS)
         self.assertEqual(enums.VocationFilter.from_name("unknown"), enums.VocationFilter.ALL)
         self.assertIsNone(enums.VocationFilter.from_name("unknown", False))
 
-    def testParseTibiaMoney(self):
+    def test_parse_tibia_money(self):
         self.assertEqual(1000, parse_tibia_money("1k"))
         self.assertEqual(5000000, parse_tibia_money("5kk"))
         self.assertEqual(2500, parse_tibia_money("2.5k"))
         self.assertEqual(50, parse_tibia_money("50"))
         with self.assertRaises(ValueError):
             parse_tibia_money("abc")
 
-    def testParseInteger(self):
+    def test_parse_integer(self):
         self.assertEqual(1450, parse_integer("1.450"))
         self.assertEqual(1110, parse_integer("1,110"))
         self.assertEqual(15, parse_integer("15"))