hyxi-cloud-api 1.3.7__tar.gz → 1.3.9__tar.gz

{hyxi_cloud_api-1.3.7/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.3.9}/PKG-INFO

@@ -1,12 +1,9 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.3.7
+Version: 1.3.9
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyxi-cloud-api"
-version = "1.3.7"
+version = "1.3.9"
 authors = [
   { name="Veldkornet", email="Veldkornet@users.noreply.github.com" },
 ]
@@ -16,9 +16,6 @@ dependencies = [
 ]
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/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.3.7"
+__version__ = "1.3.9"
 __all__ = ["VPP_ACTIVE_MODES", "HyxiApiClient"]

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/src/hyxi_cloud_api/api.py

@@ -15,6 +15,7 @@ import hmac
 import logging
 import os
 import re
+import secrets
 import time
 from collections import defaultdict
 from dataclasses import dataclass, field
@@ -646,28 +647,44 @@ def _compute_battery_metrics(
         return True
 
     # Unify cumulative battery charge energy telemetry keys to resolve polling/push mismatch
-    charge_val = None
-    if _is_valid_metric("batCharge"):
-        charge_val = _get_f("batCharge", m_raw)
-    elif _is_valid_metric("totalEchg"):
-        charge_val = _get_f("totalEchg", m_raw)
-
-    if charge_val is not None:
-        derived["bat_charge_total"] = charge_val
-        derived["totalEchg"] = charge_val
-        derived["batCharge"] = charge_val
+    total_echg_val = (
+        _get_f("totalEchg", m_raw) if _is_valid_metric("totalEchg") else None
+    )
+    bat_charge_val = (
+        _get_f("batCharge", m_raw) if _is_valid_metric("batCharge") else None
+    )
+
+    if total_echg_val is not None:
+        derived["totalEchg"] = total_echg_val
+        derived["bat_charge_total"] = total_echg_val
+        if bat_charge_val is None:
+            derived["batCharge"] = total_echg_val
+
+    if bat_charge_val is not None:
+        derived["batCharge"] = bat_charge_val
+        if total_echg_val is None:
+            derived["totalEchg"] = bat_charge_val
+            derived["bat_charge_total"] = bat_charge_val
 
     # Unify cumulative battery discharge energy telemetry keys to resolve polling/push mismatch
-    discharge_val = None
-    if _is_valid_metric("batDisCharge"):
-        discharge_val = _get_f("batDisCharge", m_raw)
-    elif _is_valid_metric("totalEdchg"):
-        discharge_val = _get_f("totalEdchg", m_raw)
-
-    if discharge_val is not None:
-        derived["bat_discharge_total"] = discharge_val
-        derived["totalEdchg"] = discharge_val
-        derived["batDisCharge"] = discharge_val
+    total_edchg_val = (
+        _get_f("totalEdchg", m_raw) if _is_valid_metric("totalEdchg") else None
+    )
+    bat_discharge_val = (
+        _get_f("batDisCharge", m_raw) if _is_valid_metric("batDisCharge") else None
+    )
+
+    if total_edchg_val is not None:
+        derived["totalEdchg"] = total_edchg_val
+        derived["bat_discharge_total"] = total_edchg_val
+        if bat_discharge_val is None:
+            derived["batDisCharge"] = total_edchg_val
+
+    if bat_discharge_val is not None:
+        derived["batDisCharge"] = bat_discharge_val
+        if total_edchg_val is None:
+            derived["totalEdchg"] = bat_discharge_val
+            derived["bat_discharge_total"] = bat_discharge_val
 
 
 def _compute_pv_metrics(m_raw: dict, derived: dict[str, float]) -> None:
@@ -883,6 +900,22 @@ def _flatten_nested_push_device(device: dict) -> dict:  # pylint: disable=too-ma
     return flat
 
 
+# Deployment-configured secret for log masking. If not provided,
+# falls back to a process-random secret.
+_LOG_SALT = os.environ.get("HYXI_LOG_SALT", "").encode("utf-8") or secrets.token_bytes(
+    16
+)
+
+
+def set_log_salt(salt: str | bytes) -> None:
+    """Set a deployment-stable secret for cross-device log correlation."""
+    global _LOG_SALT  # pylint: disable=global-statement
+    if isinstance(salt, str):
+        salt = salt.encode("utf-8")
+    _LOG_SALT = salt
+    _mask_id.cache_clear()
+
+
 @functools.lru_cache(maxsize=1024)
 def _mask_id(value: str) -> str:
     """Mask an identifier (SN, plant ID, etc.) for logs.
@@ -896,7 +929,7 @@ def _mask_id(value: str) -> str:
     if not value or value == "None":
         return "****"
     id_str = str(value)
-    return hashlib.sha256(id_str.encode("utf-8")).hexdigest()[:8]
+    return hmac.new(_LOG_SALT, id_str.encode("utf-8"), hashlib.sha256).hexdigest()[:8]
 
 
 # Keys in raw API response dicts that contain identifying or personal information.

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9/src/hyxi_cloud_api.egg-info}/PKG-INFO

@@ -1,12 +1,9 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.3.7
+Version: 1.3.9
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/src/hyxi_cloud_api.egg-info/SOURCES.txt

@@ -18,10 +18,12 @@ tests/test_compute_battery_metrics.py
 tests/test_compute_derived_metrics.py
 tests/test_compute_grid_metrics.py
 tests/test_compute_load_metrics.py
+tests/test_compute_pv_metrics.py
 tests/test_device_control.py
 tests/test_device_entry.py
 tests/test_devices_errors.py
 tests/test_discovery.py
+tests/test_ensure_authenticated.py
 tests/test_execute_device_tasks.py
 tests/test_execute_metric_tasks.py
 tests/test_execute_metrics_and_map_alarms.py
@@ -33,6 +35,7 @@ tests/test_fetch_plants.py
 tests/test_fetch_state.py
 tests/test_fetch_sub_device_list.py
 tests/test_filter_metrics.py
+tests/test_flatten_nested_push_device.py
 tests/test_fuzz_parser.py
 tests/test_get_f.py
 tests/test_handle_back_discovery_alarm.py

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_additional_coverage.py

@@ -32,7 +32,7 @@ async def test_fetch_sub_devices_coverage(caplog):
 
     # Verify debug log was hit (line 1243)
     # PARENT_SN is masked to ca7b0e8c
-    assert "HYXI Found 3 sub-devices under ca7b0e8c" in caplog.text
+    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(
@@ -54,7 +54,8 @@ async def test_fetch_sub_devices_coverage(caplog):
     api._fetch_sub_device_list = AsyncMock(side_effect=Exception("Database failure"))
     await api._fetch_sub_devices("PARENT_SN", state)
     # PARENT_SN is masked to ca7b0e8c
-    assert "Error fetching sub-devices for ca7b0e8c: Database failure" in caplog.text
+    assert "Error fetching sub-devices for " in caplog.text
+    assert "Database failure" in caplog.text
 
 
 @pytest.mark.asyncio
@@ -71,7 +72,7 @@ async def test_fetch_alarms_for_plant_coverage(caplog):
     res = await api._fetch_alarms_for_plant("PLANT_123")
     assert res == []
     # PLANT_123 is masked to b7a0873d
-    assert "HYXI API Alarm Fetch Rejected for Plant b7a0873d" in caplog.text
+    assert "HYXI API Alarm Fetch Rejected for Plant " in caplog.text
 
     # 2. Alarm Name Mapping (line 1295)
     api._request = AsyncMock(

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_api.py

@@ -592,7 +592,8 @@ async def test_fetch_alarms_for_plant_error(caplog):
     assert alarms == []
 
     log_text = caplog.text
-    assert "Error fetching alarms for plant ef797c81: Connection reset" in log_text
+    assert "Error fetching alarms for plant " in log_text
+    assert "Connection reset" in log_text
 
 
 @pytest.mark.asyncio

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_compute_battery_metrics.py

@@ -107,3 +107,62 @@ def test_compute_battery_metrics_none_device_type():
     _compute_battery_metrics(m_raw, derived, None)  # type: ignore
     assert derived["bat_charging"] == 100.0
     assert derived["bat_power_dc"] == -100.0
+
+
+def test_compute_battery_metrics_both_present():
+    """Test that when both polling and daily keys are present, they are preserved.
+
+    Cumulative values should take priority for battery totals.
+    """
+    derived: dict[str, float] = {}
+    m_raw = {
+        "totalEchg": 366.3,
+        "totalEdchg": 371.3,
+        "batCharge": 2.3,
+        "batDisCharge": 4.4,
+    }
+    _compute_battery_metrics(m_raw, derived, "OTHER")
+    assert derived["bat_charge_total"] == 366.3
+    assert derived["bat_discharge_total"] == 371.3
+    assert derived["totalEchg"] == 366.3
+    assert derived["totalEdchg"] == 371.3
+    assert derived["batCharge"] == 2.3
+    assert derived["batDisCharge"] == 4.4
+
+
+def test_is_valid_metric_edge_cases():
+    """Test all edge cases for _is_valid_metric helper via _compute_battery_metrics."""
+    invalid_values = [
+        None,
+        "",
+        "   ",
+        "null",
+        "NULL",
+        " none ",
+        "na",
+        " NA ",
+        "--",
+    ]
+
+    for val in invalid_values:
+        derived: dict[str, float] = {}
+        m_raw = {"totalEchg": val}
+        _compute_battery_metrics(m_raw, derived, "OTHER")
+        assert "totalEchg" not in derived
+        assert "bat_charge_total" not in derived
+
+    valid_values = [
+        0,
+        1.5,
+        "1.5",
+        " 2.5 ",
+        "0",
+    ]
+
+    for val in valid_values:
+        derived: dict[str, float] = {}
+        m_raw = {"totalEchg": val}
+        _compute_battery_metrics(m_raw, derived, "OTHER")
+        assert "totalEchg" in derived
+        assert "bat_charge_total" in derived
+        assert derived["totalEchg"] == float(val)

hyxi_cloud_api-1.3.9/tests/test_compute_pv_metrics.py

@@ -0,0 +1,50 @@
+"""Tests for the _compute_pv_metrics helper function in api.py."""
+
+from src.hyxi_cloud_api.api import _compute_pv_metrics
+
+
+class TestComputePvMetrics:
+    """Tests for _compute_pv_metrics."""
+
+    def test_compute_pv_metrics_with_direct_power(self):
+        """Test PV power uses direct power when provided."""
+        m_raw = {"pv1v": 100.0, "pv1i": 5.0, "pv1p": 600.0}
+        derived: dict[str, float] = {}
+        _compute_pv_metrics(m_raw, derived)
+        assert derived["pv1p"] == 600.0
+
+    def test_compute_pv_metrics_with_voltage_current(self):
+        """Test PV power calculates voltage * current when direct power is missing."""
+        m_raw = {"pv1v": 100.0, "pv1i": 5.5}
+        derived: dict[str, float] = {}
+        _compute_pv_metrics(m_raw, derived)
+        assert derived["pv1p"] == 550.0
+
+    def test_compute_pv_metrics_empty_dict(self):
+        """Test empty input results in empty derived metrics."""
+        m_raw = {}
+        derived: dict[str, float] = {}
+        _compute_pv_metrics(m_raw, derived)
+        assert not derived
+
+    def test_compute_pv_metrics_pv1_fallback_normal(self):
+        """Test pv1p fallback is calculated correctly from ppv and pv2p."""
+        m_raw = {"ppv": 1000.0}
+        derived: dict[str, float] = {"pv2p": 400.0}
+        _compute_pv_metrics(m_raw, derived)
+        assert derived["pv1p"] == 600.0
+        assert derived["pv2p"] == 400.0
+
+    def test_compute_pv_metrics_pv1_fallback_negative(self):
+        """Test pv1p fallback bounds negative results to 0.0."""
+        m_raw = {"ppv": 300.0}
+        derived: dict[str, float] = {"pv2p": 400.0}
+        _compute_pv_metrics(m_raw, derived)
+        assert derived["pv1p"] == 0.0
+
+    def test_compute_pv_metrics_zero_direct_power_with_vi(self):
+        """Test PV power falls back to calculated value if direct power is exactly 0.0."""
+        m_raw = {"pv1v": 100.0, "pv1i": 5.0, "pv1p": 0.0}
+        derived: dict[str, float] = {}
+        _compute_pv_metrics(m_raw, derived)
+        assert derived["pv1p"] == 500.0

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_device_control.py

@@ -245,6 +245,30 @@ async def test_set_micro_power_limit_mocked_control():
     assert result == {"success": True}
 
 
+@pytest.mark.asyncio
+async def test_restart_device_mocked_control():
+    """Test restart_device by mocking set_device_control and checking edge cases."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api.set_device_control = AsyncMock(return_value={"success": True})
+
+    result = await api.restart_device(device_sn="SN123")
+
+    assert result == {"success": True}
+    api.set_device_control.assert_called_once()
+
+    call_args, call_kwargs = api.set_device_control.call_args
+    if "param_code" in call_kwargs:
+        assert call_kwargs["device_sn"] == "SN123"
+        assert call_kwargs["param_code"] == "rebootSet"
+        assert call_kwargs["value"] == 1
+    elif len(call_args) > 1 and call_args[1] == "rebootSet":
+        assert call_args[0] == "SN123"
+        assert call_args[1] == "rebootSet"
+        assert call_args[2] == 1
+    else:
+        api.set_device_control.assert_awaited_once_with("SN123", {3013: "1"})
+
+
 @pytest.mark.asyncio
 async def test_restart_device():
     """Test restart_device sends controlId 3013 with value '1'."""

hyxi_cloud_api-1.3.9/tests/test_ensure_authenticated.py

@@ -0,0 +1,46 @@
+"""Tests for _ensure_authenticated."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from hyxi_cloud_api.api import HyxiApiClient
+
+
+class DummyError(Exception):
+    """A dummy exception class for testing."""
+
+
+@pytest.fixture
+def api_client():
+    """Fixture for HyxiApiClient."""
+    session = MagicMock()
+    return HyxiApiClient("access_key", "secret_key", "https://api.example.com", session)
+
+
+@pytest.mark.asyncio
+async def test_ensure_authenticated_success(api_client):
+    """Test _ensure_authenticated succeeds without raising when token refresh is successful."""
+    api_client._refresh_token = AsyncMock(return_value=True)
+    await api_client._ensure_authenticated(DummyError)
+    api_client._refresh_token.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_ensure_authenticated_auth_failed(api_client):
+    """Test _ensure_authenticated raises error_cls with specific message on auth_failed."""
+    api_client._refresh_token = AsyncMock(return_value="auth_failed")
+    with pytest.raises(DummyError, match="Authentication failed"):
+        await api_client._ensure_authenticated(DummyError)
+
+
+@pytest.mark.asyncio
+async def test_ensure_authenticated_no_token(api_client):
+    """Test _ensure_authenticated raises error_cls when token cannot be obtained."""
+    api_client._refresh_token = AsyncMock(return_value=False)
+    with pytest.raises(DummyError, match="Could not obtain API token"):
+        await api_client._ensure_authenticated(DummyError)
+
+    api_client._refresh_token = AsyncMock(return_value=None)
+    with pytest.raises(DummyError, match="Could not obtain API token"):
+        await api_client._ensure_authenticated(DummyError)

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_fetch_device_list_for_plant.py

@@ -86,7 +86,6 @@ async def test_fetch_device_list_for_plant_debug_logging(caplog):
     await api._fetch_device_list_for_plant("plant123")
     assert "HYXI Discovered Devices for Plant" in caplog.text
     # SN12345678 -> 10 chars. _mask_id should show last 4. 10-4 = 6 X's.
-    assert "5d82af15" in caplog.text
 
 
 @pytest.mark.asyncio

hyxi_cloud_api-1.3.9/tests/test_filter_metrics.py

@@ -0,0 +1,133 @@
+import sys
+from unittest.mock import MagicMock
+
+if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientError"):
+    m = MagicMock()
+
+    class MockExp(Exception):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args)
+            for k, v in kwargs.items():
+                setattr(self, k, v)
+
+    m.ClientError = MockExp
+    m.ClientResponseError = type("ClientResponseError", (MockExp,), {})
+    m.ContentTypeError = type("ContentTypeError", (MockExp,), {})
+    sys.modules["aiohttp"] = m
+mock_aiohttp = sys.modules["aiohttp"]
+
+"""Tests for _filter_collector_metrics optimization."""
+
+from src.hyxi_cloud_api.api import (
+    _filter_collector_metrics,
+    _is_collector_key_allowed,
+)
+
+
+def test_filter_collector_metrics_filtering():
+    """Verify that sensitive metrics are filtered out."""
+    m_raw = {
+        "totalE": "2731.9",
+        "pbat": "-500",
+        "gridP": "1.5",
+        "ph1Loadp": "0.5",
+        "ph2Loadp": "0.5",
+        "ph3Loadp": "0.5",
+        "temp": "40.5",
+        "vpv1": "400",
+        "vbat": "52",
+        "soc": "100",
+    }
+
+    filtered = _filter_collector_metrics(m_raw)
+
+    # These should be filtered out
+    assert "pbat" not in filtered
+    assert "gridP" not in filtered
+    assert "ph1Loadp" not in filtered
+    assert "ph2Loadp" not in filtered
+    assert "ph3Loadp" not in filtered
+    assert "vpv1" not in filtered
+    assert "vbat" not in filtered
+
+    # These should remain
+    assert "totalE" in filtered
+    assert "temp" in filtered
+    assert "soc" in filtered
+    assert filtered["totalE"] == "2731.9"
+    assert filtered["temp"] == "40.5"
+    assert filtered["soc"] == "100"
+
+
+def test_filter_collector_metrics_empty():
+    """Verify empty dict handling."""
+    assert not _filter_collector_metrics({})
+
+
+def test_filter_collector_metrics_no_match():
+    """Verify dict with no matches handling."""
+    m_raw = {"abc": "123", "def": "456"}
+    assert _filter_collector_metrics(m_raw) == m_raw
+
+
+def test_filter_collector_metrics_case_insensitivity():
+    """Verify case insensitivity of filtering."""
+    m_raw = {"BATTERY_TEMP": "25", "PV_VOLTAGE": "200"}
+    filtered = _filter_collector_metrics(m_raw)
+    assert "BATTERY_TEMP" not in filtered
+    assert "PV_VOLTAGE" not in filtered
+
+
+def test_is_collector_key_allowed_true():
+    """Verify that safe keys are allowed."""
+    assert _is_collector_key_allowed("totalE") is True
+    assert _is_collector_key_allowed("temp") is True
+    assert _is_collector_key_allowed("soc") is True
+    assert _is_collector_key_allowed("voltage") is True
+    assert _is_collector_key_allowed("current") is True
+    assert _is_collector_key_allowed("randomKey") is True
+
+
+def test_is_collector_key_allowed_false():
+    """Verify that sensitive keys are not allowed."""
+    assert _is_collector_key_allowed("pbat") is False
+    assert _is_collector_key_allowed("gridP") is False
+    assert _is_collector_key_allowed("ph1Loadp") is False
+    assert _is_collector_key_allowed("ph2Loadp") is False
+    assert _is_collector_key_allowed("ph3Loadp") is False
+    assert _is_collector_key_allowed("vpv1") is False
+    assert _is_collector_key_allowed("vbat") is False
+
+
+def test_is_collector_key_allowed_case_insensitivity():
+    """Verify case insensitivity."""
+    assert _is_collector_key_allowed("BAT_VOLTAGE") is False
+    assert _is_collector_key_allowed("PV_VOLTAGE") is False
+    assert _is_collector_key_allowed("GRID_POWER") is False
+    assert _is_collector_key_allowed("LOAD_POWER") is False
+    assert _is_collector_key_allowed("PH1_LOAD") is False
+    assert _is_collector_key_allowed("PH2_LOAD") is False
+    assert _is_collector_key_allowed("PH3_LOAD") is False
+    assert _is_collector_key_allowed("BaT") is False
+    assert _is_collector_key_allowed("pBAt") is False
+
+
+def test_is_collector_key_allowed_cache():
+    """Verify that the lru_cache works and caches results."""
+    # Clear cache to ensure clean state
+    _is_collector_key_allowed.cache_clear()
+
+    # First call - should be a miss
+    res1 = _is_collector_key_allowed("totalE")
+
+    # Second call - should be a hit
+    res2 = _is_collector_key_allowed("totalE")
+
+    # Check cache info
+    cache_info = _is_collector_key_allowed.cache_info()
+
+    assert res1 is True
+    assert res2 is True
+    assert cache_info.hits == 1
+    assert cache_info.misses == 1
+    assert cache_info.currsize == 1

hyxi_cloud_api-1.3.9/tests/test_flatten_nested_push_device.py

@@ -0,0 +1,59 @@
+"""Tests for _flatten_nested_push_device error handling."""
+
+from hyxi_cloud_api.api import _flatten_nested_push_device
+
+
+def test_flatten_nested_push_device_record_collecttime_valueerror():
+    """Test ValueError is handled when collectTime in record is an invalid string."""
+    device = {"record": {"collectTime": "invalid_time"}}
+    flat = _flatten_nested_push_device(device)
+    assert flat["collectTime"] == "invalid_time"
+
+
+def test_flatten_nested_push_device_record_collecttime_typeerror():
+    """Test TypeError is handled when collectTime in record is of an invalid type."""
+    device = {"record": {"collectTime": {"nested": "dict"}}}
+    flat = _flatten_nested_push_device(device)
+    assert flat["collectTime"] == {"nested": "dict"}
+
+
+def test_flatten_nested_push_device_root_collecttime_valueerror():
+    """Test ValueError is handled when collectTime in root is an invalid string."""
+    device = {"collectTime": "invalid_time"}
+    flat = _flatten_nested_push_device(device)
+    assert flat["collectTime"] == "invalid_time"
+
+
+def test_flatten_nested_push_device_root_collecttime_typeerror():
+    """Test TypeError is handled when collectTime in root is of an invalid type."""
+    device = {"collectTime": ["invalid", "type"]}
+    flat = _flatten_nested_push_device(device)
+    assert flat["collectTime"] == ["invalid", "type"]
+
+
+def test_flatten_nested_push_device_root_collecttime_valid_large():
+    """Test large valid collectTime in root."""
+    device = {"collectTime": 20000000000}
+    flat = _flatten_nested_push_device(device)
+    assert flat["collectTime"] == 20000000.0
+
+
+def test_flatten_nested_push_device_root_collecttime_valid_small():
+    """Test small valid collectTime in root."""
+    device = {"collectTime": 5000000000}
+    flat = _flatten_nested_push_device(device)
+    assert flat["collectTime"] == 5000000000
+
+
+def test_flatten_nested_push_device_root_reporttimestamp():
+    """Test reportTimestamp in root."""
+    device = {"reportTimestamp": 1234567890}
+    flat = _flatten_nested_push_device(device)
+    assert flat["reportTimestamp"] == 1234567890
+
+
+def test_flatten_nested_push_device_system_workmode():
+    """Test workMode in system."""
+    device = {"system": {"workMode": "test_mode"}}
+    flat = _flatten_nested_push_device(device)
+    assert flat["workMode"] == "test_mode"

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_info_errors.py

@@ -41,7 +41,8 @@ async def test_fetch_device_info_network_error(caplog):
     # Use a longer SN so it's not fully masked to ****
     await api._fetch_device_info("10602251600016", entry)
 
-    assert "Error fetching device info for fefbfd75: Connection reset" in caplog.text
+    assert "Error fetching device info for " in caplog.text
+    assert "Connection reset" in caplog.text
     # Ensure it didn't crash and entry was not updated with metrics
     assert "sw_version" not in entry
 
@@ -70,7 +71,7 @@ async def test_fetch_device_info_invalid_json(caplog):
     entry = {"metrics": {}, "device_type_code": "INVERTER"}
     await api._fetch_device_info("10602251600016", entry)
 
-    assert "Error fetching device info for fefbfd75" in caplog.text
+    assert "Error fetching device info for " in caplog.text
     assert "sw_version" not in entry
 
 
@@ -97,7 +98,7 @@ async def test_fetch_device_info_api_error(caplog):
     entry = {"metrics": {}, "device_type_code": "INVERTER"}
     await api._fetch_device_info("10602251600016", entry)
 
-    assert "HYXI INFO API Rejected for fefbfd75" in caplog.text
+    assert "HYXI INFO API Rejected for " in caplog.text
     assert "success" in caplog.text  # _sanitize_dict logs full response dict
     assert "sw_version" not in entry
 
@@ -117,10 +118,8 @@ async def test_fetch_device_info_client_error_handling(caplog):
     await api._fetch_device_info("10602251600016", entry)
 
     # Verify that the exception is caught and logged
-    assert (
-        "Error fetching device info for fefbfd75: Simulated fallback error"
-        in caplog.text
-    )
+    assert "Error fetching device info for" in caplog.text
+    assert "Simulated fallback error" in caplog.text
     # Ensure it didn't crash and entry was not updated with metrics
     assert "sw_version" not in entry
 

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_mask_id.py

@@ -1,8 +1,9 @@
 """Tests for the _mask_id and _sanitize_dict log sanitisation helpers in api.py."""
 
 import hashlib
+import hmac
 
-from hyxi_cloud_api.api import _mask_id, _sanitize_dict
+from hyxi_cloud_api.api import _LOG_SALT, _mask_id, _sanitize_dict
 
 
 class TestMaskId:
@@ -13,7 +14,10 @@ class TestMaskId:
     def test_normal_sn_is_masked_with_hash(self):
         """A typical device SN should be masked using a hash, yielding an 8-char string."""
         sn = "HYXABC12345678"
-        expected = hashlib.sha256(sn.encode("utf-8")).hexdigest()[:8]
+
+        expected = hmac.new(_LOG_SALT, sn.encode("utf-8"), hashlib.sha256).hexdigest()[
+            :8
+        ]
         result = _mask_id(sn)
         assert result == expected
         assert len(result) == 8

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_metrics_errors.py

@@ -41,7 +41,8 @@ async def test_fetch_device_metrics_request_error(caplog):
     # Use a longer SN so it's not fully masked to ****
     await api._fetch_device_metrics("10602251600016", entry)
 
-    assert "Error fetching metrics for fefbfd75: Mock client error" in caplog.text
+    assert "Error fetching metrics for " in caplog.text
+    assert "Mock client error" in caplog.text
     # Ensure it didn't crash and entry was not updated with metrics
     assert not entry["metrics"]
 
@@ -60,7 +61,8 @@ async def test_fetch_device_metrics_network_error(caplog):
     # Use a longer SN so it's not fully masked to ****
     await api._fetch_device_metrics("10602251600016", entry)
 
-    assert "Error fetching metrics for fefbfd75: Connection reset" in caplog.text
+    assert "Error fetching metrics for " in caplog.text
+    assert "Connection reset" in caplog.text
     # Ensure it didn't crash and entry was not updated with metrics
     assert not entry["metrics"]
 
@@ -90,7 +92,7 @@ async def test_fetch_device_metrics_invalid_json(caplog):
     entry = {"metrics": {}, "device_type_code": "INVERTER"}
     await api._fetch_device_metrics("10602251600016", entry)
 
-    assert "Error fetching metrics for fefbfd75" in caplog.text
+    assert "Error fetching metrics for " in caplog.text
     assert not entry["metrics"]
 
 
@@ -118,7 +120,7 @@ async def test_fetch_device_metrics_api_error(caplog):
     entry = {"metrics": {}, "device_type_code": "INVERTER"}
     await api._fetch_device_metrics("10602251600016", entry)
 
-    assert "HYXI API metrics rejected for fefbfd75" in caplog.text
+    assert "HYXI API metrics rejected for " in caplog.text
     assert "success" in caplog.text  # _sanitize_dict logs full response dict
     assert not entry["metrics"]
 
@@ -138,7 +140,7 @@ async def test_fetch_ems_basic_data_no_data(caplog):
     entry = {"metrics": {}, "device_type_code": "EMS"}
     await api._fetch_all_for_device("10602251600016", entry, "INVERTER")
 
-    assert "HYXI EMS telemetry probe returned no data for fefbfd75" in caplog.text
+    assert "HYXI EMS telemetry probe returned no data for " in caplog.text
     # No EMS data should be merged into metrics.
     assert "new_metric" not in entry["metrics"]
 
@@ -160,7 +162,7 @@ async def test_fetch_ems_basic_data_error(caplog):
 
     # No EMS data should be merged into metrics.
     assert "batSoc" not in entry["metrics"]
-    assert "HYXI EMS telemetry probe returned no data for fefbfd75" in caplog.text
+    assert "HYXI EMS telemetry probe returned no data for " in caplog.text
 
 
 @pytest.mark.asyncio
@@ -177,10 +179,8 @@ async def test_query_ems_basic_details_error(caplog):
 
     assert result == {}
 
-    assert (
-        "HYXI EMS Basic Data Request Failed for fefbfd75: EMS query failed"
-        in caplog.text
-    )
+    assert "HYXI EMS Basic Data Request Failed for" in caplog.text
+    assert "EMS query failed" in caplog.text
 
 
 @pytest.mark.asyncio
@@ -197,10 +197,8 @@ async def test_query_ems_basic_details_network_error(caplog):
 
     assert result == {}
 
-    assert (
-        "HYXI EMS Basic Data Request Failed for fefbfd75: Connection reset"
-        in caplog.text
-    )
+    assert "HYXI EMS Basic Data Request Failed for" in caplog.text
+    assert "Connection reset" in caplog.text
 
 
 @pytest.mark.asyncio
@@ -221,7 +219,7 @@ async def test_query_ems_basic_details_non_zero_code(caplog):
     result = await api.query_ems_basic_details("10602251600016")
 
     assert result == {}
-    assert "HYXI EMS Basic Data Request Rejected for fefbfd75" in caplog.text
+    assert "HYXI EMS Basic Data Request Rejected for " in caplog.text
 
 
 @pytest.mark.asyncio
@@ -237,5 +235,5 @@ async def test_query_ems_basic_details_malformed_response(caplog):
     result = await api.query_ems_basic_details("10602251600016")
 
     assert result == {}
-    assert "HYXI EMS Basic Data Request Failed for fefbfd75" in caplog.text
+    assert "HYXI EMS Basic Data Request Failed for " in caplog.text
     assert "object has no attribute 'get'" in caplog.text

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_push.py

@@ -305,3 +305,68 @@ def test_process_push_data_flat_ms_collect_time():
     assert metrics["pv1v"] == 119.0
     assert metrics["pv1i"] == 1.2
     assert metrics["pv1p"] == 142.8
+
+
+def test_process_push_data_invalid_time_formats():
+    """Test process_push_data correctly handles ValueError and TypeError when parsing timestamps."""
+
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api._discovery_cache["device_info"] = {
+        "TEST_DEV": {
+            "model": "TEST",
+            "device_type_code": "TEST_TYPE",
+            "device_name": "Test Device",
+        }
+    }
+
+    # Test invalid collectTime (ValueError)
+    payload_invalid_collect_time = {
+        "dataList": [
+            {
+                "deviceSn": "TEST_DEV",
+                "collectTime": "invalid-time",
+            }
+        ]
+    }
+
+    # Test invalid collectTime (TypeError)
+    payload_type_err_collect_time = {
+        "dataList": [
+            {
+                "deviceSn": "TEST_DEV",
+                "collectTime": {"a": "b"},
+            }
+        ]
+    }
+
+    # Test invalid reportTimestamp (ValueError)
+    payload_invalid_report_ts = {
+        "dataList": [
+            {
+                "deviceSn": "TEST_DEV",
+                "reportTimestamp": "invalid-time",
+            }
+        ]
+    }
+
+    # Test invalid reportTimestamp (TypeError)
+    payload_type_err_report_ts = {
+        "dataList": [
+            {
+                "deviceSn": "TEST_DEV",
+                "reportTimestamp": {"a": "b"},
+            }
+        ]
+    }
+
+    res1 = api.process_push_data(payload_invalid_collect_time)
+    res2 = api.process_push_data(payload_type_err_collect_time)
+    res3 = api.process_push_data(payload_invalid_report_ts)
+    res4 = api.process_push_data(payload_type_err_report_ts)
+
+    # Check that last_seen was not updated to a specific time, but fell back to now_utc
+    # In api.process_push_data, if it fails, last_seen = now_utc
+    assert "last_seen" in res1["TEST_DEV"]["metrics"]
+    assert "last_seen" in res2["TEST_DEV"]["metrics"]
+    assert "last_seen" in res3["TEST_DEV"]["metrics"]
+    assert "last_seen" in res4["TEST_DEV"]["metrics"]

{hyxi_cloud_api-1.3.7 → hyxi_cloud_api-1.3.9}/tests/test_security_fix.py

@@ -5,7 +5,7 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from src.hyxi_cloud_api.api import HyxiApiClient, _sanitize_dict
+from src.hyxi_cloud_api.api import HyxiApiClient, _mask_id, _sanitize_dict
 
 # Mock aiohttp before importing the API client
 if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientError"):
@@ -44,20 +44,20 @@ def test_sanitize_dict_recursive():
     sanitized = _sanitize_dict(raw)
 
     assert sanitized["plantAddress"] == "[REDACTED]"
-    assert sanitized["deviceSn"] == "c90391cf"
+    assert sanitized["deviceSn"] == _mask_id("SN123456789")
     assert sanitized["normalKey"] == "normalValue"
 
     # Check nested list of dicts
-    assert sanitized["data"][0]["deviceSn"] == "795d881c"
-    assert sanitized["data"][0]["nested"]["plantId"] == "bd83cb6a"
+    assert sanitized["data"][0]["deviceSn"] == _mask_id("SN987654321")
+    assert sanitized["data"][0]["nested"]["plantId"] == _mask_id("PID123")
     assert sanitized["data"][0]["nested"]["normal"] == "value"
     assert sanitized["data"][1] == "not a dict"
 
     # Check nested dict
-    assert sanitized["nestedDict"]["batSn"] == "8015218b"
+    assert sanitized["nestedDict"]["batSn"] == _mask_id("BAT12345")
 
     # Check nested list
-    assert sanitized["nestedList"][0][0]["deviceSn"] == "083c86de"
+    assert sanitized["nestedList"][0][0]["deviceSn"] == _mask_id("SN0000")
 
 
 @pytest.mark.asyncio

hyxi_cloud_api-1.3.7/tests/test_filter_metrics.py

@@ -1,75 +0,0 @@
-import sys
-from unittest.mock import MagicMock
-
-if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientError"):
-    m = MagicMock()
-
-    class MockExp(Exception):
-        def __init__(self, *args, **kwargs):
-            super().__init__(*args)
-            for k, v in kwargs.items():
-                setattr(self, k, v)
-
-    m.ClientError = MockExp
-    m.ClientResponseError = type("ClientResponseError", (MockExp,), {})
-    m.ContentTypeError = type("ContentTypeError", (MockExp,), {})
-    sys.modules["aiohttp"] = m
-mock_aiohttp = sys.modules["aiohttp"]
-
-"""Tests for _filter_collector_metrics optimization."""
-
-from src.hyxi_cloud_api.api import _filter_collector_metrics
-
-
-def test_filter_collector_metrics_filtering():
-    """Verify that sensitive metrics are filtered out."""
-    m_raw = {
-        "totalE": "2731.9",
-        "pbat": "-500",
-        "gridP": "1.5",
-        "ph1Loadp": "0.5",
-        "ph2Loadp": "0.5",
-        "ph3Loadp": "0.5",
-        "temp": "40.5",
-        "vpv1": "400",
-        "vbat": "52",
-        "soc": "100",
-    }
-
-    filtered = _filter_collector_metrics(m_raw)
-
-    # These should be filtered out
-    assert "pbat" not in filtered
-    assert "gridP" not in filtered
-    assert "ph1Loadp" not in filtered
-    assert "ph2Loadp" not in filtered
-    assert "ph3Loadp" not in filtered
-    assert "vpv1" not in filtered
-    assert "vbat" not in filtered
-
-    # These should remain
-    assert "totalE" in filtered
-    assert "temp" in filtered
-    assert "soc" in filtered
-    assert filtered["totalE"] == "2731.9"
-    assert filtered["temp"] == "40.5"
-    assert filtered["soc"] == "100"
-
-
-def test_filter_collector_metrics_empty():
-    """Verify empty dict handling."""
-    assert not _filter_collector_metrics({})
-
-
-def test_filter_collector_metrics_no_match():
-    """Verify dict with no matches handling."""
-    m_raw = {"abc": "123", "def": "456"}
-    assert _filter_collector_metrics(m_raw) == m_raw
-
-
-def test_filter_collector_metrics_case_insensitivity():
-    """Verify case insensitivity of filtering."""
-    m_raw = {"BATTERY_TEMP": "25", "PV_VOLTAGE": "200"}
-    filtered = _filter_collector_metrics(m_raw)
-    assert "BATTERY_TEMP" not in filtered
-    assert "PV_VOLTAGE" not in filtered