violet-poolController-api 0.0.34__tar.gz → 0.0.36__tar.gz

{violet_poolcontroller_api-0.0.34/violet_poolController_api.egg-info → violet_poolcontroller_api-0.0.36}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.34
+Version: 0.0.36
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Author-email: "Basti (Xerolux)" <git@xerolux.de>
-License: AGPL-3.0-or-later
-Project-URL: Homepage, https://github.com/Xerolux/violet-hass
-Project-URL: Bug Tracker, https://github.com/Xerolux/violet-hass/issues
+License-Expression: AGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/Xerolux/violet-poolController-api
+Project-URL: Bug Tracker, https://github.com/Xerolux/violet-poolController-api/issues
 Project-URL: License, https://www.gnu.org/licenses/agpl-3.0.html
-Project-URL: Changelog, https://github.com/Xerolux/violet-hass/blob/main/violet_poolcontroller_api/CHANGELOG.md
+Project-URL: Changelog, https://github.com/Xerolux/violet-poolController-api/blob/main/CHANGELOG.md
 Keywords: pool,violet,controller,home-assistant,async
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
@@ -22,7 +22,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp<3.15,>=3.11.0
 Provides-Extra: test
-Requires-Dist: aioresponses>=0.7.8; extra == "test"
+Requires-Dist: aioresponses>=0.7.9; extra == "test"
+Requires-Dist: mypy>=1.15; extra == "test"
 Requires-Dist: pytest>=8.3; extra == "test"
 Requires-Dist: pytest-asyncio>=0.24; extra == "test"
 Dynamic: license-file

{violet_poolcontroller_api-0.0.34 → violet_poolcontroller_api-0.0.36}/pyproject.toml

@@ -1,23 +1,18 @@
 [build-system]
-requires = ["setuptools>=61.0.0", "wheel"]
+requires = ["setuptools>=77.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
-[tool.setuptools.packages.find]
-include = ["violet_poolcontroller_api*"]
-
-[tool.setuptools.package-data]
-violet_poolcontroller_api = ["py.typed"]
-
 [project]
 name = "violet-poolController-api"
-version = "0.0.34"
+version = "0.0.36"
 authors = [
   { name="Basti (Xerolux)", email="git@xerolux.de" },
 ]
 description = "Asynchronous Python client for the Violet Pool Controller."
 readme = "README.md"
 requires-python = ">=3.12"
-license = { text = "AGPL-3.0-or-later" }
+license = "AGPL-3.0-or-later"
+license-files = ["LICENSE"]
 keywords = ["pool", "violet", "controller", "home-assistant", "async"]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -35,20 +30,27 @@ dependencies = [
 
 [project.optional-dependencies]
 test = [
-    "aioresponses>=0.7.8",
+    "aioresponses>=0.7.9",
+    "mypy>=1.15",
     "pytest>=8.3",
     "pytest-asyncio>=0.24",
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/Xerolux/violet-hass"
-"Bug Tracker" = "https://github.com/Xerolux/violet-hass/issues"
+"Homepage" = "https://github.com/Xerolux/violet-poolController-api"
+"Bug Tracker" = "https://github.com/Xerolux/violet-poolController-api/issues"
 "License" = "https://www.gnu.org/licenses/agpl-3.0.html"
-"Changelog" = "https://github.com/Xerolux/violet-hass/blob/main/violet_poolcontroller_api/CHANGELOG.md"
+"Changelog" = "https://github.com/Xerolux/violet-poolController-api/blob/main/CHANGELOG.md"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
+[tool.setuptools.packages.find]
+include = ["violet_poolcontroller_api*"]
+
+[tool.setuptools.package-data]
+violet_poolcontroller_api = ["py.typed"]
+
 [tool.ruff]
 line-length = 100
 target-version = "py312"
@@ -61,3 +63,5 @@ ignore = ["E501"]
 python_version = "3.12"
 warn_return_any = true
 warn_unused_configs = true
+check_untyped_defs = true
+disallow_untyped_defs = true

{violet_poolcontroller_api-0.0.34 → violet_poolcontroller_api-0.0.36}/tests/test_api.py

@@ -1,4 +1,4 @@
-# violet-poolController-api - API f├╝r Violet Pool Controller
+# violet-poolController-api - API für Violet Pool Controller
 # Copyright (C) 2024-2026  Xerolux
 #
 # This program is free software: you can redistribute it and/or modify
@@ -96,6 +96,47 @@ async def test_get_readings_success(
     assert dict(result) == mock_data
 
 
+@pytest.mark.asyncio
+async def test_get_output_runtimes_success(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test get_output_runtimes parses a JSON dict response.
+
+    Regression: previously the endpoint was requested without expect_json,
+    so the raw text body was returned and the method logged a warning
+    ("Unexpected non-dict response for get_output_runtimes: str") and
+    returned an empty dict.
+    """
+    url = "http://192.168.1.100/getOutputruntimes"
+    mock_data = {
+        "PUMP_RUNTIME": "04h 33m 12s",
+        "PUMP_LAST_ON": 1700000000,
+        "PUMP_LAST_OFF": 1699996800,
+        "CPU_UPTIME": "12d 4h 30m",
+        "LOAD_AVG": "0.42",
+    }
+    mock_aioresponse.get(url, payload=mock_data, status=200)
+
+    result = await api_client.get_output_runtimes()
+
+    assert isinstance(result, dict)
+    assert result == mock_data
+
+
+@pytest.mark.asyncio
+async def test_get_output_runtimes_non_dict_raises(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test get_output_runtimes raises when the controller returns a non-dict."""
+    url = "http://192.168.1.100/getOutputruntimes"
+    mock_aioresponse.get(url, body="not-json", status=200)
+
+    with pytest.raises(VioletPoolAPIError):
+        await api_client.get_output_runtimes()
+
+
 @pytest.mark.asyncio
 async def test_set_pump_speed_success(
     mock_aioresponse: aioresponses,
@@ -486,7 +527,7 @@ async def test_ext1_readings_filtered_when_not_detected(mock_aioresponse, api_cl
         payload={
             "getReadings": {
                 "PUMPSTATE": "2",
-                # No SYSTEM_ext1module_alive_count  module not connected
+                # No SYSTEM_ext1module_alive_count → module not connected
                 "EXT1_1": 0,
                 "EXT1_2": 0,
             }
@@ -801,6 +842,32 @@ async def test_set_device_temperature_solar(
     assert result["success"] is True
 
 
+@pytest.mark.asyncio
+async def test_set_device_temperature_normalizes_key(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    url = "http://192.168.1.100/setConfig"
+    mock_aioresponse.post(url, body="OK", status=200)
+
+    await api_client.set_device_temperature(" heater ", 28.0)
+
+    request = mock_aioresponse.requests[("POST", URL(url))][0]
+    assert request.kwargs["data"] == {"HEATER_set_temp": 28.0}
+
+
+@pytest.mark.asyncio
+async def test_set_device_temperature_rejects_unknown_key(api_client: VioletPoolAPI) -> None:
+    with pytest.raises(VioletPoolAPIError, match="Expected HEATER or SOLAR"):
+        await api_client.set_device_temperature("DOSAGE", 28.0)
+
+
+@pytest.mark.asyncio
+async def test_set_device_temperature_cannot_bypass_range(api_client: VioletPoolAPI) -> None:
+    with pytest.raises(VioletPoolAPIError, match="outside the valid range"):
+        await api_client.set_device_temperature("heater", 1000.0)
+
+
 @pytest.mark.asyncio
 async def test_set_ph_target(
     mock_aioresponse: aioresponses,
@@ -871,6 +938,20 @@ async def test_set_dosing_parameters(
     assert result["success"] is True
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("raw_value", "expected"), [("1", True), ("1.0", True), ("0.0", False)])
+async def test_is_dosage_enabled_accepts_numeric_strings(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+    raw_value: str,
+    expected: bool,
+) -> None:
+    url = "http://192.168.1.100/getConfig?DOSAGE_phminus_use"
+    mock_aioresponse.get(url, payload={"DOSAGE_phminus_use": raw_value}, status=200)
+
+    assert await api_client.is_dosage_enabled("pH-") is expected
+
+
 @pytest.mark.asyncio
 async def test_reset_blocking(
     mock_aioresponse: aioresponses,
@@ -1515,6 +1596,40 @@ async def test_manual_dosing_unknown_type(api_client: VioletPoolAPI) -> None:
     assert "Unknown dosing type" in str(exc_info.value)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("duration", [0.5, 86401, float("nan"), float("inf")])
+async def test_dosing_start_rejects_unsafe_duration(
+    api_client: VioletPoolAPI,
+    duration: float,
+) -> None:
+    with pytest.raises(VioletPoolAPIError, match="Duration must be a whole number"):
+        await api_client.set_switch_state("DOS_1_CL", "ON", duration=duration)
+
+
+@pytest.mark.asyncio
+async def test_manual_dosing_post_is_not_retried(
+    mock_aioresponse: aioresponses,
+) -> None:
+    url = "http://192.168.1.100/triggerManualDosing"
+    mock_aioresponse.post(url, status=500, body="boom")
+    async with aiohttp.ClientSession() as session:
+        api = VioletPoolAPI(host="192.168.1.100", session=session, max_retries=3)
+        with pytest.raises(VioletPoolAPIError):
+            await api.manual_dosing("Chlor", 30)
+
+    assert len(mock_aioresponse.requests[("POST", URL(url))]) == 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("duration", [-1, 0.5, 86401, float("nan")])
+async def test_switch_state_rejects_invalid_duration(
+    api_client: VioletPoolAPI,
+    duration: float,
+) -> None:
+    with pytest.raises(VioletPoolAPIError, match="Duration must be a whole number"):
+        await api_client.set_switch_state("PUMP", "ON", duration=duration)
+
+
 @pytest.mark.asyncio
 async def test_manual_dosing_stop(
     mock_aioresponse: aioresponses,
@@ -1689,6 +1804,51 @@ async def test_client_error_does_not_trip_circuit_breaker(
     assert stats["state"].name == "CLOSED"
 
 
+@pytest.mark.asyncio
+async def test_empty_get_readings_payload_is_flattened(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    url = "http://192.168.1.100/getReadings?ALL"
+    mock_aioresponse.get(url, payload={"getReadings": {}}, status=200)
+
+    readings = await api_client.get_readings()
+
+    assert dict(readings) == {}
+
+
+@pytest.mark.asyncio
+async def test_empty_standalone_payload_updates_mode(api_client: VioletPoolAPI) -> None:
+    result = api_client._flatten_getreadings_response({"getReadings": []})  # noqa: SLF001
+
+    assert result == {}
+    assert api_client.dosing_standalone is True
+
+
+@pytest.mark.asyncio
+async def test_clients_use_independent_rate_limiters() -> None:
+    async with aiohttp.ClientSession() as session:
+        first = VioletPoolAPI(host="192.168.1.100", session=session)
+        second = VioletPoolAPI(host="192.168.1.101", session=session)
+
+    assert first._rate_limiter is not second._rate_limiter  # noqa: SLF001
+
+
+@pytest.mark.asyncio
+async def test_basic_auth_uses_authorization_header(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    url = "http://192.168.1.100/getReadings?ALL"
+    mock_aioresponse.get(url, payload={}, status=200)
+
+    await api_client.get_readings()
+
+    request = next(iter(mock_aioresponse.requests.values()))[0]
+    assert request.kwargs["headers"]["Authorization"].startswith("Basic ")
+    assert "auth" not in request.kwargs
+
+
 @pytest.mark.asyncio
 async def test_server_error_still_counts_for_circuit_breaker(
     mock_aioresponse: aioresponses,
@@ -1740,3 +1900,152 @@ def test_state_translation_language_switch() -> None:
 
     with pytest.raises(ValueError, match="Unsupported language"):
         set_state_translation_language("fr")
+
+
+@pytest.mark.asyncio
+async def test_set_config_preserves_int_values(
+    api_client: VioletPoolAPI,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Integer config values must be sent as integers, not coerced to float.
+
+    Regression for v0.0.36: ``InputSanitizer.sanitize_numeric`` returns a
+    float, so an integer flag like ``1`` became ``1.0`` on the wire. The
+    controller firmware expects integer flags (e.g. ``DOS_*_use``).
+    """
+    captured: dict[str, object] = {}
+
+    async def fake_request(endpoint: str, **kwargs: Any) -> str:  # noqa: ANN401
+        captured["data"] = kwargs.get("data")
+        return "OK"
+
+    monkeypatch.setattr(api_client, "_request", fake_request)
+
+    await api_client.set_config({"FLAG_enabled": 1, "FLAG_disabled": 0, "ph_set": 7.4})
+
+    data = captured["data"]
+    assert data == {"FLAG_enabled": 1, "FLAG_disabled": 0, "ph_set": 7.4}
+    assert isinstance(data["FLAG_enabled"], int)
+    assert isinstance(data["ph_set"], float)
+
+
+@pytest.mark.asyncio
+async def test_set_config_preserves_bool_as_int_flag(
+    api_client: VioletPoolAPI,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Booleans are sent as 0/1 integer flags (bool is an int subclass)."""
+    captured: dict[str, object] = {}
+
+    async def fake_request(endpoint: str, **kwargs: Any) -> str:  # noqa: ANN401
+        captured["data"] = kwargs.get("data")
+        return "OK"
+
+    monkeypatch.setattr(api_client, "_request", fake_request)
+
+    await api_client.set_config({"DOS_1_use": True, "DOS_2_use": False})
+
+    data = captured["data"]
+    assert data == {"DOS_1_use": 1, "DOS_2_use": 0}
+
+
+@pytest.mark.asyncio
+async def test_set_config_not_retried_on_server_error(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """set_config must not retry on 5xx — consistent with other POSTs.
+
+    A duplicated POST could re-apply a configuration change. POST methods
+    default to non-retryable; set_config previously opted into retries.
+    """
+    url = "http://192.168.1.100/setConfig"
+    mock_aioresponse.post(url, status=500, body="server error")
+
+    with pytest.raises(VioletPoolAPIError):
+        await api_client.set_config({"some_key": 1})
+
+    assert len(mock_aioresponse.requests[("POST", URL(url))]) == 1
+
+
+@pytest.mark.asyncio
+async def test_get_calibration_history_url_encodes_sensor(
+    api_client: VioletPoolAPI,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Sensor names with reserved characters must be percent-encoded.
+
+    Regression for v0.0.36: ``sensor`` was concatenated raw into the URL,
+    so a value containing ``&`` or space could inject extra query
+    parameters. The value passed to ``_request`` must be percent-encoded.
+    """
+    captured: dict[str, object] = {}
+
+    async def fake_request(endpoint: str, **kwargs: Any) -> str:  # noqa: ANN401
+        captured["query"] = kwargs.get("query")
+        return "2024-01-01 | 7.2 | pH_CALIB"
+
+    monkeypatch.setattr(api_client, "_request", fake_request)
+
+    await api_client.get_calibration_history("pH value & test")
+
+    assert captured["query"] == "pH%20value%20%26%20test"
+
+
+@pytest.mark.asyncio
+async def test_get_log_rejects_unknown_log_type(api_client: VioletPoolAPI) -> None:
+    """Unknown log_type values must be rejected before the request is sent."""
+    with pytest.raises(VioletPoolAPIError, match="Unsupported log_type"):
+        await api_client.get_log("drop_table")
+
+
+@pytest.mark.asyncio
+async def test_get_log_valid_log_type_reaches_request(
+    api_client: VioletPoolAPI,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Valid log_type is passed through to the request layer."""
+    captured: dict[str, object] = {}
+
+    async def fake_request(endpoint: str, **kwargs: Any) -> str:  # noqa: ANN401
+        captured["query"] = kwargs.get("query")
+        return "line one\nLOAD_MORE"
+
+    monkeypatch.setattr(api_client, "_request", fake_request)
+
+    result = await api_client.get_log("actions", page=0)
+
+    assert captured["query"] == "actions&0"
+    assert result["has_more"] is True
+    assert result["lines"] == ["line one"]
+
+
+@pytest.mark.asyncio
+async def test_restore_calibration_sanitizes_payload(
+    api_client: VioletPoolAPI,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """restore_calibration must sanitize sensor/timestamp before posting."""
+    captured: dict[str, object] = {}
+
+    async def fake_request(endpoint: str, **kwargs: Any) -> str:  # noqa: ANN401
+        captured["data"] = kwargs.get("data")
+        return "OK"
+
+    monkeypatch.setattr(api_client, "_request", fake_request)
+
+    await api_client.restore_calibration("pH", "2024-01-01 12:00")
+
+    assert captured["data"] == {"sensor": "pH", "timestamp": "2024-01-01 12:00"}
+
+
+def test_input_sanitizer_no_duplicate_validate_duration() -> None:
+    """InputSanitizer must not expose validate_duration/validate_speed.
+
+    These names collided with the raising validators in ``_api_model`` but
+    silently clamped instead. They were removed in v0.0.36.
+    """
+    from violet_poolcontroller_api.utils_sanitizer import InputSanitizer
+
+    assert not hasattr(InputSanitizer, "validate_duration")
+    assert not hasattr(InputSanitizer, "validate_speed")

{violet_poolcontroller_api-0.0.34 → violet_poolcontroller_api-0.0.36}/tests/test_api_smoke.py

@@ -27,14 +27,14 @@ from violet_poolcontroller_api.api import VioletPoolAPI, VioletPoolAPIError
 
 
 @dataclasses.dataclass
-class TestResult:
+class SmokeResult:
     name: str
     status: str  # "PASS" | "FAIL" | "SKIP"
     detail: str = ""
     duration_ms: float = 0.0
 
 
-_results: list[TestResult] = []
+_results: list[SmokeResult] = []
 
 
 async def _run(
@@ -53,7 +53,7 @@ async def _run(
             error_msg = check(result)
 
         if error_msg:
-            _results.append(TestResult(name, "FAIL", error_msg, elapsed))
+            _results.append(SmokeResult(name, "FAIL", error_msg, elapsed))
         else:
             detail = ""
             if isinstance(result, dict):
@@ -67,16 +67,16 @@ async def _run(
                 detail = f"{len(result)} entries"
             elif isinstance(result, bool):
                 detail = str(result)
-            _results.append(TestResult(name, "PASS", detail, elapsed))
+            _results.append(SmokeResult(name, "PASS", detail, elapsed))
         return result
     except VioletPoolAPIError as exc:
         elapsed = (time.monotonic() - start) * 1000
-        _results.append(TestResult(name, "FAIL", f"VioletPoolAPIError: {exc}", elapsed))
+        _results.append(SmokeResult(name, "FAIL", f"VioletPoolAPIError: {exc}", elapsed))
         return None
     except Exception as exc:
         elapsed = (time.monotonic() - start) * 1000
         tb = traceback.format_exc()
-        _results.append(TestResult(name, "FAIL", f"{type(exc).__name__}: {exc}\n{tb}", elapsed))
+        _results.append(SmokeResult(name, "FAIL", f"{type(exc).__name__}: {exc}\n{tb}", elapsed))
         return None
 
 
@@ -90,21 +90,17 @@ async def _expect_error(
     try:
         result = await coro
         elapsed = (time.monotonic() - start) * 1000
-        _results.append(TestResult(name, "FAIL", f"Expected error but got success: {result}", elapsed))
+        _results.append(SmokeResult(name, "FAIL", f"Expected error but got success: {result}", elapsed))
     except VioletPoolAPIError as exc:
         elapsed = (time.monotonic() - start) * 1000
         msg = str(exc)
         if error_contains and error_contains not in msg:
-            _results.append(TestResult(name, "FAIL", f"Error message mismatch: '{msg}' does not contain '{error_contains}'", elapsed))
+            _results.append(SmokeResult(name, "FAIL", f"Error message mismatch: '{msg}' does not contain '{error_contains}'", elapsed))
         else:
-            _results.append(TestResult(name, "PASS", f"Correctly raised: {msg}", elapsed))
+            _results.append(SmokeResult(name, "PASS", f"Correctly raised: {msg}", elapsed))
     except Exception as exc:
         elapsed = (time.monotonic() - start) * 1000
-        _results.append(TestResult(name, "FAIL", f"Unexpected {type(exc).__name__}: {exc}", elapsed))
-
-
-def _skip(name: str, reason: str) -> None:
-    _results.append(TestResult(name, "SKIP", reason))
+        _results.append(SmokeResult(name, "FAIL", f"Unexpected {type(exc).__name__}: {exc}", elapsed))
 
 
 async def run_all_tests(api: VioletPoolAPI) -> None:
@@ -184,6 +180,18 @@ async def run_all_tests(api: VioletPoolAPI) -> None:
         check=lambda r: "empty" if not r else None,
     )
 
+    await _run(
+        "get_log(actions)",
+        api.get_log("actions"),
+        check=lambda r: "missing lines" if "lines" not in r else None,
+    )
+
+    await _run(
+        "get_notifications",
+        api.get_notifications(),
+        check=lambda r: "unexpected payload" if not isinstance(r, dict) else None,
+    )
+
     # ── POST endpoints (config / commands) ──────────────────────────────
     print("[Config & Commands]")
 
@@ -229,6 +237,12 @@ async def run_all_tests(api: VioletPoolAPI) -> None:
         check=lambda r: "not success" if not r.get("success") else None,
     )
 
+    await _run(
+        "is_dosage_enabled(pH-)",
+        api.is_dosage_enabled("pH-"),
+        check=lambda r: "expected enabled" if not r else None,
+    )
+
     await _run(
         "set_device_temperature(HEATER, 28.0)",
         api.set_device_temperature("HEATER", 28.0),
@@ -365,6 +379,21 @@ async def run_all_tests(api: VioletPoolAPI) -> None:
         check=lambda r: "not success" if not r.get("success") else None,
     )
 
+    # ── OmniTronic multi-port valve ─────────────────────────────────────
+    print("[OmniTronic]")
+
+    await _run(
+        "set_omni_position(2)",
+        api.set_omni_position(2),
+        check=lambda r: "missing OMNITRONIC ack" if "OMNITRONIC" not in r.get("response", "") else None,
+    )
+
+    await _run(
+        "set_omni_position(0) - filtration",
+        api.set_omni_position(0),
+        check=lambda r: "not success" if not r.get("success") else None,
+    )
+
     # ── PV Surplus ──────────────────────────────────────────────────────
     print("[PV Surplus]")
 
@@ -491,14 +520,6 @@ async def run_all_tests(api: VioletPoolAPI) -> None:
         error_contains="Unknown dosing type",
     )
 
-    # ── Skipped methods (use _api_request, not available in source) ─────
-    print("[Skipped - requires _api_request]")
-
-    _skip("get_log(actions)", "uses _api_request (not in source, only in installed package)")
-    _skip("get_notifications", "uses _api_request (not in source, only in installed package)")
-    _skip("is_dosage_enabled(pH-)", "uses _request_json_dict without payload_name param mismatch")
-
-
 async def _run_prop(api: VioletPoolAPI, prop: str) -> Any:
     return getattr(api, prop)
 

{violet_poolcontroller_api-0.0.34 → violet_poolcontroller_api-0.0.36}/tests/test_circuit_breaker.py

@@ -1,5 +1,8 @@
 """Tests for violet_poolcontroller_api.circuit_breaker module."""
 
+import asyncio
+import time
+
 import pytest
 
 from violet_poolcontroller_api.circuit_breaker import (
@@ -90,7 +93,7 @@ class TestCircuitBreakerConfiguration:
         cb = CircuitBreaker(failure_threshold=5, recovery_timeout=2)
         assert cb.failure_threshold == 5
 
-    def test_zero_failure_threshold(self):
+    async def test_zero_failure_threshold(self):
         """Zero failure threshold opens on first failure."""
         cb = CircuitBreaker(failure_threshold=0, recovery_timeout=1)
 
@@ -98,7 +101,8 @@ class TestCircuitBreakerConfiguration:
             raise ValueError("fail")
 
         with pytest.raises(ValueError):
-            cb.call(failing)  # no await needed — fails before reaching callable
+            await cb.call(failing)
+        assert cb.state.name == "OPEN"
 
     def test_negative_recovery_timeout(self):
         """Negative timeout handled gracefully."""
@@ -133,6 +137,43 @@ class TestCircuitBreakerMetrics:
                 await cb.call(failing)
 
         assert cb.state.name == "OPEN"
-        cb.reset()
+        await cb.reset()
         assert cb.state.name == "CLOSED"
         assert cb.failure_count == 0
+
+
+async def test_half_open_allows_only_one_recovery_probe() -> None:
+    cb = CircuitBreaker(failure_threshold=1, timeout=0, recovery_timeout=1)
+    cb.state = cb.state.OPEN
+    cb.last_failure_time = time.monotonic() - 1
+    started = asyncio.Event()
+    release = asyncio.Event()
+
+    async def probe() -> str:
+        started.set()
+        await release.wait()
+        return "ok"
+
+    first = asyncio.create_task(cb.call(probe))
+    await started.wait()
+    with pytest.raises(CircuitBreakerOpenError, match="probe"):
+        await cb.call(probe)
+    release.set()
+
+    assert await first == "ok"
+    assert cb.state.name == "CLOSED"
+
+
+async def test_half_open_probe_timeout_reopens_circuit() -> None:
+    cb = CircuitBreaker(failure_threshold=1, timeout=0, recovery_timeout=0.01)
+    cb.state = cb.state.OPEN
+    cb.last_failure_time = time.monotonic() - 1
+
+    async def probe() -> None:
+        await asyncio.sleep(1)
+
+    with pytest.raises(TimeoutError):
+        await cb.call(probe)
+
+    assert cb.state.name == "OPEN"
+    assert cb.get_stats()["half_open_probe_in_flight"] is False