Added Data Dragon for TFT

src/riotwatcher/TftWatcher.py

@@ -14,7 +14,7 @@
 from .Handlers.RateLimit import BasicRateLimiter
 
 from ._apis import BaseApi
-from ._apis.team_fight_tactics import LeagueApi, MatchApi, SummonerApi
+from ._apis.team_fight_tactics import LeagueApi, MatchApi, SummonerApi, DataDragonApi
 
 
 class TftWatcher:
@@ -60,6 +60,7 @@ def __init__(
         self._league = LeagueApi(self._base_api)
         self._match = MatchApi(self._base_api)
         self._summoner = SummonerApi(self._base_api)
+        self._data_dragon = DataDragonApi(self._base_api)
 
     @property
     def league(self) -> LeagueApi:
@@ -87,3 +88,12 @@ def summoner(self) -> SummonerApi:
         :rtype: team_fight_tactics.SummonerApi
         """
         return self._summoner
+
+    @property
+    def data_dragon(self) -> DataDragonApi:
+        """
+        Interface to the DataDragon Endpoint
+
+        :rtype: team_fight_tactics.DataDragonApi
+        """
+        return self._data_dragon

src/riotwatcher/_apis/team_fight_tactics/DataDragonApi.py

@@ -0,0 +1,46 @@
+import re
+
+from .. import BaseApi, Endpoint
+from .urls import DataDragonUrls
+
+
+class DataDragonApi:
+    def __init__(self, base_api: BaseApi):
+        self._base_api = base_api
+
+    def arenas(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.arenas, version, locale)
+
+    def augments(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.augments, version, locale)
+
+    def champions(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.champions, version, locale)
+
+    def items(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.items, version, locale)
+
+    def queues(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.queues, version, locale)
+
+    def regalia(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.regalia, version, locale)
+
+    def tacticians(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.tacticians, version, locale)
+
+    def traits(self, version: str, locale: str = None):
+        return self._request(DataDragonUrls.traits, version, locale)
+
+    def versions_for_region(self, region: str):
+        region = re.sub(r"\d", "", region)
+        url, query = DataDragonUrls.versions(region=region)
+        return self._base_api.raw_request_static(url, query)
+
+    def versions_all(self):
+        url, query = DataDragonUrls.versions_all()
+        return self._base_api.raw_request_static(url, query)
+
+    def _request(self, endpoint: Endpoint, version: str, locale: str):
+        url, query = endpoint(version=version, locale=locale if locale else "en_US")
+        return self._base_api.raw_request_static(url, query)

src/riotwatcher/_apis/team_fight_tactics/__init__.py

@@ -1,3 +1,4 @@
 from .LeagueApi import LeagueApi
 from .MatchApi import MatchApi
 from .SummonerApi import SummonerApi
+from .DataDragonApi import DataDragonApi

src/riotwatcher/_apis/team_fight_tactics/urls/DataDragonUrls.py

@@ -0,0 +1,14 @@
+from ...league_of_legends.urls.DataDragonUrls import DataDragonEndpoint, DDragonVersionLocaleEndpoint
+
+
+class DataDragonUrls:
+    arenas = DDragonVersionLocaleEndpoint("/tft-arena.json")
+    augments = DDragonVersionLocaleEndpoint("/tft-augments.json")
+    champions = DDragonVersionLocaleEndpoint("/tft-champion.json")
+    items = DDragonVersionLocaleEndpoint("/tft-item.json")
+    queues = DDragonVersionLocaleEndpoint("/tft-queues.json")
+    regalia = DDragonVersionLocaleEndpoint("/tft-regalia.json")
+    tacticians = DDragonVersionLocaleEndpoint("/tft-tactician.json")
+    traits = DDragonVersionLocaleEndpoint("/tft-trait.json")
+    versions = DataDragonEndpoint("/realms/{region}.json")
+    versions_all = DataDragonEndpoint("/api/versions.json")

src/riotwatcher/_apis/team_fight_tactics/urls/__init__.py

@@ -1,3 +1,4 @@
 from .LeagueApiUrls import LeagueApiUrls
 from .MatchApiUrls import MatchApiUrls
 from .SummonerApiUrls import SummonerApiUrls
+from .DataDragonUrls import DataDragonUrls

tests/_apis/team_fight_tactics/test_DataDragonApi.py

@@ -0,0 +1,194 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from riotwatcher._apis.team_fight_tactics import DataDragonApi
+
+@pytest.mark.lol
+@pytest.mark.unit
+class TestDataDragonApi:
+    def test_arenas(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.arenas(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-arena.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_augments(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.augments(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-augments.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_champions(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.champions(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-champion.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_items(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.items(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-item.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_queues(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.queues(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-queues.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_regalia(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.regalia(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-regalia.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_tacticians(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.tacticians(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-tactician.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_traits(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        version = "234"
+        locale = "sdfasdf"
+
+        ret = static_data.traits(version, locale)
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            f"https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/tft-trait.json",
+            {},
+        )
+
+        assert ret is expected_return
+
+    def test_version(self):
+            mock_base_api = MagicMock()
+            expected_return = object()
+            mock_base_api.raw_request_static.return_value = expected_return
+
+            static_data = DataDragonApi(mock_base_api)
+
+            region = "euw1"
+
+            ret = static_data.versions_for_region(region)
+
+            mock_base_api.raw_request_static.assert_called_once_with(
+                "https://ddragon.leagueoflegends.com/realms/{region}.json".format(
+                    region="euw"
+                ),
+                {},
+            )
+
+            assert ret is expected_return
+
+    def test_version_all(self):
+        mock_base_api = MagicMock()
+        expected_return = object()
+        mock_base_api.raw_request_static.return_value = expected_return
+
+        static_data = DataDragonApi(mock_base_api)
+
+        ret = static_data.versions_all()
+
+        mock_base_api.raw_request_static.assert_called_once_with(
+            "https://ddragon.leagueoflegends.com/api/versions.json",
+            {},
+        )