python-aidot 0.3.57__tar.gz → 0.3.59__tar.gz

{python_aidot-0.3.57/python_aidot.egg-info → python_aidot-0.3.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.57
+Version: 0.3.59
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024

{python_aidot-0.3.57 → python_aidot-0.3.59}/aidot/client.py

@@ -24,6 +24,11 @@ from .const import (
     CONF_CODE,
     CONF_COUNTRY,
     CONF_DEVICE_LIST,
+    CONF_DIYS,
+    CONF_EFFECTS,
+    CONF_EFFECT_SELECTION,
+    CONF_EFFECT_SOURCE,
+    CONF_FAV_PRESETS,
     CONF_ID,
     CONF_IPADDRESS,
     CONF_PASSWORD,
@@ -48,6 +53,9 @@ from .const import (
     CONF_AES_KEY,
     CONF_FIRMWARE_VERSION,
     CONF_PRIMITIVE,
+    DEFAULT_EFFECT_SOURCE,
+    EFFECT_SOURCE_MANUAL,
+    EFFECT_SOURCE_RECOMMENDED,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -76,9 +84,13 @@ class AidotClient:
         username: str | None = None,
         password: str | None = None,
         token: dict | None = None,
+        options: dict[str, Any] | None = None,
+        effect_source: str = DEFAULT_EFFECT_SOURCE,
     ) -> None:
-        _LOGGER.info("Client Version: v0.3.57")
+        _LOGGER.info("Client Version: v0.3.59")
         self.session = session
+        self.options = options.copy() if options is not None else {}
+        self.effect_source = self.options.get(CONF_EFFECT_SOURCE, effect_source)
         self.username = username
         self.password = password
         self.country_code = country_code or DEFAULT_COUNTRY_CODE
@@ -394,7 +406,7 @@ class AidotClient:
     async def async_get_all_effects(
         self, device: dict[str, Any]
     ) -> dict[str, FavoriteEffectPrimitive]:
-        """Get all effects list."""
+        """Get all effects list and store raw effect sources on the device."""
         diy_list: list[FavoriteEffectPrimitive] = []
         fav_preset: list[FavoriteEffectPrimitive] = []
         preset_list: list[FavoriteEffectPrimitive] = []
@@ -430,7 +442,87 @@ class AidotClient:
         preset_list = [
             item for item in preset_list if item.primitiveEffectId not in fav_preset_ids
         ]
-        return self._merge_effects_by_unique_name(diy_list, fav_preset, preset_list)
+
+        device[CONF_DIYS] = diy_list
+        device[CONF_FAV_PRESETS] = fav_preset
+        device[CONF_PRESETS] = preset_list
+        return self.get_filtered_effects(device)
+
+    def get_filtered_effects(
+        self, device: dict[str, Any]
+    ) -> dict[str, FavoriteEffectPrimitive]:
+        """Get final effects for Home Assistant from raw device effect sources."""
+        diy_list = device.get(CONF_DIYS, [])
+        fav_preset = device.get(CONF_FAV_PRESETS, [])
+        preset_list = device.get(CONF_PRESETS, [])
+
+        if self.effect_source == EFFECT_SOURCE_MANUAL:
+            return self._merge_effects_by_unique_name(
+                self._filter_manual_effects(device, diy_list),
+                self._filter_manual_effects(device, fav_preset),
+                self._filter_manual_effects(device, preset_list),
+            )
+
+        return self._merge_effects_by_unique_name(
+            diy_list,
+            fav_preset,
+            self._filter_preset_list(preset_list),
+        )
+
+    def get_all_cached_effects(
+        self, device: dict[str, Any]
+    ) -> dict[str, FavoriteEffectPrimitive]:
+        """Get all effects from cached raw device effect sources."""
+        return self._merge_effects_by_unique_name(
+            device.get(CONF_DIYS, []),
+            device.get(CONF_FAV_PRESETS, []),
+            device.get(CONF_PRESETS, []),
+        )
+
+    def _filter_manual_effects(
+        self, device: dict[str, Any], effect_list: list[FavoriteEffectPrimitive]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Filter effect list by manual device selection."""
+        selected_ids = self._get_manual_effect_ids(device)
+        return [
+            effect
+            for effect in effect_list
+            if self._get_effect_ids(effect) & selected_ids
+        ]
+
+    def _get_manual_effect_ids(self, device: dict[str, Any]) -> set[str]:
+        """Get manually selected effect ids for a device."""
+        effect_selection = self.options.get(CONF_EFFECT_SELECTION, {})
+        selected_ids = effect_selection.get(device.get(CONF_ID), [])
+        return {effect_id for effect_id in selected_ids if effect_id}
+
+    @staticmethod
+    def _get_effect_ids(effect: FavoriteEffectPrimitive) -> set[str]:
+        """Get selectable ids for an effect."""
+        return {
+            effect_id
+            for effect_id in (effect.primitiveEffectId, effect.favoriteId)
+            if effect_id
+        }
+
+    def _filter_preset_list(
+        self, preset_list: list[FavoriteEffectPrimitive]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Filter preset effects by configured source."""
+        if self.effect_source != EFFECT_SOURCE_RECOMMENDED:
+            return preset_list
+
+        recommended = [
+            effect for effect in preset_list if self._is_recommended_effect(effect)
+        ]
+        if recommended:
+            return recommended
+        return preset_list[:10]
+
+    @staticmethod
+    def _is_recommended_effect(effect: FavoriteEffectPrimitive) -> bool:
+        """Return whether an effect should be included in recommended presets."""
+        return effect.tag not in (None, "") and effect.tag.strip() != "New"
 
     @staticmethod
     def _merge_effects_by_unique_name(
@@ -485,7 +577,7 @@ class AidotClient:
                     and CONF_AES_KEY in device
                     and device[CONF_AES_KEY][0] is not None
                 ):
-                    device[CONF_PRESETS] = await self.async_get_all_effects(device)
+                    device[CONF_EFFECTS] = await self.async_get_all_effects(device)
 
         except Exception as e:
             raise e

{python_aidot-0.3.57 → python_aidot-0.3.59}/aidot/const.py

@@ -215,6 +215,13 @@ CONF_SET_DEV_ATTR_REQ = "setDevAttrReq"
 CONF_DIYS = "diys"
 CONF_PRESETS = "presets"
 CONF_FAV_PRESETS = "favoritePresets"
+CONF_EFFECTS = "effects"
+CONF_EFFECT_SOURCE = "effect_source"
+CONF_EFFECT_SELECTION = "effect_selection"
+EFFECT_SOURCE_ALL = "all"
+EFFECT_SOURCE_RECOMMENDED = "recommended"
+EFFECT_SOURCE_MANUAL = "manual"
+DEFAULT_EFFECT_SOURCE = EFFECT_SOURCE_ALL
 CONF_VERSION = "version"
 CONF_LIGHT_SCRIPT_FLAGS = "lightScriptFlags"
 CONF_PRIMITIVE = "primitive"

{python_aidot-0.3.57 → python_aidot-0.3.59}/aidot/device_client.py

@@ -7,6 +7,7 @@ import time
 import json
 import asyncio
 import logging
+from ipaddress import ip_address
 from typing import TYPE_CHECKING, Any
 
 from .aes_utils import aes_encrypt, aes_decrypt_to_json
@@ -21,6 +22,7 @@ from .models.device_client_model import (
 from .const import (
     CONF_AES_KEY,
     CONF_CCT,
+    CONF_EFFECTS,
     CONF_HARDWARE_VERSION,
     CONF_ID,
     CONF_IDENTITY,
@@ -106,7 +108,7 @@ class DeviceInformation:
         self.model_id = device.get(CONF_MODEL_ID)
         self.name = device.get(CONF_NAME)
         self.hw_version = device.get(CONF_HARDWARE_VERSION)
-        self.presets = device.get(CONF_PRESETS, {})
+        self.presets = device.get(CONF_EFFECTS, device.get(CONF_PRESETS, {}))
         self.preset_names = list(self.presets)
         if CONF_PRODUCT in device and CONF_SERVICE_MODULES in device[CONF_PRODUCT]:
             for service in device[CONF_PRODUCT][CONF_SERVICE_MODULES]:
@@ -174,13 +176,28 @@ class DeviceClient(object):
         self._simpleVersion = device.get("simpleVersion")
         self._TAG = f"{self.device_id}"
         self.syncProperties = []
-        if self.info.model_id == "lk.WIFI-RGBWLight-D0006":
+        if self.info.model_id == "lk.WIFI-RGBWLight-D0006":  # 一代灯
             self.syncProperties = [CONF_ON_OFF, CONF_DIMMING, CONF_RGBW, CONF_CCT]
             self.ping_data = None
             self.heart_time = 10
+        else:
+            properties = device.get(CONF_PROPERTIES)
+            if properties is not None:
+                ip_address = self._get_valid_ip(properties.get("ipAddress"))
+                self.update_ip_address(ip_address)
 
         # _LOGGER.warning(f"{self._TAG}:{device}")
 
+    @staticmethod
+    def _get_valid_ip(ip: str | None) -> str | None:
+        """Return a valid IP address string."""
+        if not ip:
+            return None
+        try:
+            return str(ip_address(ip))
+        except ValueError:
+            return None
+
     async def connect(self, ip_address) -> None:
         _LOGGER.warning(f"{self._TAG}:connect device: {ip_address}")
         self.reader = self.writer = None

{python_aidot-0.3.57 → python_aidot-0.3.59}/aidot/models/device_model.py

@@ -100,6 +100,7 @@ class FavoriteEffectPrimitive:
     icon: str = None
     libraryId: str = "aidot.preset"
     name: str = None
+    tag: str = None
     tags: Optional[FavoriteEffectTags] = None
     scriptSize: int = None
     secondShareFlag: bool = None

{python_aidot-0.3.57 → python_aidot-0.3.59/python_aidot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.57
+Version: 0.3.59
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024

{python_aidot-0.3.57 → python_aidot-0.3.59}/python_aidot.egg-info/SOURCES.txt

@@ -19,4 +19,5 @@ python_aidot.egg-info/SOURCES.txt
 python_aidot.egg-info/dependency_links.txt
 python_aidot.egg-info/requires.txt
 python_aidot.egg-info/top_level.txt
-tests/test_client.py
+tests/test_client.py
+tests/test_device_client.py

{python_aidot-0.3.57 → python_aidot-0.3.59}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="python-aidot",
-    version="0.3.57",
+    version="0.3.59",
     author="aidotdev2024",
     url="https://github.com/Aidot-Development-Team/python-aidot",
     description="aidot control wifi lights",

python_aidot-0.3.59/tests/test_client.py

@@ -0,0 +1,384 @@
+"""Tests for the AiDot client."""
+
+import unittest
+from typing import Any
+from unittest.mock import AsyncMock
+
+import aiohttp
+
+from aidot.client import AidotClient
+from aidot.const import (
+    CONF_ACCESS_TOKEN,
+    CONF_COUNTRY,
+    CONF_DIYS,
+    CONF_EFFECTS,
+    CONF_EFFECT_SELECTION,
+    CONF_EFFECT_SOURCE,
+    CONF_FAV_PRESETS,
+    CONF_ID,
+    CONF_PASSWORD,
+    CONF_PRESETS,
+    CONF_REFRESH_TOKEN,
+    CONF_REGION,
+    CONF_USERNAME,
+    EFFECT_SOURCE_MANUAL,
+    EFFECT_SOURCE_RECOMMENDED,
+)
+from aidot.models.device_model import FavoriteEffectPrimitive
+
+
+class FakeResponse:
+    """Minimal aiohttp response test double."""
+
+    def __init__(self, data: dict[str, Any]) -> None:
+        self._data = data
+
+    async def json(self) -> dict[str, Any]:
+        """Return the response payload."""
+        return self._data
+
+    def raise_for_status(self) -> None:
+        """Represent a successful response."""
+
+
+class FakeSession:
+    """Record requests made by one client."""
+
+    def __init__(self, response: dict[str, Any]) -> None:
+        self._response = response
+        self.post_calls: list[tuple[str, dict[str, str], dict[str, Any]]] = []
+
+    async def post(
+        self,
+        url: str,
+        *,
+        headers: dict[str, str],
+        json: dict[str, Any],
+    ) -> FakeResponse:
+        """Record a POST request."""
+        self.post_calls.append((url, headers, json))
+        return FakeResponse(self._response)
+
+
+class FailingSession:
+    """Raise a typed connection error for every request."""
+
+    async def post(
+        self,
+        url: str,
+        *,
+        headers: dict[str, str],
+        json: dict[str, Any],
+    ) -> FakeResponse:
+        """Simulate a network failure."""
+        raise aiohttp.ClientConnectionError
+
+
+def create_token(
+    *, username: str, region: str, access_token: str, refresh_token: str
+) -> dict[str, Any]:
+    """Create stored login data for a client."""
+    return {
+        CONF_ID: None,
+        CONF_USERNAME: username,
+        CONF_PASSWORD: "password",
+        CONF_COUNTRY: "United States",
+        CONF_REGION: region,
+        CONF_ACCESS_TOKEN: access_token,
+        CONF_REFRESH_TOKEN: refresh_token,
+    }
+
+
+class AidotClientTest(unittest.IsolatedAsyncioTestCase):
+    """Verify client state is isolated by account."""
+
+    async def test_multiple_accounts_keep_state_isolated(self) -> None:
+        """Refreshing one account does not update another account."""
+        first_session = FakeSession(
+            {
+                CONF_ACCESS_TOKEN: "first-new-access",
+                CONF_REFRESH_TOKEN: "first-new-refresh",
+            }
+        )
+        second_session = FakeSession(
+            {
+                CONF_ACCESS_TOKEN: "second-new-access",
+                CONF_REFRESH_TOKEN: "second-new-refresh",
+            }
+        )
+        first_client = AidotClient(
+            session=first_session,
+            token=create_token(
+                username="first@example.com",
+                region="us",
+                access_token="first-access",
+                refresh_token="first-refresh",
+            ),
+        )
+        second_client = AidotClient(
+            session=second_session,
+            token=create_token(
+                username="second@example.com",
+                region="eu",
+                access_token="second-access",
+                refresh_token="second-refresh",
+            ),
+        )
+        refreshed: list[str] = []
+        first_client.set_token_fresh_cb(lambda: refreshed.append("first"))
+        second_client.set_token_fresh_cb(lambda: refreshed.append("second"))
+
+        await first_client.async_refresh_token()
+
+        self.assertIsNot(first_client.login_info, second_client.login_info)
+        self.assertEqual(first_client.login_info[CONF_ACCESS_TOKEN], "first-new-access")
+        self.assertEqual(
+            first_client.login_info[CONF_REFRESH_TOKEN], "first-new-refresh"
+        )
+        self.assertEqual(second_client.login_info[CONF_ACCESS_TOKEN], "second-access")
+        self.assertEqual(second_client.login_info[CONF_REFRESH_TOKEN], "second-refresh")
+        self.assertEqual(second_session.post_calls, [])
+        self.assertEqual(refreshed, ["first"])
+
+    async def test_login_preserves_connection_error(self) -> None:
+        """Login keeps aiohttp connection errors typed for callers."""
+        client = AidotClient(
+            session=FailingSession(),
+            country_code="US",
+            username="user@example.com",
+            password="password",
+        )
+
+        with self.assertRaises(aiohttp.ClientConnectionError):
+            await client.async_post_login()
+
+    def test_recommended_effect_source_keeps_tagged_presets(self) -> None:
+        """Recommended effect source keeps tagged presets except New."""
+        client = AidotClient(session=None, effect_source=EFFECT_SOURCE_RECOMMENDED)
+        presets = [
+            FavoriteEffectPrimitive(name="Calm", primitiveEffectId="p_1"),
+            FavoriteEffectPrimitive(
+                name="Spark",
+                primitiveEffectId="p_3",
+                tag=" New ",
+            ),
+            FavoriteEffectPrimitive(
+                name="Wave",
+                primitiveEffectId="p_4",
+                tag="Hot",
+            ),
+            FavoriteEffectPrimitive(
+                name="Blank tag",
+                primitiveEffectId="p_5",
+                tag="",
+            ),
+            FavoriteEffectPrimitive(
+                name="Space tag",
+                primitiveEffectId="p_6",
+                tag=" ",
+            ),
+        ]
+
+        filtered = client._filter_preset_list(presets)
+
+        self.assertEqual(
+            [effect.name for effect in filtered],
+            ["Wave", "Space tag"],
+        )
+
+    def test_options_effect_source_takes_precedence(self) -> None:
+        """Options effect source takes precedence over legacy argument."""
+        client = AidotClient(
+            session=None,
+            options={CONF_EFFECT_SOURCE: EFFECT_SOURCE_RECOMMENDED},
+        )
+
+        self.assertEqual(client.effect_source, EFFECT_SOURCE_RECOMMENDED)
+
+    def test_recommended_effect_source_falls_back_to_top_ten(self) -> None:
+        """Recommended effect source falls back to the first ten presets."""
+        client = AidotClient(session=None, effect_source=EFFECT_SOURCE_RECOMMENDED)
+        presets = [
+            FavoriteEffectPrimitive(
+                name=f"Effect {index}", primitiveEffectId=f"p_{index}"
+            )
+            for index in range(12)
+        ]
+
+        filtered = client._filter_preset_list(presets)
+
+        self.assertEqual(len(filtered), 10)
+        self.assertEqual(filtered[-1].name, "Effect 9")
+
+    def test_all_effect_source_keeps_all_presets(self) -> None:
+        """All effect source keeps all preset effects."""
+        client = AidotClient(session=None)
+        device = {
+            CONF_DIYS: [
+                FavoriteEffectPrimitive(name="DIY", primitiveEffectId="d_1")
+            ],
+            CONF_FAV_PRESETS: [
+                FavoriteEffectPrimitive(name="Favorite", primitiveEffectId="f_1")
+            ],
+            CONF_PRESETS: [
+                FavoriteEffectPrimitive(name="Hot", primitiveEffectId="p_1", tag=" "),
+                FavoriteEffectPrimitive(
+                    name="New", primitiveEffectId="p_2", tag="New"
+                ),
+                FavoriteEffectPrimitive(name="Plain", primitiveEffectId="p_3"),
+            ],
+        }
+
+        effects = client.get_filtered_effects(device)
+
+        self.assertEqual(list(effects), ["DIY", "Favorite", "Hot", "New", "Plain"])
+
+    def test_manual_effect_source_filters_selected_device_effects(self) -> None:
+        """Manual effect source keeps selected effects for one device."""
+        client = AidotClient(
+            session=None,
+            options={
+                CONF_EFFECT_SOURCE: EFFECT_SOURCE_MANUAL,
+                CONF_EFFECT_SELECTION: {
+                    "device_id_1": ["d_1", "f_1", "p_2"],
+                    "device_id_2": ["p_3"],
+                },
+            },
+        )
+        device = {
+            CONF_ID: "device_id_1",
+            CONF_DIYS: [
+                FavoriteEffectPrimitive(name="DIY", primitiveEffectId="d_1"),
+                FavoriteEffectPrimitive(name="Other DIY", primitiveEffectId="d_2"),
+            ],
+            CONF_FAV_PRESETS: [
+                FavoriteEffectPrimitive(
+                    name="Favorite",
+                    primitiveEffectId="p_1",
+                    favoriteId="f_1",
+                )
+            ],
+            CONF_PRESETS: [
+                FavoriteEffectPrimitive(name="Preset 2", primitiveEffectId="p_2"),
+                FavoriteEffectPrimitive(name="Preset 3", primitiveEffectId="p_3"),
+            ],
+        }
+
+        effects = client.get_filtered_effects(device)
+
+        self.assertEqual(list(effects), ["DIY", "Favorite", "Preset 2"])
+
+    def test_manual_effect_source_returns_empty_without_selection(self) -> None:
+        """Manual effect source returns no effects when device has no selection."""
+        client = AidotClient(
+            session=None,
+            options={
+                CONF_EFFECT_SOURCE: EFFECT_SOURCE_MANUAL,
+                CONF_EFFECT_SELECTION: {
+                    "other_device_id": ["p_1"],
+                },
+            },
+        )
+        device = {
+            CONF_ID: "device_id",
+            CONF_PRESETS: [
+                FavoriteEffectPrimitive(name="Preset", primitiveEffectId="p_1"),
+            ],
+        }
+
+        effects = client.get_filtered_effects(device)
+
+        self.assertEqual(effects, {})
+
+    def test_get_all_cached_effects_ignores_effect_source(self) -> None:
+        """All cached effects ignores the configured effect source."""
+        client = AidotClient(
+            session=None,
+            options={
+                CONF_EFFECT_SOURCE: EFFECT_SOURCE_MANUAL,
+                CONF_EFFECT_SELECTION: {"device_id": ["p_1"]},
+            },
+        )
+        device = {
+            CONF_ID: "device_id",
+            CONF_PRESETS: [
+                FavoriteEffectPrimitive(name="Selected", primitiveEffectId="p_1"),
+                FavoriteEffectPrimitive(name="Available", primitiveEffectId="p_2"),
+            ],
+        }
+
+        effects = client.get_all_cached_effects(device)
+
+        self.assertEqual(list(effects), ["Selected", "Available"])
+
+    async def test_get_all_effects_stores_raw_lists_before_filtering(self) -> None:
+        """All effect sources are stored on the device before final filtering."""
+        client = AidotClient(session=None, effect_source=EFFECT_SOURCE_RECOMMENDED)
+        diy = [FavoriteEffectPrimitive(name="DIY", primitiveEffectId="d_1")]
+        favorite = [
+            FavoriteEffectPrimitive(name="Favorite", primitiveEffectId="p_1")
+        ]
+        presets = [
+            FavoriteEffectPrimitive(
+                name=f"Preset {index}", primitiveEffectId=f"p_{index}"
+            )
+            for index in range(12)
+        ]
+        device = {CONF_ID: "device_id"}
+        client.async_get_diy_list = AsyncMock(return_value=diy)
+        client.async_get_fav_presets = AsyncMock(return_value=favorite)
+        client.async_get_presets = AsyncMock(return_value=presets)
+
+        effects = await client.async_get_all_effects(device)
+
+        self.assertIs(device[CONF_DIYS], diy)
+        self.assertIs(device[CONF_FAV_PRESETS], favorite)
+        self.assertEqual(
+            [effect.primitiveEffectId for effect in device[CONF_PRESETS]],
+            ["p_0", *[f"p_{index}" for index in range(2, 12)]],
+        )
+        self.assertEqual(
+            list(effects),
+            [
+                "DIY",
+                "Favorite",
+                "Preset 0",
+                "Preset 2",
+                "Preset 3",
+                "Preset 4",
+                "Preset 5",
+                "Preset 6",
+                "Preset 7",
+                "Preset 8",
+                "Preset 9",
+                "Preset 10",
+            ],
+        )
+
+    def test_device_information_reads_final_effects(self) -> None:
+        """Device information uses final effects instead of raw preset list."""
+        from aidot.device_client import DeviceInformation
+
+        device = {
+            CONF_ID: "device_id",
+            "mac": "00:11:22:33:44:55",
+            "modelId": "model",
+            "name": "Light",
+            "hardwareVersion": "1",
+            CONF_PRESETS: [
+                FavoriteEffectPrimitive(name="Raw", primitiveEffectId="p_raw")
+            ],
+            CONF_EFFECTS: {
+                "Final": FavoriteEffectPrimitive(
+                    name="Final", primitiveEffectId="p_final"
+                )
+            },
+        }
+
+        info = DeviceInformation(device)
+
+        self.assertEqual(info.preset_names, ["Final"])
+
+
+if __name__ == "__main__":
+    unittest.main()

python_aidot-0.3.59/tests/test_device_client.py

@@ -0,0 +1,65 @@
+"""Tests for the AiDot device client."""
+
+import asyncio
+import unittest
+from unittest.mock import AsyncMock, patch
+
+from aidot.const import (
+    CONF_AES_KEY,
+    CONF_ID,
+    CONF_MODEL_ID,
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_PROPERTIES,
+)
+from aidot.device_client import DeviceClient
+
+
+class DeviceClientTest(unittest.TestCase):
+    """Test device client helpers."""
+
+    def test_get_valid_ip(self) -> None:
+        """Validate IP address strings."""
+        self.assertEqual(DeviceClient._get_valid_ip("192.168.1.10"), "192.168.1.10")
+        self.assertEqual(DeviceClient._get_valid_ip("2001:db8::1"), "2001:db8::1")
+        self.assertIsNone(DeviceClient._get_valid_ip(""))
+        self.assertIsNone(DeviceClient._get_valid_ip(None))
+        self.assertIsNone(DeviceClient._get_valid_ip("999.168.1.10"))
+        self.assertIsNone(DeviceClient._get_valid_ip("not-an-ip"))
+
+
+class AsyncDeviceClientTest(unittest.IsolatedAsyncioTestCase):
+    """Test async device client behavior."""
+
+    def _create_device(self, ip_address: str) -> dict:
+        """Create a test device."""
+        return {
+            CONF_ID: "device-id",
+            CONF_NAME: "Test Light",
+            CONF_MODEL_ID: "aidot.light.rgbw",
+            CONF_AES_KEY: ["mock_aes_key"],
+            CONF_PASSWORD: "password",
+            CONF_PROPERTIES: {"ipAddress": ip_address},
+        }
+
+    async def test_init_with_valid_ip_schedules_login(self) -> None:
+        """A valid IP from cloud properties triggers an initial login attempt."""
+        with patch.object(DeviceClient, "async_login", new=AsyncMock()) as mock_login:
+            device_client = DeviceClient(self._create_device("192.168.1.10"), {}, None)
+            await asyncio.sleep(0)
+
+        self.assertEqual(device_client._ip_address, "192.168.1.10")
+        mock_login.assert_awaited_once()
+
+    async def test_init_with_invalid_ip_does_not_schedule_login(self) -> None:
+        """An invalid IP from cloud properties is ignored."""
+        with patch.object(DeviceClient, "async_login", new=AsyncMock()) as mock_login:
+            device_client = DeviceClient(self._create_device("not-an-ip"), {}, None)
+            await asyncio.sleep(0)
+
+        self.assertIsNone(device_client._ip_address)
+        mock_login.assert_not_awaited()
+
+
+if __name__ == "__main__":
+    unittest.main()

python_aidot-0.3.57/tests/test_client.py

@@ -1,147 +0,0 @@
-"""Tests for the AiDot client."""
-
-import unittest
-from typing import Any
-
-import aiohttp
-
-from aidot.client import AidotClient
-from aidot.const import (
-    CONF_ACCESS_TOKEN,
-    CONF_COUNTRY,
-    CONF_ID,
-    CONF_PASSWORD,
-    CONF_REFRESH_TOKEN,
-    CONF_REGION,
-    CONF_USERNAME,
-)
-
-
-class FakeResponse:
-    """Minimal aiohttp response test double."""
-
-    def __init__(self, data: dict[str, Any]) -> None:
-        self._data = data
-
-    async def json(self) -> dict[str, Any]:
-        """Return the response payload."""
-        return self._data
-
-    def raise_for_status(self) -> None:
-        """Represent a successful response."""
-
-
-class FakeSession:
-    """Record requests made by one client."""
-
-    def __init__(self, response: dict[str, Any]) -> None:
-        self._response = response
-        self.post_calls: list[tuple[str, dict[str, str], dict[str, Any]]] = []
-
-    async def post(
-        self,
-        url: str,
-        *,
-        headers: dict[str, str],
-        json: dict[str, Any],
-    ) -> FakeResponse:
-        """Record a POST request."""
-        self.post_calls.append((url, headers, json))
-        return FakeResponse(self._response)
-
-
-class FailingSession:
-    """Raise a typed connection error for every request."""
-
-    async def post(
-        self,
-        url: str,
-        *,
-        headers: dict[str, str],
-        json: dict[str, Any],
-    ) -> FakeResponse:
-        """Simulate a network failure."""
-        raise aiohttp.ClientConnectionError
-
-
-def create_token(
-    *, username: str, region: str, access_token: str, refresh_token: str
-) -> dict[str, Any]:
-    """Create stored login data for a client."""
-    return {
-        CONF_ID: None,
-        CONF_USERNAME: username,
-        CONF_PASSWORD: "password",
-        CONF_COUNTRY: "United States",
-        CONF_REGION: region,
-        CONF_ACCESS_TOKEN: access_token,
-        CONF_REFRESH_TOKEN: refresh_token,
-    }
-
-
-class AidotClientTest(unittest.IsolatedAsyncioTestCase):
-    """Verify client state is isolated by account."""
-
-    async def test_multiple_accounts_keep_state_isolated(self) -> None:
-        """Refreshing one account does not update another account."""
-        first_session = FakeSession(
-            {
-                CONF_ACCESS_TOKEN: "first-new-access",
-                CONF_REFRESH_TOKEN: "first-new-refresh",
-            }
-        )
-        second_session = FakeSession(
-            {
-                CONF_ACCESS_TOKEN: "second-new-access",
-                CONF_REFRESH_TOKEN: "second-new-refresh",
-            }
-        )
-        first_client = AidotClient(
-            session=first_session,
-            token=create_token(
-                username="first@example.com",
-                region="us",
-                access_token="first-access",
-                refresh_token="first-refresh",
-            ),
-        )
-        second_client = AidotClient(
-            session=second_session,
-            token=create_token(
-                username="second@example.com",
-                region="eu",
-                access_token="second-access",
-                refresh_token="second-refresh",
-            ),
-        )
-        refreshed: list[str] = []
-        first_client.set_token_fresh_cb(lambda: refreshed.append("first"))
-        second_client.set_token_fresh_cb(lambda: refreshed.append("second"))
-
-        await first_client.async_refresh_token()
-
-        self.assertIsNot(first_client.login_info, second_client.login_info)
-        self.assertEqual(first_client.login_info[CONF_ACCESS_TOKEN], "first-new-access")
-        self.assertEqual(
-            first_client.login_info[CONF_REFRESH_TOKEN], "first-new-refresh"
-        )
-        self.assertEqual(second_client.login_info[CONF_ACCESS_TOKEN], "second-access")
-        self.assertEqual(second_client.login_info[CONF_REFRESH_TOKEN], "second-refresh")
-        self.assertEqual(second_session.post_calls, [])
-        self.assertEqual(refreshed, ["first"])
-
-    async def test_login_preserves_connection_error(self) -> None:
-        """Login keeps aiohttp connection errors typed for callers."""
-        client = AidotClient(
-            session=FailingSession(),
-            country_code="US",
-            username="user@example.com",
-            password="password",
-        )
-
-        with self.assertRaises(aiohttp.ClientConnectionError):
-            await client.async_post_login()
-
-
-if __name__ == "__main__":
-    unittest.main()