hyxi-cloud-api 1.4.0__tar.gz → 1.4.2__tar.gz

{hyxi_cloud_api-1.4.0/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.4.0
+Version: 1.4.2
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyxi-cloud-api"
-version = "1.4.0"
+version = "1.4.2"
 authors = [
   { name="Veldkornet", email="Veldkornet@users.noreply.github.com" },
 ]

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/src/hyxi_cloud_api/__init__.py

@@ -5,5 +5,5 @@ from .api import HyxiApiClient
 # Module-level alias so callers can do: from hyxi_cloud_api import VPP_ACTIVE_MODES
 VPP_ACTIVE_MODES: frozenset[str] = HyxiApiClient.VPP_ACTIVE_MODES
 
-__version__ = "1.4.0"
+__version__ = "1.4.2"
 __all__ = ["VPP_ACTIVE_MODES", "HyxiApiClient"]

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/src/hyxi_cloud_api/api.py

@@ -32,6 +32,10 @@ except ImportError:
 import aiohttp
 
 
+class TokenRejectedError(aiohttp.ClientError):
+    """Raised when the HYXI Cloud API rejects an authentication token."""
+
+
 @dataclass
 class FetchState:
     """State object to hold shared data during a device fetch cycle."""
@@ -522,6 +526,23 @@ INTERNAL_ERROR_MAP = {
     "C999999": "Service exception, please contact the service provide",
 }
 
+_TOKEN_REJECTION_CODES = frozenset(
+    (
+        "A000001",
+        "A000002",
+        "A000003",
+        "A000004",
+        "A000005",
+        "A000006",
+        "A000007",
+        "A000008",
+        "A000009",
+        "A000010",
+        "A000011",
+        "C000006",
+    )
+)
+
 
 # Official HYXI Device Type Reference Table
 DEVICE_TYPE_MAP = {
@@ -1207,6 +1228,18 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
             response.raise_for_status()
             res = await response.json()
+
+            if not is_token_request and not res.get("success") and res.get("code"):
+                api_code = res.get("code")
+                if api_code in _TOKEN_REJECTION_CODES:
+                    _LOGGER.debug(
+                        "HYXI Server rejected our token (%s). Forcing immediate token refresh...",
+                        api_code,
+                    )
+                    self.token = None
+                    self.token_expires_at = 0
+                    raise TokenRejectedError("Server rejected token")
+
             return status, res
 
     def _apply_token_response(self, data: dict) -> bool:
@@ -1281,6 +1314,28 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         if not token_status:
             raise error_cls("Could not obtain API token")
 
+    async def _execute_with_auth_retry(
+        self, method: str, path: str, error_cls: type[Exception], **kwargs
+    ) -> dict:
+        """Execute a request with automatic re-authentication if the token is rejected."""
+        await self._ensure_authenticated(error_cls)
+        try:
+            _, res = await self._request(method, path, **kwargs)
+        except TokenRejectedError:
+            _LOGGER.debug(
+                "Token rejected, forcing re-authentication and retrying request to %s...",
+                path,
+            )
+            await self._ensure_authenticated(error_cls)
+            _, res = await self._request(method, path, **kwargs)
+
+        if res is None or not res.get("success"):
+            code = res.get("code", "unknown") if res else "no_response"
+            msg = res.get("msg", "") if res else ""
+            raise error_cls(f"request failed (code={code}): {msg}")
+
+        return res
+
     async def _fetch_device_metrics(self, sn, entry):
         """Helper to fetch detailed metrics for a single device."""
         q_path = "/api/device/v1/queryDeviceData"
@@ -1316,6 +1371,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     _mask_id(sn),
                     _sanitize_dict(res_q),
                 )
+        except TokenRejectedError:  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error("Error fetching metrics for %s: %s", _mask_id(sn), e)
 
@@ -1334,6 +1391,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                 _mask_id(ems_sn),
                 _sanitize_dict(res),
             )
+        except TokenRejectedError:  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error(
                 "HYXI EMS Basic Data Request Failed for %s: %s", _mask_id(ems_sn), e
@@ -1417,6 +1476,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     _sanitize_dict(res_i),
                 )
 
+        except TokenRejectedError:  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error("Error fetching device info for %s: %s", _mask_id(sn), e)
 
@@ -1492,6 +1553,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
             await self._process_devices_for_plant(devices, state)
 
+        except TokenRejectedError:  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error(
                 "Error fetching devices for plant %s: %s", _mask_id(plant_id), e
@@ -1510,7 +1573,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
             self._update_discovery_cache(sn, entry)
 
-            state.metric_tasks.append(self._fetch_all_for_device(sn, entry, dev_type))
+            state.metric_tasks.append((sn, entry, dev_type))
 
             # 🚀 DEEP DISCOVERY: If this is a Collector, DMU, or Inverter, find its children!
             if dev_type in _parent_device_types:
@@ -1544,6 +1607,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
             data_val = res_sd.get("data", {})
             return data_val.get("childDevice", []) if isinstance(data_val, dict) else []
+        except TokenRejectedError:  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error(
                 "Error fetching sub-device list for %s: %s", _mask_id(parent_sn), e
@@ -1575,11 +1640,11 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
                 self._update_discovery_cache(sn, entry)
 
-                # These are real devices, so fetch their metrics/info
-                state.metric_tasks.append(
-                    self._fetch_all_for_device(sn, entry, raw_type)
-                )
+                # These are real devices, so store args for later metric/info fetch
+                state.metric_tasks.append((sn, entry, raw_type))
 
+        except TokenRejectedError:  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error(
                 "Error fetching sub-devices for %s: %s", _mask_id(parent_sn), e
@@ -1613,6 +1678,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     a["alarmName"] = alarm_name
 
             return alarms
+        except TokenRejectedError:  # pylint: disable=try-except-raise  # pylint: disable=try-except-raise
+            raise
         except Exception as e:
             _LOGGER.error(
                 "Error fetching alarms for plant %s: %s", _mask_id(plant_id), e
@@ -1671,16 +1738,6 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         )
 
         if not res_p.get("success"):
-            # 🚀 If the server rejects the token, wipe it and force a retry!
-            if res_p.get("code") in ("A000002", "A000005"):
-                _LOGGER.debug(
-                    "HYXI Server rejected our token (A000002/A000005). Forcing immediate token refresh..."
-                )
-                self.token = None
-                self.token_expires_at = 0
-                # Raising this error kicks it back up to the retry loop
-                raise aiohttp.ClientError("Server rejected token")
-
             _LOGGER.error("HYXI API Plant Fetch Rejected: %s", _sanitize_dict(res_p))
             return None
 
@@ -1742,11 +1799,10 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         if device_fetch_tasks:
             await asyncio.gather(*device_fetch_tasks)
 
-    @staticmethod
-    async def _execute_metric_tasks(plant_alarms, state: FetchState):
+    async def _execute_metric_tasks(self, plant_alarms, state: FetchState):
         """Helper to conditionally execute metrics and map alarms."""
         if state.metric_tasks:
-            await HyxiApiClient._execute_metrics_and_map_alarms(plant_alarms, state)
+            await self._execute_metrics_and_map_alarms(plant_alarms, state)
 
     async def _process_plants_data(
         self, state: FetchState, allow_back_discovery: bool = False
@@ -1783,11 +1839,11 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         state.discovered_sns.add(sn)
 
         entry, dev_type = HyxiApiClient._build_device_entry(sn, a, state.now)
-        state.metric_tasks.append(self._fetch_all_for_device(sn, entry, dev_type))
+        state.metric_tasks.append((sn, entry, dev_type))
 
         # 🚀 DEEP BACK-DISCOVERY: If this is a parent, search for ITS children too!
         if dev_type in _parent_device_types:
-            sub_device_tasks.append(self._fetch_sub_devices(sn, state))
+            sub_device_tasks.append((sn, state))
 
     async def _process_alarms_and_back_discovery(
         self,
@@ -1816,12 +1872,12 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     )
 
         if sub_device_tasks:
-            await asyncio.gather(*sub_device_tasks)
+            tasks = [self._fetch_sub_devices(sn, s) for sn, s in sub_device_tasks]
+            await asyncio.gather(*tasks)
 
         return plant_alarms
 
-    @staticmethod
-    async def _execute_metrics_and_map_alarms(plant_alarms, state: FetchState):
+    async def _execute_metrics_and_map_alarms(self, plant_alarms, state: FetchState):
         """Helper to execute metric tasks and map alarms to devices."""
         # Precompute alarm mapping to optimize from O(N*M) to O(N+M)
         alarms_by_sn = defaultdict(list)
@@ -1830,12 +1886,19 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             if sn:
                 alarms_by_sn[sn].append(a)
 
-        updated_entries = await asyncio.gather(*state.metric_tasks)
-        for sn, entry in updated_entries:
-            if sn:
-                # Map the relevant active alarms to this specific device
-                entry["alarms"] = alarms_by_sn.get(sn, [])
-                state.results[sn] = entry
+        # Convert argument tuples to coroutines just in time
+        tasks = [
+            self._fetch_all_for_device(sn, entry, dev_type)
+            for sn, entry, dev_type in state.metric_tasks
+        ]
+
+        if tasks:
+            updated_entries = await asyncio.gather(*tasks)
+            for sn, entry in updated_entries:
+                if sn:
+                    # Map the relevant active alarms to this specific device
+                    entry["alarms"] = alarms_by_sn.get(sn, [])
+                    state.results[sn] = entry
 
     async def _execute_fetch_all(
         self, allow_back_discovery: bool = False, force_discovery: bool = False
@@ -1882,9 +1945,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     "hw_version": info.get("hw_version"),
                     "metrics": {"last_seen": state.now},
                 }
-                state.metric_tasks.append(
-                    self._fetch_all_for_device(sn, entry, info["device_type_code"])
-                )
+                state.metric_tasks.append((sn, entry, info["device_type_code"]))
             state.discovered_sns = set(info_cache.keys())
 
         # Fetch alarms (to allow back-discovery if enabled) and metrics
@@ -1960,8 +2021,6 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             _LOGGER.warning("set_device_control called with empty settings")
             return {}
 
-        await self._ensure_authenticated(self.ControlError)
-
         path = "/api/device/v2/control"
         body = {
             "deviceControlMap": {device_sn: {str(k): v for k, v in control_map.items()}}
@@ -1971,33 +2030,18 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             _mask_id(device_sn),
             body["deviceControlMap"][device_sn],
         )
-        _, res = await self._request("POST", path, json=body)
-        if res is None or not res.get("success"):
-            code = res.get("code", "unknown") if res else "no_response"
-            msg = res.get("msg", "") if res else ""
-            raise self.ControlError(f"controlMap write failed (code={code}): {msg}")
-        _LOGGER.debug(
-            "HYXI CONTROL response for %s: success=%s",
-            _mask_id(device_sn),
-            res.get("success"),
+        return await self._execute_with_auth_retry(
+            "POST", path, self.ControlError, json=body
         )
-        return res
 
     # ── Subscription API ────────────────────────────────────────────────
 
     async def _post_subscription(self, path: str, body: dict) -> dict:
         """Send an authenticated subscription request."""
-        await self._ensure_authenticated(self.SubscriptionError)
-
         _LOGGER.debug("HYXI subscription request to %s", path)
-        _, res = await self._request("POST", path, json=body)
-        if res is None or not res.get("success"):
-            code = res.get("code", "unknown") if res else "no_response"
-            msg = res.get("msg", "") if res else ""
-            raise self.SubscriptionError(
-                f"subscription request failed (code={code}): {msg}"
-            )
-        return res
+        return await self._execute_with_auth_retry(
+            "POST", path, self.SubscriptionError, json=body
+        )
 
     @staticmethod
     def _validate_subscription_device_sns(device_sn_list: list[str]) -> None:

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2/src/hyxi_cloud_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.4.0
+Version: 1.4.2
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_additional_coverage.py

@@ -34,8 +34,8 @@ async def test_fetch_sub_devices_coverage(caplog):
     # PARENT_SN is masked to ca7b0e8c
     assert "HYXI Found 3 sub-devices under " in caplog.text
     # Verify duplicate/empty check worked (line 1253)
-    assert api._fetch_all_for_device.call_count == 1
-    api._fetch_all_for_device.assert_called_once_with(
+    assert len(state.metric_tasks) == 1
+    assert state.metric_tasks[0] == (
         "NEW_SN",
         {
             "sn": "NEW_SN",

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_api.py

@@ -337,13 +337,15 @@ async def test_execute_fetch_all_concurrent():
     # Mock the _fetch_devices_for_plant internal call
     # It must return an awaitable AND add an awaitable to state.metric_tasks
     async def mock_fetch_devices(plant_id, state):
-        async def mock_metric_task():
-            return (f"SN_{plant_id}", {"device_name": f"Device {plant_id}"})
-
-        state.metric_tasks.append(mock_metric_task())
+        state.metric_tasks.append(
+            (f"SN_{plant_id}", {"device_name": f"Device {plant_id}"}, "MOCK")
+        )
         return None
 
     api._fetch_devices_for_plant = MagicMock(side_effect=mock_fetch_devices)
+    api._fetch_all_for_device = AsyncMock(
+        side_effect=lambda sn, entry, dev_type: (sn, entry)
+    )
 
     # Configure the mock response to simulate aiohttp's async context manager.
     mock_response = MagicMock()

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_device_control.py

@@ -145,7 +145,7 @@ async def test_control_error_on_api_failure():
         )
     )
 
-    with pytest.raises(api.ControlError, match="controlMap write failed"):
+    with pytest.raises(api.ControlError, match="request failed"):
         await api.set_mode_charge("SN123", watts=3000)
 
 
@@ -372,7 +372,7 @@ async def test_set_device_control_no_response():
     api._request = AsyncMock(return_value=(200, None))
 
     with pytest.raises(
-        api.ControlError, match="controlMap write failed \\(code=no_response\\):"
+        api.ControlError, match="request failed \\(code=no_response\\):"
     ):
         await api.set_device_control("SN123", {"1062": "1"})
 
@@ -387,7 +387,7 @@ async def test_set_device_control_api_failure():
     )
 
     with pytest.raises(
-        api.ControlError, match="controlMap write failed \\(code=E123\\): API Error"
+        api.ControlError, match="request failed \\(code=E123\\): API Error"
     ):
         await api.set_device_control("SN123", {"1062": "1"})
 

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_execute_metric_tasks.py

@@ -23,22 +23,27 @@ from src.hyxi_cloud_api.api import FetchState, HyxiApiClient
 @pytest.mark.asyncio
 async def test_execute_metric_tasks_with_tasks():
     """Test _execute_metric_tasks when metric tasks are present."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
     state = FetchState(plants=[{"id": 1}], now="2024-01-01T00:00:00Z")
-    state.metric_tasks = [AsyncMock()]
+    state.metric_tasks = [("SN", {}, "TYPE")]
+    api._execute_metrics_and_map_alarms = AsyncMock()
     plant_alarms = {}
 
-    with patch("asyncio.gather", new_callable=AsyncMock) as mock_gather:
-        await HyxiApiClient._execute_metric_tasks(plant_alarms, state)
-        mock_gather.assert_awaited_once()
+    api._fetch_all_for_device = AsyncMock()
+    with patch("asyncio.gather", new_callable=AsyncMock):
+        await api._execute_metric_tasks(plant_alarms, state)
+        api._execute_metrics_and_map_alarms.assert_awaited_once()
 
 
 @pytest.mark.asyncio
 async def test_execute_metric_tasks_without_tasks():
     """Test _execute_metric_tasks when metric tasks are absent."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
     state = FetchState(plants=[{"id": 1}], now="2024-01-01T00:00:00Z")
     state.metric_tasks = []
     plant_alarms = {}
+    api._execute_metrics_and_map_alarms = AsyncMock()
 
-    with patch("asyncio.gather", new_callable=AsyncMock) as mock_gather:
-        await HyxiApiClient._execute_metric_tasks(plant_alarms, state)
-        mock_gather.assert_not_awaited()
+    with patch("asyncio.gather", new_callable=AsyncMock):
+        await api._execute_metric_tasks(plant_alarms, state)
+        api._execute_metrics_and_map_alarms.assert_not_awaited()

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_execute_metrics_and_map_alarms.py

@@ -16,7 +16,6 @@ if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientEr
     sys.modules["aiohttp"] = m
 mock_aiohttp = sys.modules["aiohttp"]
 
-import asyncio
 
 import pytest
 
@@ -34,17 +33,20 @@ async def test_execute_metrics_and_map_alarms():
 
     state = FetchState(now="2023-10-27")
 
-    async def mock_metric_task(sn, result):
-        return (sn, result)
-
     state.metric_tasks = [
-        asyncio.create_task(mock_metric_task("SN1", {"data": 1})),
-        asyncio.create_task(mock_metric_task("SN2", {"data": 2})),
-        asyncio.create_task(mock_metric_task("SN3", {"data": 3})),  # No alarms
-        asyncio.create_task(mock_metric_task(None, {"data": 4})),  # None SN
+        ("SN1", {"data": 1}, "TYPE"),
+        ("SN2", {"data": 2}, "TYPE"),
+        ("SN3", {"data": 3}, "TYPE"),  # No alarms
+        (None, {"data": 4}, "TYPE"),  # None SN
     ]
 
-    await HyxiApiClient._execute_metrics_and_map_alarms(plant_alarms, state)
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+
+    async def mock_fetch(sn, entry, t):
+        return (sn, entry)
+
+    api._fetch_all_for_device = mock_fetch
+    await api._execute_metrics_and_map_alarms(plant_alarms, state)
 
     assert state.results["SN1"]["data"] == 1
     assert len(state.results["SN1"]["alarms"]) == 2

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_fetch_plants.py

@@ -20,10 +20,9 @@ mock_aiohttp = sys.modules["aiohttp"]
 
 from unittest.mock import AsyncMock, MagicMock, patch
 
-import aiohttp
 import pytest
 
-from hyxi_cloud_api.api import HyxiApiClient
+from hyxi_cloud_api.api import HyxiApiClient, TokenRejectedError
 
 
 @pytest.mark.asyncio
@@ -46,28 +45,6 @@ async def test_fetch_plants_success():
     assert plants[1]["plantId"] == "Pl456"
 
 
-@pytest.mark.parametrize("error_code", ["A000002", "A000005"])
-@pytest.mark.asyncio
-async def test_fetch_plants_token_rejection(error_code):
-    """Verify that _fetch_plants handles token rejection correctly."""
-    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
-    api.token = "Bearer old_token"
-    api.token_expires_at = 9999999999.0
-
-    api._request = AsyncMock(
-        return_value=(
-            200,
-            {"success": False, "code": error_code, "message": "Invalid access token"},
-        )
-    )
-
-    with pytest.raises(aiohttp.ClientError, match="Server rejected token"):
-        await api._fetch_plants()
-
-    assert api.token is None
-    assert api.token_expires_at == 0
-
-
 @pytest.mark.asyncio
 async def test_fetch_plants_generic_failure():
     """Verify that _fetch_plants returns None on generic failure."""
@@ -111,3 +88,37 @@ async def test_fetch_plants_empty_list_warning():
             "If your developer email differs from your app email, you must share "
             "your Plant from the app to the developer email first."
         )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("error_code", ["A000002", "A000005", "C000006"])
+async def test_request_token_rejection_errors_are_raised(error_code):
+    """
+    When the HYXI backend rejects a token with a known error code, _request
+    should raise TokenRejectedError.
+    """
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api.token = "Bearer good_token"
+    api.token_expires_at = 9999999999.0
+
+    mocked_response = {
+        "success": False,
+        "code": error_code,
+        "msg": "Server rejected token",
+    }
+
+    # Mock the aiohttp client session post method
+    mock_post = MagicMock()
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.json = AsyncMock(return_value=mocked_response)
+    mock_post.return_value.__aenter__.return_value = mock_response
+    api.session.post = mock_post
+
+    with pytest.raises(TokenRejectedError) as exc_info:
+        await api._request("POST", "/api/plant/v1/page", json={})
+
+    assert "Server rejected token" in str(exc_info.value)
+    # Ensure token is cleared
+    assert api.token is None
+    assert api.token_expires_at == 0

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_handle_back_discovery_alarm.py

@@ -2,7 +2,7 @@
 # pylint: disable=redefined-outer-name
 
 import sys
-from unittest.mock import ANY, MagicMock
+from unittest.mock import AsyncMock, MagicMock
 
 if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientError"):
     m = MagicMock()
@@ -73,17 +73,16 @@ def test_handle_back_discovery_alarm_success_non_parent(mock_api, mock_state):
     """Test successful discovery of a non-parent device."""
     sub_device_tasks = []
     alarm = {"deviceSn": "SN12345", "deviceType": "METER", "deviceName": "My Meter"}
-    mock_api._fetch_all_for_device = MagicMock(return_value="mock_task")
+    mock_api._fetch_all_for_device = AsyncMock()
 
     mock_api._handle_back_discovery_alarm(alarm, "plant1", mock_state, sub_device_tasks)
 
     assert "SN12345" in mock_state.discovered_sns
     assert len(mock_state.metric_tasks) == 1
-    assert mock_state.metric_tasks[0] == "mock_task"
+    assert mock_state.metric_tasks[0][0] == "SN12345"
     assert not sub_device_tasks
 
-    mock_api._fetch_all_for_device.assert_called_once()
-    args, _ = mock_api._fetch_all_for_device.call_args
+    args = mock_state.metric_tasks[0]
     assert args[0] == "SN12345"
     assert args[1]["sn"] == "SN12345"
     assert args[1]["device_name"] == "My Meter"
@@ -95,17 +94,13 @@ def test_handle_back_discovery_alarm_success_parent(mock_api, mock_state):
     """Test successful discovery of a parent device."""
     sub_device_tasks = []
     alarm = {"deviceSn": "SN_COLL_1", "deviceType": "COLLECTOR"}
-    mock_api._fetch_all_for_device = MagicMock(return_value="metric_task")
-    mock_api._fetch_sub_devices = MagicMock(return_value="sub_task")
+    mock_api._fetch_all_for_device = AsyncMock()
 
     mock_api._handle_back_discovery_alarm(alarm, "plant1", mock_state, sub_device_tasks)
 
     assert "SN_COLL_1" in mock_state.discovered_sns
-    assert mock_state.metric_tasks == ["metric_task"]
-    assert sub_device_tasks == ["sub_task"]
-
-    mock_api._fetch_all_for_device.assert_called_with("SN_COLL_1", ANY, "COLLECTOR")
-    mock_api._fetch_sub_devices.assert_called_with("SN_COLL_1", mock_state)
+    assert len(mock_state.metric_tasks) == 1
+    assert len(sub_device_tasks) == 1
 
 
 def test_handle_back_discovery_alarm_fallback_name(mock_api, mock_state):
@@ -116,7 +111,7 @@ def test_handle_back_discovery_alarm_fallback_name(mock_api, mock_state):
 
     mock_api._handle_back_discovery_alarm(alarm, "plant1", mock_state, sub_device_tasks)
 
-    args, _ = mock_api._fetch_all_for_device.call_args
+    args = mock_state.metric_tasks[0]
     assert args[1]["device_name"] == "Hybrid Inverter SN_INV_1"
     assert args[1]["model"] == "Hybrid Inverter"
 
@@ -129,6 +124,6 @@ def test_handle_back_discovery_alarm_unknown_type(mock_api, mock_state):
 
     mock_api._handle_back_discovery_alarm(alarm, "plant1", mock_state, sub_device_tasks)
 
-    args, _ = mock_api._fetch_all_for_device.call_args
+    args = mock_state.metric_tasks[0]
     assert args[1]["model"] == "Unknown Type"
     assert args[1]["device_name"] == "Unknown Type SN_UNKNOWN"

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_process_alarms_and_back_discovery.py

@@ -114,7 +114,7 @@ async def test_process_alarms_gathers_sub_device_tasks(
     """Test that sub-device tasks created during back-discovery are awaited."""
 
     def side_effect(a, plant_id, state, sub_device_tasks):
-        sub_device_tasks.append("mock_task")
+        sub_device_tasks.append(("sn", state))
 
     mock_api._handle_back_discovery_alarm = MagicMock(side_effect=side_effect)
     alarm_results = [[{"id": "a1"}]]
@@ -123,4 +123,4 @@ async def test_process_alarms_gathers_sub_device_tasks(
         alarm_results, mock_state, allow_back_discovery=True
     )
 
-    mock_gather.assert_called_once_with("mock_task")
+    mock_gather.assert_called_once()

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_process_devices_for_plant.py

@@ -23,7 +23,7 @@ def mock_api():
     """Fixture for a mock API client."""
     api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
     api._update_discovery_cache = MagicMock()
-    api._fetch_all_for_device = MagicMock(return_value="fetch_all_task")
+    api._fetch_all_for_device = AsyncMock()
     api._fetch_sub_devices = MagicMock(return_value="fetch_sub_device_task")
     return api
 
@@ -85,7 +85,7 @@ async def test_process_devices_for_plant_normal_devices(mock_api, mock_state):
         assert "SN_NORMAL_2" in mock_state.discovered_sns
         assert mock_api._update_discovery_cache.call_count == 2
         assert len(mock_state.metric_tasks) == 2
-        assert mock_state.metric_tasks == ["fetch_all_task", "fetch_all_task"]
+        assert len(mock_state.metric_tasks) == 2
 
 
 @pytest.mark.asyncio

{hyxi_cloud_api-1.4.0 → hyxi_cloud_api-1.4.2}/tests/test_subscriptions.py

@@ -188,7 +188,7 @@ async def test_subscription_error_on_api_failure():
         )
     )
 
-    with pytest.raises(api.SubscriptionError, match="subscription request failed"):
+    with pytest.raises(api.SubscriptionError, match="request failed"):
         await api.subscribe_real_time_data("https://example.com/hyxi", ["SN1"], 60000)