pynintendoparental 2.0.0__tar.gz → 2.1.1__tar.gz

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 2.0.0
+Version: 2.1.1
 Summary: A Python module to interact with Nintendo Parental Controls
 Home-page: http://github.com/pantherale0/pynintendoparental
 Author: pantherale0
@@ -11,16 +11,20 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pynintendoauth~=1.0.0
+Requires-Dist: pynintendoauth==1.0.0
 Provides-Extra: dev
+Requires-Dist: aiofiles<26,>=23; extra == "dev"
 Requires-Dist: bandit<1.9,>=1.7; extra == "dev"
 Requires-Dist: black<26,>=23; extra == "dev"
 Requires-Dist: build<1.4,>=0.10; extra == "dev"
+Requires-Dist: Faker<39,>=38; extra == "dev"
 Requires-Dist: flake8<8,>=6; extra == "dev"
 Requires-Dist: isort<7,>=5; extra == "dev"
-Requires-Dist: mypy<1.19,>=1.5; extra == "dev"
+Requires-Dist: mypy<1.20,>=1.5; extra == "dev"
 Requires-Dist: pytest<9,>=7; extra == "dev"
 Requires-Dist: pytest-cov<8,>=4; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0,>=0.21; extra == "dev"
+Requires-Dist: syrupy<6,>=5; extra == "dev"
 Requires-Dist: twine<7,>=4; extra == "dev"
 Dynamic: author
 Dynamic: classifier

pynintendoparental-2.1.1/pynintendoparental/_version.py

@@ -0,0 +1 @@
+__version__ = "2.1.1"

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental/api.py

@@ -112,12 +112,6 @@ class Api:
         # now return the resp dict
         return resp
 
-    async def async_get_account_details(self) -> dict:
-        """Get account details."""
-        return await self.send_request(
-            endpoint="get_account_details", ACCOUNT_ID=self.account_id
-        )
-
     async def async_get_account_devices(self) -> dict:
         """Get account devices."""
         return await self.send_request(endpoint="get_account_devices")
@@ -146,14 +140,6 @@ class Api:
             endpoint="get_device_parental_control_setting", DEVICE_ID=device_id
         )
 
-    async def async_get_device_parental_control_setting_state(
-        self, device_id: str
-    ) -> dict:
-        """Get device parental control setting state."""
-        return await self.send_request(
-            endpoint="get_device_parental_control_setting_state", DEVICE_ID=device_id
-        )
-
     async def async_get_device_monthly_summary(
         self, device_id: str, year: int, month: int
     ) -> dict:

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental/const.py

@@ -6,8 +6,8 @@ import logging
 _LOGGER = logging.getLogger(__package__)
 CLIENT_ID = "54789befb391a838"
 MOBILE_APP_PKG = "com.nintendo.znma"
-MOBILE_APP_VERSION = "2.2.0"
-MOBILE_APP_BUILD = "560"
+MOBILE_APP_VERSION = "2.3.0"
+MOBILE_APP_BUILD = "600"
 OS_NAME = "ANDROID"
 OS_VERSION = "34"
 OS_STR = f"{OS_NAME} {OS_VERSION}"

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental/device.py

@@ -32,8 +32,9 @@ class Device:
         self._api: Api = api
         self.daily_summaries: dict = {}
         self.parental_control_settings: dict = {}
-        self.players: list[Player] = []
+        self.players: dict[str, Player] = {}
         self.limit_time: int | float | None = 0
+        self.extra_playing_time: int | None = None
         self.timer_mode: DeviceTimerMode | None = None
         self.today_playing_time: int | float = 0
         self.today_time_remaining: int | float = 0
@@ -66,6 +67,13 @@ class Device:
         """Return the generation."""
         return self.extra.get("platformGeneration", None)
 
+    @property
+    def last_sync(self) -> float | None:
+        """Return the last time this device was synced."""
+        return self.extra.get("synchronizedParentalControlSetting", {}).get(
+            "synchronizedAt", None
+        )
+
     async def update(self):
         """Update data."""
         _LOGGER.debug(">> Device.update()")
@@ -76,11 +84,8 @@ class Device:
             self.get_monthly_summary(),
             self._get_extras(),
         )
-        if not self.players:
-            self.players = Player.from_device_daily_summary(self.daily_summaries)
-        else:
-            for player in self.players:
-                player.update_from_daily_summary(self.daily_summaries)
+        for player in self.players.values():
+            player.update_from_daily_summary(self.daily_summaries)
         await self._execute_callbacks()
 
     def add_device_callback(self, callback):
@@ -321,6 +326,14 @@ class Device:
         today_reg = self._get_today_regulation(now)
         limit_time = today_reg.get("timeToPlayInOneDay", {}).get("limitTime")
         self.limit_time = limit_time if limit_time is not None else -1
+        extra_playing_time_data = (
+            pcs.get("ownedDevice", {}).get("device", {}).get("extraPlayingTime")
+        )
+        self.extra_playing_time = None
+        if extra_playing_time_data:
+            self.extra_playing_time = extra_playing_time_data.get("inOneDay", {}).get(
+                "duration"
+            )
 
         bedtime_setting = today_reg.get("bedtime", {})
         if bedtime_setting.get("enabled"):
@@ -527,6 +540,15 @@ class Device:
             )
             if latest:
                 self.last_month_summary = summary = response["json"]["summary"]
+                # Generate player objects
+                for player in response.get("json", {}).get("summary", {}).get("players", []):
+                    profile = player.get("profile")
+                    if not profile or not profile.get("playerId"):
+                        continue
+                    player_id = profile["playerId"]
+                    if player_id not in self.players:
+                        self.players[player_id] = Player.from_profile(profile)
+                    self.players[player_id].month_summary = player.get("summary", {})
                 return summary
             return response["json"]["summary"]
 
@@ -564,7 +586,7 @@ class Device:
 
     def get_player(self, player_id: str) -> Player:
         """Returns a player."""
-        player = next((p for p in self.players if p.player_id == player_id), None)
+        player = self.players.get(player_id)
         if player:
             return player
         raise ValueError(f"Player with id {player_id} not found.")

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental/exceptions.py

@@ -2,12 +2,14 @@
 
 from enum import StrEnum
 
+
 class RangeErrorKeys(StrEnum):
     """Keys for range errors."""
 
     DAILY_PLAYTIME = "daily_playtime_out_of_range"
     BEDTIME = "bedtime_alarm_out_of_range"
 
+
 class NoDevicesFoundException(Exception):
     """No devices were found for the account."""
 

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental/player.py

@@ -8,22 +8,22 @@ class Player:
 
     def __init__(self):
         """Init a player."""
-        self.player_image: str = None
-        self.nickname: str = None
+        self.player_image: str | None = None
+        self.nickname: str | None = None
         self.apps: list = []
-        self.player_id: str = None
-        self.playing_time: int = None
+        self.month_summary: dict = {}
+        self.player_id: str | None = None
+        self.playing_time: int = 0
 
     def update_from_daily_summary(self, raw: list[dict]):
         """Update the current instance of the player from the daily summery"""
         _LOGGER.debug("Updating player %s daily summary", self.player_id)
-        for player in raw[0].get("devicePlayers", []):
-            if self.player_id is player["profile"].get("playerId"):
-                self.player_id = player["profile"].get("playerId")
+        for player in raw[0].get("players", []):
+            if self.player_id == player["profile"].get("playerId"):
                 self.player_image = player["profile"].get("imageUri")
                 self.nickname = player["profile"].get("nickname")
                 self.playing_time = player.get("playingTime")
-                self.apps = player.get("playedApps")
+                self.apps = player.get("playedGames")
                 break
 
     @classmethod
@@ -41,3 +41,12 @@ class Player:
             players.append(parsed)
             _LOGGER.debug("Built player %s", parsed.player_id)
         return players
+
+    @classmethod
+    def from_profile(cls, raw: dict) -> "Player":
+        """Converts a profile response into a player."""
+        parsed = cls()
+        parsed.player_id = raw.get("playerId")
+        parsed.player_image = raw.get("imageUri")
+        parsed.nickname = raw.get("nickname")
+        return parsed

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 2.0.0
+Version: 2.1.1
 Summary: A Python module to interact with Nintendo Parental Controls
 Home-page: http://github.com/pantherale0/pynintendoparental
 Author: pantherale0
@@ -11,16 +11,20 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pynintendoauth~=1.0.0
+Requires-Dist: pynintendoauth==1.0.0
 Provides-Extra: dev
+Requires-Dist: aiofiles<26,>=23; extra == "dev"
 Requires-Dist: bandit<1.9,>=1.7; extra == "dev"
 Requires-Dist: black<26,>=23; extra == "dev"
 Requires-Dist: build<1.4,>=0.10; extra == "dev"
+Requires-Dist: Faker<39,>=38; extra == "dev"
 Requires-Dist: flake8<8,>=6; extra == "dev"
 Requires-Dist: isort<7,>=5; extra == "dev"
-Requires-Dist: mypy<1.19,>=1.5; extra == "dev"
+Requires-Dist: mypy<1.20,>=1.5; extra == "dev"
 Requires-Dist: pytest<9,>=7; extra == "dev"
 Requires-Dist: pytest-cov<8,>=4; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0,>=0.21; extra == "dev"
+Requires-Dist: syrupy<6,>=5; extra == "dev"
 Requires-Dist: twine<7,>=4; extra == "dev"
 Dynamic: author
 Dynamic: classifier

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental.egg-info/SOURCES.txt

@@ -18,4 +18,8 @@ pynintendoparental.egg-info/PKG-INFO
 pynintendoparental.egg-info/SOURCES.txt
 pynintendoparental.egg-info/dependency_links.txt
 pynintendoparental.egg-info/requires.txt
-pynintendoparental.egg-info/top_level.txt
+pynintendoparental.egg-info/top_level.txt
+tests/test_api.py
+tests/test_device.py
+tests/test_init.py
+tests/test_player.py

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/pynintendoparental.egg-info/requires.txt

@@ -1,12 +1,16 @@
-pynintendoauth~=1.0.0
+pynintendoauth==1.0.0
 
 [dev]
+aiofiles<26,>=23
 bandit<1.9,>=1.7
 black<26,>=23
 build<1.4,>=0.10
+Faker<39,>=38
 flake8<8,>=6
 isort<7,>=5
-mypy<1.19,>=1.5
+mypy<1.20,>=1.5
 pytest<9,>=7
 pytest-cov<8,>=4
+pytest-asyncio<1.0,>=0.21
+syrupy<6,>=5
 twine<7,>=4

{pynintendoparental-2.0.0 → pynintendoparental-2.1.1}/setup.py

@@ -16,18 +16,22 @@ with open('pynintendoparental/_version.py', 'r') as version_file:
 REQUIREMENTS = [
     # Add your list of production dependencies here, eg:
     # 'requests == 2.*',
-    'pynintendoauth~=1.0.0'
+    'pynintendoauth==1.0.0'
 ]
 
 DEV_REQUIREMENTS = [
+    'aiofiles >= 23,< 26',
     'bandit >= 1.7,< 1.9',
     'black >= 23,< 26',
     'build >= 0.10,< 1.4',
+    'Faker >= 38,< 39',
     'flake8 >= 6,< 8',
     'isort >= 5,< 7',
-    'mypy >= 1.5,< 1.19',
+    'mypy >= 1.5,< 1.20',
     'pytest >= 7,< 9',
     'pytest-cov >= 4,< 8',
+    'pytest-asyncio >= 0.21,< 1.0',
+    'syrupy >= 5,< 6',
     'twine >= 4,< 7',
 ]
 

pynintendoparental-2.1.1/tests/test_api.py

@@ -0,0 +1,193 @@
+"""Tests for the API class."""
+
+from unittest.mock import AsyncMock, MagicMock, Mock
+
+import pytest
+from aiohttp import ContentTypeError
+from pynintendoauth.exceptions import HttpException
+
+from pynintendoparental.api import Api, _check_http_success
+from pynintendoparental.authenticator import Authenticator
+
+
+@pytest.mark.parametrize(
+    "status, expected", [(200, True), (204, True), (300, False), (404, False)]
+)
+def test_check_http_success(status, expected):
+    """Test the _check_http_success function."""
+    assert _check_http_success(status) == expected
+
+
+def test_api_init_and_properties(mock_authenticator: Authenticator):
+    """Test API initialization and properties."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+    assert api.account_id == "ACCOUNT_ID"
+    headers = api._headers
+    assert headers["Authorization"] == "ACCESS_TOKEN"
+    assert headers["X-Moon-TimeZone"] == "Europe/London"
+    assert headers["X-Moon-App-Language"] == "en-GB"
+
+
+async def test_send_request_invalid_endpoint(mock_authenticator: Authenticator):
+    """Test sending a request to an invalid endpoint."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+    with pytest.raises(ValueError, match="Endpoint does not exist"):
+        await api.send_request("invalid_endpoint")
+
+
+async def test_send_request_token_refresh(mock_authenticator: Authenticator):
+    """Test that the token is refreshed if it's expired."""
+    mock_authenticator.access_token_expired = True
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.json = AsyncMock(return_value={"status": "ok"})
+    mock_response.text = AsyncMock(return_value='{"status": "ok"}')
+    mock_authenticator.async_authenticated_request = AsyncMock(
+        return_value=mock_response
+    )
+
+    await api.send_request("get_account_devices")
+    mock_authenticator.perform_refresh.assert_called_once()
+
+
+async def test_send_request_http_exception(mock_authenticator: Authenticator):
+    """Test a generic HttpException is raised on non-2xx response."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+
+    mock_response = MagicMock()
+    mock_response.status = 500
+    mock_response.content_type = "text/plain"
+    mock_response.text = AsyncMock(return_value="Internal Server Error")
+    mock_authenticator.async_authenticated_request = AsyncMock(
+        return_value=mock_response
+    )
+
+    with pytest.raises(HttpException, match="Internal Server Error"):
+        await api.send_request("get_account_devices")
+
+
+async def test_send_request_http_exception_problem_json(
+    mock_authenticator: Authenticator,
+):
+    """Test that HttpException is raised with details from a problem+json response."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+
+    mock_response = MagicMock()
+    mock_response.status = 400
+    mock_response.content_type = "application/problem+json"
+    mock_response.json = AsyncMock(
+        return_value={"detail": "Bad Request", "errorCode": "E0001"}
+    )
+    mock_authenticator.async_authenticated_request = AsyncMock(
+        return_value=mock_response
+    )
+
+    with pytest.raises(HttpException, match="Bad Request"):
+        await api.send_request("get_account_devices")
+
+
+async def test_send_request_http_exception_problem_json_invalid(
+    mock_authenticator: Authenticator,
+):
+    """Test HttpException with a generic message for invalid problem+json."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+    mock_request_info = Mock(real_url="http://mock.url")
+    content_type_error = ContentTypeError(mock_request_info, ())
+
+    mock_response = MagicMock()
+    mock_response.status = 400
+    mock_response.content_type = "application/problem+json"
+    mock_response.json = AsyncMock(side_effect=content_type_error)
+    mock_response.text = AsyncMock(return_value="Invalid JSON")
+    mock_authenticator.async_authenticated_request = AsyncMock(
+        return_value=mock_response
+    )
+
+    with pytest.raises(HttpException, match="Invalid JSON"):
+        await api.send_request("get_account_devices")
+
+
+async def test_send_request_json_decode_error(mock_authenticator: Authenticator):
+    """Test that an empty json dict is returned on a JSON decode error."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+    mock_request_info = Mock(real_url="http://mock.url")
+    content_type_error = ContentTypeError(mock_request_info, ())
+
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.json = AsyncMock(side_effect=content_type_error)
+    mock_response.text = AsyncMock(return_value="<not_json>")
+    mock_response.url = "http://mock.url"
+    mock_authenticator.async_authenticated_request = AsyncMock(
+        return_value=mock_response
+    )
+
+    result = await api.send_request("get_account_devices")
+    assert result["json"] == {}
+
+
+async def test_api_methods(mock_authenticator: Authenticator):
+    """Test that API methods call send_request with correct parameters."""
+    api = Api(auth=mock_authenticator, tz="Europe/London", lang="en-GB")
+    api.send_request = AsyncMock()
+
+    await api.async_get_account_devices()
+    api.send_request.assert_called_with(endpoint="get_account_devices")
+
+    await api.async_get_account_device("DEVICE_ID")
+    api.send_request.assert_called_with(
+        endpoint="get_account_device", DEVICE_ID="DEVICE_ID"
+    )
+
+    await api.async_get_device_daily_summaries("DEVICE_ID")
+    api.send_request.assert_called_with(
+        endpoint="get_device_daily_summaries", DEVICE_ID="DEVICE_ID"
+    )
+
+    await api.async_get_device_monthly_summaries("DEVICE_ID")
+    api.send_request.assert_called_with(
+        endpoint="get_device_monthly_summaries", DEVICE_ID="DEVICE_ID"
+    )
+
+    await api.async_get_device_parental_control_setting("DEVICE_ID")
+    api.send_request.assert_called_with(
+        endpoint="get_device_parental_control_setting", DEVICE_ID="DEVICE_ID"
+    )
+
+    await api.async_get_device_monthly_summary("DEVICE_ID", 2023, 11)
+    api.send_request.assert_called_with(
+        endpoint="get_device_monthly_summary",
+        DEVICE_ID="DEVICE_ID",
+        YEAR=2023,
+        MONTH="11",
+    )
+
+    await api.async_update_restriction_level({"some": "setting"})
+    api.send_request.assert_called_with(
+        endpoint="update_restriction_level", body={"some": "setting"}
+    )
+
+    await api.async_update_extra_playing_time("DEVICE_ID", -1)
+    api.send_request.assert_called_with(
+        endpoint="update_extra_playing_time",
+        body={"deviceId": "DEVICE_ID", "status": "TO_INFINITY"},
+    )
+
+    await api.async_update_extra_playing_time("DEVICE_ID", 60)
+    api.send_request.assert_called_with(
+        endpoint="update_extra_playing_time",
+        body={"deviceId": "DEVICE_ID", "additionalTime": 60, "status": "TO_ADDED"},
+    )
+
+    await api.async_update_play_timer({"some": "setting"})
+    api.send_request.assert_called_with(
+        endpoint="update_play_timer", body={"some": "setting"}
+    )
+
+    await api.async_update_unlock_code("1234", "DEVICE_ID")
+    api.send_request.assert_called_with(
+        endpoint="update_unlock_code",
+        body={"deviceId": "DEVICE_ID", "unlockCode": "1234"},
+    )

pynintendoparental-2.1.1/tests/test_device.py

@@ -0,0 +1,110 @@
+"""Tests for the Device class."""
+
+import copy
+import pytest
+
+from syrupy.assertion import SnapshotAssertion
+from syrupy.filters import props
+
+from pynintendoauth.exceptions import HttpException
+from pynintendoparental.device import Device
+from pynintendoparental.api import Api
+
+from .helpers import load_fixture, clean_device_for_snapshot
+
+
+async def test_device_parsing(mock_api: Api, snapshot: SnapshotAssertion):
+    """Test that the device class parsing works as expected."""
+    devices_response = await load_fixture("account_devices")
+    devices = await Device.from_devices_response(devices_response, mock_api)
+    assert len(devices) > 0
+    device = devices[0]
+
+    mock_api.async_get_device_monthly_summary.assert_called_once()
+
+    test_device = copy.deepcopy(device)
+    assert test_device.last_sync is not None
+    assert test_device.last_sync == device.extra["synchronizedParentalControlSetting"][
+        "synchronizedAt"
+    ]
+    del test_device.extra["synchronizedParentalControlSetting"]["synchronizedAt"]
+    assert test_device.last_sync is None
+    del test_device.extra["synchronizedParentalControlSetting"]
+    assert test_device.last_sync is None
+
+    assert clean_device_for_snapshot(device) == snapshot(
+        exclude=props("today_time_remaining")
+    )
+
+async def test_player_discovery(mock_api: Api):
+    """Test that the device correctly parses players in different scenarios."""
+    devices_response = await load_fixture("account_devices")
+    devices = await Device.from_devices_response(devices_response, mock_api)
+    assert len(devices) > 0
+    device = devices[0]
+    assert len(device.players) > 0
+
+    # Test that the library correctly handles cases where the playerId is not found
+    monthly_summary_response = await load_fixture("device_monthly_summary")
+    players = copy.deepcopy(monthly_summary_response["summary"]["players"][0])
+    del players["profile"]["playerId"]
+    monthly_summary_response["summary"]["players"][0] = players
+
+    mock_api.async_get_device_monthly_summary.return_value = {
+        "status": 200,
+        "json": monthly_summary_response,
+    }
+
+    await device.update()
+    assert mock_api.async_get_device_monthly_summary.call_count == 2
+
+async def test_get_player(mock_api: Api):
+    """Test that the get_player method works as expected."""
+    devices_response = await load_fixture("account_devices")
+    devices = await Device.from_devices_response(devices_response, mock_api)
+    assert len(devices) > 0
+    device = devices[0]
+    assert len(device.players) > 0
+
+    # Get the ID of the first player in the dictionary
+    first_player_id = list(device.players.keys())[0]
+    player = device.get_player(first_player_id)
+    assert player.player_id == first_player_id
+
+    # Now test that it errors
+    with pytest.raises(ValueError):
+        device.get_player("invalid_player_id")
+
+@pytest.mark.parametrize(
+    "mock_api_function,side_effect,expected_log",
+    [
+        pytest.param(
+            "async_get_device_monthly_summary",
+            HttpException(404, "test", "test"),
+            "HTTP Exception raised while getting monthly summary for device {DEVICE_ID}: HTTP 404: test (test)"
+        ),
+        pytest.param(
+            "async_get_device_monthly_summaries",
+            HttpException(404, "test", "test"),
+            "Could not retrieve monthly summaries: HTTP 404: test (test)"
+        )
+    ]
+)
+async def test_get_monthly_summary_error(
+    mock_api: Api,
+    caplog: pytest.LogCaptureFixture,
+    mock_api_function: str,
+    side_effect: Exception,
+    expected_log: str
+):
+    """Test that get_monthly_summary calls correctly handle and log HTTP exceptions."""
+    devices_response = await load_fixture("account_devices")
+    devices = await Device.from_devices_response(devices_response, mock_api)
+    assert len(devices) > 0
+    device = devices[0]
+    assert len(device.players) > 0
+
+    getattr(mock_api, mock_api_function).side_effect = side_effect
+
+    await device.get_monthly_summary()
+    assert expected_log.format(DEVICE_ID=device.device_id) in caplog.text

pynintendoparental-2.1.1/tests/test_init.py

@@ -0,0 +1,80 @@
+"""Tests for the pynintendoparental package."""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from pynintendoauth.exceptions import HttpException
+
+from pynintendoparental import NintendoParental, NoDevicesFoundException
+from pynintendoparental.authenticator import Authenticator
+
+from .helpers import load_fixture
+
+
+@pytest.fixture(name="mock_api_init")
+def fixture_mock_api_init():
+    """Fixture to mock the Api class."""
+    with patch("pynintendoparental.Api", autospec=True) as mock_api:
+        yield mock_api
+
+
+async def test_create_method(
+    mock_authenticator: Authenticator, mock_api_init: AsyncMock
+):
+    """Test the create class method."""
+    devices_fixture = await load_fixture("account_devices")
+    device_id = devices_fixture["ownedDevices"][0]["deviceId"]
+    mock_api_instance = mock_api_init.return_value
+    mock_api_instance.async_get_account_devices.return_value = {"json": devices_fixture}
+
+    parental = await NintendoParental.create(mock_authenticator)
+
+    assert isinstance(parental, NintendoParental)
+    assert parental.account_id == mock_authenticator.account_id
+    assert len(parental.devices) == 1
+    assert device_id in parental.devices
+    mock_api_init.assert_called_once()
+    mock_api_instance.async_get_account_devices.assert_called_once()
+
+
+async def test_no_devices_found(
+    mock_authenticator: Authenticator, mock_api_init: AsyncMock
+):
+    """Test the create class method when no devices are found."""
+    mock_api_instance = mock_api_init.return_value
+    mock_api_instance.async_get_account_devices.side_effect = HttpException(
+        404, "Not Found"
+    )
+
+    with pytest.raises(NoDevicesFoundException):
+        await NintendoParental.create(mock_authenticator)
+
+
+async def test_device_fetch_http_exception(
+    mock_authenticator: Authenticator, mock_api_init: AsyncMock
+):
+    """Test an HttpException when fetching devices."""
+    mock_api_instance = mock_api_init.return_value
+    mock_api_instance.async_get_account_devices.side_effect = HttpException(
+        500, "Internal Server Error"
+    )
+
+    with pytest.raises(HttpException):
+        await NintendoParental.create(mock_authenticator)
+
+
+async def test_device_update_exception(
+    mock_authenticator: Authenticator, mock_api_init: AsyncMock
+):
+    """Test an exception during device update doesn't stop creation."""
+    devices_fixture = await load_fixture("account_devices")
+    device_id = devices_fixture["ownedDevices"][0]["deviceId"]
+    mock_api_instance = mock_api_init.return_value
+    mock_api_instance.async_get_account_devices.return_value = {"json": devices_fixture}
+    with patch(
+        "pynintendoparental.device.Device.update",
+        new=AsyncMock(side_effect=Exception("Update Failed")),
+    ):
+        parental = await NintendoParental.create(mock_authenticator)
+        assert len(parental.devices) == 1
+        assert device_id in parental.devices

pynintendoparental-2.1.1/tests/test_player.py

@@ -0,0 +1,46 @@
+"""Tests for the Player class."""
+
+from syrupy.assertion import SnapshotAssertion
+import copy
+
+from pynintendoparental.player import Player
+
+from .helpers import load_fixture
+
+
+async def test_player_parsing(snapshot: SnapshotAssertion):
+    """Test that the player class parsing works as expected."""
+    daily_summaries_response = await load_fixture("device_daily_summaries")
+    players = Player.from_device_daily_summary(
+        daily_summaries_response["dailySummaries"]
+    )
+    assert len(players) > 0
+    player = players[0]
+
+    assert player == snapshot
+
+
+async def test_player_update_from_daily_summary(snapshot: SnapshotAssertion):
+    """Test that updating a player from a daily summary works."""
+    daily_summaries_response = await load_fixture("device_daily_summaries")
+    players = Player.from_device_daily_summary(
+        daily_summaries_response["dailySummaries"]
+    )
+    assert len(players) > 0
+    player = players[0]
+
+    # Create a deep copy to modify for the update
+    updated_summary = copy.deepcopy(daily_summaries_response)
+
+    # Find the corresponding player in the new summary and update their data
+    for p_summary in updated_summary["dailySummaries"][0]["players"]:
+        if p_summary["profile"]["playerId"] == player.player_id:
+            p_summary["playingTime"] = 54321
+            p_summary["playedGames"] = [{"app": "new_app"}]
+            break
+
+    player.update_from_daily_summary(updated_summary["dailySummaries"])
+
+    assert player.playing_time == 54321
+    assert player.apps == [{"app": "new_app"}]
+    assert player == snapshot

pynintendoparental-2.0.0/pynintendoparental/_version.py

@@ -1 +0,0 @@
-__version__ = "2.0.0"