hyxi-cloud-api 1.5.2__tar.gz → 1.5.4__tar.gz

{hyxi_cloud_api-1.5.2/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.5.2
+Version: 1.5.4
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3
@@ -146,6 +146,10 @@ result = await client.query_control_result(trace_id)
 You can subscribe a callback URL to HYXI push notifications for real-time data,
 alarms, and FCAS/frequency-modulation real-time data.
 
+The callback URL must use HTTPS and contain no credentials: HYXI sends each push
+with your AccessKey in its headers and lists the URL with the subscription, so
+`subscribe_*` raises `ValueError` for any other URL.
+
 ```python
 async def subscription_example(client):
     callback_url = "https://your-public-callback-host/hyxi/callback"

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4}/README.md

@@ -124,6 +124,10 @@ result = await client.query_control_result(trace_id)
 You can subscribe a callback URL to HYXI push notifications for real-time data,
 alarms, and FCAS/frequency-modulation real-time data.
 
+The callback URL must use HTTPS and contain no credentials: HYXI sends each push
+with your AccessKey in its headers and lists the URL with the subscription, so
+`subscribe_*` raises `ValueError` for any other URL.
+
 ```python
 async def subscription_example(client):
     callback_url = "https://your-public-callback-host/hyxi/callback"

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4}/src/hyxi_cloud_api/__init__.py

@@ -13,7 +13,7 @@ from .api import (
 # 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.5.2"
+__version__ = "1.5.4"
 __all__ = [
     "VPP_ACTIVE_MODES",
     "DiscoveryResult",

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4}/src/hyxi_cloud_api/api.py

@@ -19,6 +19,7 @@ import os
 import re
 import secrets
 import time
+import warnings
 from collections import defaultdict
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
@@ -27,9 +28,9 @@ from typing import Any
 from urllib.parse import urlparse
 
 try:
-    from datetime import UTC, datetime
+    from datetime import UTC, datetime, timedelta
 except ImportError:  # pragma: no cover - unreachable given requires-python >=3.14
-    from datetime import datetime, timezone
+    from datetime import datetime, timedelta, timezone
 
     UTC = timezone.utc  # noqa
 
@@ -1151,24 +1152,102 @@ def _compute_derived_metrics(m_raw: dict, device_type: str = "") -> dict:
     return derived
 
 
-def _resolve_push_timestamp(device: dict[str, Any], now_utc: datetime) -> datetime:
-    """Determine the last_seen timestamp from collectTime or reportTimestamp."""
-    collect_time = device.get("collectTime")
-    report_ts = device.get("reportTimestamp")
+# A pushed reading time further than this from its arrival comes from a
+# clock in another time zone: HYXI has stamped readings eight hours behind
+# UTC, UTC's wall time read as China time (UTC+8).
+_PUSH_CLOCK_TOLERANCE = timedelta(minutes=30)
+_PUSH_MAX_CLOCK_OFFSET = timedelta(hours=14)
 
-    if collect_time is not None:
-        try:
-            return datetime.fromtimestamp(float(collect_time), UTC)
-        except ValueError, TypeError, OverflowError, OSError:
-            pass
 
-    if report_ts is not None:
+def _correct_push_clock(reading: datetime, now_utc: datetime) -> datetime:
+    """Move a reading time that is a time zone's whole hours off from its
+    arrival back to UTC, and never place it after its arrival."""
+    offset = now_utc - reading
+    if _PUSH_CLOCK_TOLERANCE < abs(offset) <= _PUSH_MAX_CLOCK_OFFSET:
+        reading += timedelta(hours=offset // timedelta(hours=1))
+    return min(reading, now_utc)
+
+
+def _read_push_timestamp(device: dict[str, Any]) -> datetime | None:
+    """The reading time a push states in collectTime or reportTimestamp."""
+    for value, divisor in (
+        (device.get("collectTime"), 1.0),
+        (device.get("reportTimestamp"), 1000.0),
+    ):
+        if value is None:
+            continue
         try:
-            return datetime.fromtimestamp(float(report_ts) / 1000.0, UTC)
+            return datetime.fromtimestamp(float(value) / divisor, UTC)
         except ValueError, TypeError, OverflowError, OSError:
             pass
+    return None
+
+
+def _resolve_push_timestamp(device: dict[str, Any], now_utc: datetime) -> datetime:
+    """Determine the last_seen timestamp from collectTime or reportTimestamp,
+    or the arrival time when neither is usable."""
+    reading = _read_push_timestamp(device)
+    return now_utc if reading is None else _correct_push_clock(reading, now_utc)
+
+
+def _held_last_seen(
+    existing_metrics: dict[str, dict[str, Any]] | None, sn: str
+) -> datetime | None:
+    """The time of the reading already held for a device, if known."""
+    try:
+        held = datetime.fromisoformat((existing_metrics or {})[sn]["last_seen"])
+    except KeyError, TypeError, ValueError:
+        return None
+    return held if held.tzinfo else held.replace(tzinfo=UTC)
+
+
+def _newest_push_readings(
+    data_list: list, now_utc: datetime
+) -> dict[str, tuple[datetime, dict, bool]]:
+    """Flatten a push's readings and keep each device's newest, as its
+    reading time, flat reading and whether its grid power is already kW."""
+    newest: dict[str, tuple[datetime, dict, bool]] = {}
+
+    for device in data_list:
+        if not isinstance(device, dict):
+            continue
 
-    return now_utc
+        # A nested grid.powerW has already been converted to kW by
+        # _flatten_nested_push_device, regardless of device type.
+        # Mirror its own condition for running that conversion exactly
+        # (not just "a grid dict is present") -- a grid object without
+        # a usable powerW (e.g. only frequencyHz) wouldn't trigger it,
+        # leaving any gridP that slipped through unconverted and still
+        # needing the gridP fixup in _normalize_raw_metrics.
+        raw_grid = device.get("grid")
+        grid_power_converted = (
+            isinstance(raw_grid, dict)
+            and "powerW" in raw_grid
+            and raw_grid["powerW"] is not None
+        )
+        device = _flatten_nested_push_device(device)
+
+        sn = device.get("deviceSn")
+        if not sn:
+            continue
+
+        # A push can carry several readings of a device, out of order.
+        last_seen = _resolve_push_timestamp(device, now_utc)
+        best = newest.get(sn)
+        if best is None or last_seen > best[0]:
+            newest[sn] = (last_seen, device, grid_power_converted)
+
+    return newest
+
+
+def _drop_eps_phase_powers(device: dict[str, Any]) -> None:
+    """Remove ph1p..ph3p where they repeat ph1peps..ph3peps: in a flat push
+    they report the backup (EPS) port, not the inverter's AC phases that a
+    poll reports under the same keys."""
+    for i in range(1, 4):
+        key, eps_key = f"ph{i}p", f"ph{i}peps"
+        if eps_key in device and device.get(key) == device[eps_key]:
+            device.pop(key, None)
 
 
 def _extract_raw_push_metrics(device: dict[str, Any]) -> dict[str, Any]:
@@ -1219,6 +1298,8 @@ def _flatten_nested_push_device(device: dict) -> dict:
     _flatten_phases_section(device, flat)
     _flatten_grid_section(device, flat)
     _copy_remaining_root_keys(device, flat)
+    if not isinstance(device.get("phases"), dict):
+        _drop_eps_phase_powers(flat)
     return flat
 
 
@@ -1872,6 +1953,10 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
         )
         return token_expires_at
 
+    @warnings.deprecated(
+        "HyxiApiClient._refresh_token() is deprecated; call ensure_token(), "
+        "which raises HyxiAuthError or TokenRequestError on failure"
+    )
     async def _refresh_token(self) -> bool | str | None:
         """Status-returning wrapper around ensure_token(), for callers that
         predate its exceptions: True on success, "auth_failed" for rejected
@@ -2929,13 +3014,28 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
             raise ValueError("device_sn_list cannot contain more than 1000 device SNs")
 
     @staticmethod
-    def _validate_callback_url(callback_url: str) -> None:
-        """Validate the subscriber callback URL."""
-        if not callback_url or not callback_url.strip():
+    def _validate_callback_url(callback_url: str) -> str:
+        """Return the subscriber callback URL without surrounding whitespace,
+        after checking it is an HTTPS URL with a host, a valid port if any,
+        and no credentials: HYXI sends each push with the AccessKey in its
+        headers, and lists the URL with the subscription."""
+        url = (callback_url or "").strip()
+        if not url:
             raise ValueError("callback_url must be a non-empty string")
-        parsed = urlparse(callback_url.strip())
-        if parsed.scheme not in ("http", "https") or not parsed.netloc:
-            raise ValueError("callback_url must be a valid http/https URL")
+        invalid = "callback_url must be a valid https URL"
+        try:
+            parsed = urlparse(url)
+            if not (
+                parsed.scheme == "https"
+                and parsed.hostname
+                and parsed.port != 0
+                and parsed.username is None
+                and parsed.password is None
+            ):
+                raise ValueError(invalid)
+        except ValueError as err:
+            raise ValueError(invalid) from err
+        return url
 
     @staticmethod
     def _validate_post_rate_ms(post_rate: int) -> None:
@@ -2954,7 +3054,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
 
         Endpoint: POST /api/subscribe/v1/realTimeData
         """
-        self._validate_callback_url(callback_url)
+        callback_url = self._validate_callback_url(callback_url)
         self._validate_subscription_device_sns(device_sn_list)
         self._validate_post_rate_ms(post_rate)
 
@@ -2979,7 +3079,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
 
         Endpoint: POST /api/subscribe/v1/alarm
         """
-        self._validate_callback_url(callback_url)
+        callback_url = self._validate_callback_url(callback_url)
         self._validate_subscription_device_sns(device_sn_list)
         self._validate_post_rate_ms(post_rate)
 
@@ -3006,7 +3106,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
         Args:
             post_rate: Push rate in hours. Must be between 1 and 6.
         """
-        self._validate_callback_url(callback_url)
+        callback_url = self._validate_callback_url(callback_url)
         self._validate_subscription_device_sns(device_sn_list)
         if not 1 <= post_rate <= 6:
             raise ValueError("post_rate must be between 1 and 6 hours")
@@ -3252,7 +3352,10 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
         """Process real-time push data from HYXI Cloud.
 
         Parses the flat push payload, matches it to the discovery cache,
-        filters collector metrics, and computes derived metrics.
+        filters collector metrics, and computes derived metrics. Only the
+        newest reading of each device is used, and a device is left out when
+        that reading is not newer than the ``last_seen`` in
+        ``existing_metrics``.
 
         Returns a dictionary of:
         {
@@ -3274,29 +3377,16 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
             return {}
 
         now_utc = datetime.now(UTC)
-        results = {}
-
-        for device in data_list:
-            if not isinstance(device, dict):
-                continue
-
-            # A nested grid.powerW has already been converted to kW by
-            # _flatten_nested_push_device below, regardless of device type.
-            # Mirror its own condition for running that conversion exactly
-            # (not just "a grid dict is present") -- a grid object without
-            # a usable powerW (e.g. only frequencyHz) wouldn't trigger it,
-            # leaving any gridP that slipped through unconverted and still
-            # needing the gridP fixup in _normalize_raw_metrics below.
-            raw_grid = device.get("grid")
-            grid_power_converted = (
-                isinstance(raw_grid, dict)
-                and "powerW" in raw_grid
-                and raw_grid["powerW"] is not None
-            )
-            device = _flatten_nested_push_device(device)
+        newest = _newest_push_readings(data_list, now_utc)
 
-            sn = device.get("deviceSn")
-            if not sn:
+        results = {}
+        for sn, (last_seen, device, grid_power_converted) in newest.items():
+            held_last_seen = _held_last_seen(existing_metrics, sn)
+            if held_last_seen is not None and last_seen <= held_last_seen:
+                _LOGGER.debug(
+                    "HYXI push: reading for %s is not newer than the held one",
+                    _mask_id(sn),
+                )
                 continue
 
             # Retrieve info from discovery cache
@@ -3311,7 +3401,6 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes,too-many-pu
             _normalize_raw_metrics(device, device_type, skip_gridp=grid_power_converted)
 
             raw_metrics = _extract_raw_push_metrics(device)
-            last_seen = _resolve_push_timestamp(device, now_utc)
 
             merged_metrics = _merge_push_metrics(
                 sn, raw_metrics, device_type, existing_metrics

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4/src/hyxi_cloud_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.5.2
+Version: 1.5.4
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3
@@ -146,6 +146,10 @@ result = await client.query_control_result(trace_id)
 You can subscribe a callback URL to HYXI push notifications for real-time data,
 alarms, and FCAS/frequency-modulation real-time data.
 
+The callback URL must use HTTPS and contain no credentials: HYXI sends each push
+with your AccessKey in its headers and lists the URL with the subscription, so
+`subscribe_*` raises `ValueError` for any other URL.
+
 ```python
 async def subscription_example(client):
     callback_url = "https://your-public-callback-host/hyxi/callback"

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4}/src/hyxi_cloud_api.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ tests/test_parser.py
 tests/test_process_alarms_and_back_discovery.py
 tests/test_process_devices_for_plant.py
 tests/test_push.py
+tests/test_push_readings.py
 tests/test_request_concurrency.py
 tests/test_sanitize_dict.py
 tests/test_sanitize_list.py

hyxi_cloud_api-1.5.4/tests/test_push_readings.py

@@ -0,0 +1,183 @@
+"""Tests for which pushed readings process_push_data uses, and when."""
+
+from datetime import UTC, datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hyxi_cloud_api import HyxiApiClient
+from hyxi_cloud_api import api as api_module
+
+SN = "INV123"
+
+# When HYXI delivered the captured reading below.
+ARRIVAL = datetime(2026, 10, 10, 16, 33, 16, tzinfo=UTC)
+
+# A flat reading as HYXI pushed it (trimmed): its collectTime reads
+# 08:31:30Z, eight hours behind its arrival, and ph1p..ph3p repeat the
+# backup port's ph1peps..ph3peps.
+CAPTURED_READING = {
+    "deviceSn": SN,
+    "collectTime": 1791621090000,
+    "createTime": "2026-10-11T00:31:42.947836",
+    "acP": 9994.0,
+    "gridP": None,
+    "batSoc": 89,
+    "ph1p": 1,
+    "ph2p": 3,
+    "ph3p": 2,
+    "ph1peps": 1,
+    "ph2peps": 3,
+    "ph3peps": 2,
+    "ph1Loadp": 546,
+    "ph2Loadp": 2791,
+    "ph3Loadp": 57,
+}
+
+# The captured reading's corrected time.
+READING_TIME = "2026-10-10T16:31:30+00:00"
+
+
+class _FrozenDatetime(datetime):
+    @classmethod
+    def now(cls, tz=None):
+        return ARRIVAL.astimezone(tz)
+
+
+@pytest.fixture
+def api():
+    """A client that knows the device, at the captured reading's arrival."""
+    client = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    client._discovery_cache["device_info"] = {
+        SN: {"model": "HYX-H10K-HT", "device_type_code": "HYBRID_INVERTER"}
+    }
+    with patch.object(api_module, "datetime", _FrozenDatetime):
+        yield client
+
+
+def _reading(**changes) -> dict:
+    return {**CAPTURED_READING, **changes}
+
+
+def _ms(iso: str) -> int:
+    return int(datetime.fromisoformat(iso).timestamp() * 1000)
+
+
+def test_a_reading_hours_off_is_corrected_to_utc(api):
+    """A collectTime that is a time zone's whole hours off from its arrival
+    is moved back to UTC."""
+    results = api.process_push_data({"dataList": [_reading()]})
+
+    assert results[SN]["metrics"]["last_seen"] == READING_TIME
+
+
+@pytest.mark.parametrize(
+    ("collect_time", "last_seen"),
+    [
+        ("2026-10-10T16:20:00+00:00", "2026-10-10T16:20:00+00:00"),
+        ("2026-10-10T16:40:00+00:00", "2026-10-10T16:33:16+00:00"),
+        ("2026-10-11T00:31:30+00:00", "2026-10-10T16:31:30+00:00"),
+        ("2026-10-10T15:48:16+00:00", "2026-10-10T15:48:16+00:00"),
+        ("2026-10-09T16:00:00+00:00", "2026-10-09T16:00:00+00:00"),
+    ],
+    ids=["utc", "slightly-ahead", "hours-ahead", "45-minutes-late", "a-day-old"],
+)
+def test_reading_times_close_to_arrival_or_beyond_a_time_zone_are_kept(
+    api, collect_time, last_seen
+):
+    """A reading time within half an hour of its arrival is kept, but never
+    placed after the arrival; one less than a whole hour late, or more than
+    a time zone away, is not shifted."""
+    results = api.process_push_data(
+        {"dataList": [_reading(collectTime=_ms(collect_time))]}
+    )
+
+    assert results[SN]["metrics"]["last_seen"] == last_seen
+
+
+def test_the_newest_of_several_readings_is_used(api):
+    """A push with several readings of a device, out of order, uses the
+    newest one."""
+    newest = _reading()
+    older = _reading(collectTime=CAPTURED_READING["collectTime"] - 60_000, batSoc=88)
+
+    results = api.process_push_data({"dataList": [newest, older]})
+
+    metrics = results[SN]["metrics"]
+    assert metrics["batSoc"] == 89
+    assert metrics["last_seen"] == READING_TIME
+
+
+@pytest.mark.parametrize(
+    "held_last_seen",
+    [READING_TIME, "2026-10-10T16:32:00+00:00", "2026-10-10T16:32:00"],
+    ids=["same-reading", "newer-poll", "naive-time"],
+)
+def test_a_reading_not_newer_than_the_held_one_is_left_out(api, held_last_seen):
+    """A reading HYXI sends again, or one older than what a poll already
+    returned, does not replace the held metrics."""
+    existing = {SN: {"batSoc": 90, "last_seen": held_last_seen}}
+
+    assert api.process_push_data({"dataList": [_reading()]}, existing) == {}
+
+
+@pytest.mark.parametrize(
+    "held_last_seen", ["2026-10-10T16:30:00+00:00", None, "not-a-time"]
+)
+def test_a_reading_newer_than_the_held_one_is_used(api, held_last_seen):
+    """A newer reading, or one for a device without a usable held time,
+    updates the metrics."""
+    existing = {SN: {"batSoc": 90, "last_seen": held_last_seen}}
+
+    results = api.process_push_data({"dataList": [_reading()]}, existing)
+
+    assert results[SN]["metrics"]["batSoc"] == 89
+    assert results[SN]["metrics"]["last_seen"] == READING_TIME
+
+
+def test_backup_port_phase_powers_keep_the_polled_ones(api):
+    """Pushed ph1p..ph3p that repeat the backup port's powers do not replace
+    the inverter's phase powers a poll returned."""
+    existing = {
+        SN: {
+            "ph1p": 1201.0,
+            "ph2p": 1189.0,
+            "ph3p": 1195.0,
+            "last_seen": "2026-10-10T16:30:00+00:00",
+        }
+    }
+
+    metrics = api.process_push_data({"dataList": [_reading()]}, existing)[SN]["metrics"]
+
+    assert (metrics["ph1p"], metrics["ph2p"], metrics["ph3p"]) == (
+        1201.0,
+        1189.0,
+        1195.0,
+    )
+    assert metrics["ph1peps"] == 1
+    assert metrics["ph2Loadp"] == 2791
+
+
+def test_phase_powers_that_differ_from_the_backup_port_are_used(api):
+    """Pushed phase powers that are not the backup port's are kept."""
+    metrics = api.process_push_data(
+        {"dataList": [_reading(ph1p=1201.0, ph2p=None, ph3p=1195.0)]}
+    )[SN]["metrics"]
+
+    assert metrics["ph1p"] == 1201.0
+    assert "ph2p" not in metrics
+    assert metrics["ph3p"] == 1195.0
+
+
+def test_nested_phase_powers_are_kept(api):
+    """Phase powers from a nested push's phases section are the inverter's,
+    so they are kept even when they equal the backup port's."""
+    nested = {
+        "record": {"deviceSn": SN, "collectTime": 1791621090000},
+        "ph1peps": 1,
+        "phases": {"ph1": {"powerW": 1}},
+    }
+
+    metrics = api.process_push_data({"dataList": [nested]})[SN]["metrics"]
+
+    assert metrics["ph1p"] == 1

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4}/tests/test_subscriptions.py

@@ -220,33 +220,77 @@ async def test_subscription_validation():
         await api.cancel_subscription(" ")
 
 
-def test_validate_callback_url():
-    """Test validation of subscriber callback URLs."""
-    # Happy paths shouldn't raise any exception
-    HyxiApiClient._validate_callback_url("http://example.com")
-    HyxiApiClient._validate_callback_url("https://example.com/callback")
-    HyxiApiClient._validate_callback_url("  https://example.com/whitespace  ")
-    HyxiApiClient._validate_callback_url("http://localhost:8080")
-
-    # Empty and whitespace
-    with pytest.raises(ValueError, match="callback_url must be a non-empty string"):
-        HyxiApiClient._validate_callback_url("")
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("subscribe", "post_rate"),
+    [
+        ("subscribe_real_time_data", 60000),
+        ("subscribe_alarm", 60000),
+        ("subscribe_fm_real_time_data", 6),
+    ],
+)
+async def test_a_plain_http_callback_is_never_sent(subscribe, post_rate):
+    """Every subscribe call refuses a plain-HTTP callback URL before
+    sending anything to HYXI."""
+    api = _client()
 
-    with pytest.raises(ValueError, match="callback_url must be a non-empty string"):
-        HyxiApiClient._validate_callback_url("   ")
+    with pytest.raises(ValueError, match="valid https URL"):
+        await getattr(api, subscribe)("http://example.com/hyxi", ["SN1"], post_rate)
 
-    # Invalid schemas / URLs
-    with pytest.raises(ValueError, match="callback_url must be a valid http/https URL"):
-        HyxiApiClient._validate_callback_url("ftp://example.com")
+    api._request.assert_not_awaited()
 
-    with pytest.raises(ValueError, match="callback_url must be a valid http/https URL"):
-        HyxiApiClient._validate_callback_url("example.com")
 
-    with pytest.raises(ValueError, match="callback_url must be a valid http/https URL"):
-        HyxiApiClient._validate_callback_url("http://")
+@pytest.mark.asyncio
+async def test_the_callback_url_is_sent_without_surrounding_whitespace():
+    """The callback URL HYXI stores is the one that was validated."""
+    api = _client()
+    api._post_subscription = AsyncMock(return_value={"success": True})
 
-    with pytest.raises(ValueError, match="callback_url must be a valid http/https URL"):
-        HyxiApiClient._validate_callback_url("://example.com")
+    await api.subscribe_alarm("  https://example.com/hyxi  ", ["SN1"], 60000)
+
+    body = api._post_subscription.call_args.args[1]
+    assert body["callBackUrl"] == "https://example.com/hyxi"
+
+
+def test_validate_callback_url():
+    """An HTTPS callback URL is accepted and returned without surrounding
+    whitespace; an empty one is refused."""
+    assert (
+        HyxiApiClient._validate_callback_url("https://example.com/callback")
+        == "https://example.com/callback"
+    )
+    assert (
+        HyxiApiClient._validate_callback_url("  https://example.com/whitespace  ")
+        == "https://example.com/whitespace"
+    )
+    assert HyxiApiClient._validate_callback_url("https://localhost:8443")
+
+    for url in ("", "   ", None):
+        with pytest.raises(ValueError, match="callback_url must be a non-empty string"):
+            HyxiApiClient._validate_callback_url(url)
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "ftp://example.com",
+        "http://example.com/callback",
+        "example.com",
+        "http://",
+        "://example.com",
+        "https://:443/callback",
+        "https://example.com:abc/callback",
+        "https://example.com:99999/callback",
+        "https://example.com:0/callback",
+        "https://user:secret@example.com/callback",
+        "https://[::1/callback",
+    ],
+)
+def test_a_callback_url_that_is_not_plain_https_is_refused(url):
+    """Anything but an HTTPS URL with a host, a valid port and no
+    credentials is refused."""
+    with pytest.raises(ValueError, match="callback_url must be a valid https URL"):
+        HyxiApiClient._validate_callback_url(url)
 
 
 @pytest.mark.asyncio

{hyxi_cloud_api-1.5.2 → hyxi_cloud_api-1.5.4}/tests/test_token_errors.py

@@ -135,12 +135,14 @@ async def test_ensure_token_unexpected_exception_propagates():
     ],
 )
 async def test_refresh_token_keeps_status_return_values(side_effect, expected):
-    """_refresh_token maps ensure_token's outcome onto its original return
-    values, which ha-hyxi-cloud's config flow branches on."""
+    """The deprecated _refresh_token warns, and still maps ensure_token's
+    outcome onto its original return values, which ha-hyxi-cloud's config
+    flow up to 1.7.0 branches on."""
     api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
     api.ensure_token = AsyncMock(side_effect=side_effect)
 
-    assert await api._refresh_token() == expected
+    with pytest.warns(DeprecationWarning, match="call ensure_token"):
+        assert await api._refresh_token() == expected
 
 
 def _token_session(api, body=None, json_error=None):