violet-poolController-api 0.0.35__tar.gz → 0.0.37__tar.gz

{violet_poolcontroller_api-0.0.35/violet_poolController_api.egg-info → violet_poolcontroller_api-0.0.37}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.35
+Version: 0.0.37
 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.35 → violet_poolcontroller_api-0.0.37}/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.35"
+version = "0.0.37"
 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.35 → violet_poolcontroller_api-0.0.37}/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
@@ -22,6 +22,7 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, Never
+from unittest.mock import AsyncMock
 
 import aiohttp
 import pytest
@@ -29,7 +30,11 @@ import pytest_asyncio
 from aioresponses import aioresponses
 from yarl import URL
 
-from violet_poolcontroller_api.api import VioletPoolAPI, VioletPoolAPIError
+from violet_poolcontroller_api.api import (
+    VioletPoolAPI,
+    VioletPoolAPIError,
+    VioletSetpointError,
+)
 from violet_poolcontroller_api.circuit_breaker import CircuitBreakerOpenError
 from violet_poolcontroller_api.const_api import (
     ERROR_CODES,
@@ -37,6 +42,7 @@ from violet_poolcontroller_api.const_api import (
     ERROR_SEVERITY_INFO,
     ERROR_SEVERITY_REMINDER,
     ERROR_SEVERITY_WARNING,
+    TARGET_PH,
 )
 
 if TYPE_CHECKING:
@@ -527,7 +533,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,
             }
@@ -842,6 +848,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,
@@ -912,6 +944,29 @@ async def test_set_dosing_parameters(
     assert result["success"] is True
 
 
+@pytest.mark.asyncio
+async def test_set_dosing_parameters_enforces_setpoint_range(
+    api_client: VioletPoolAPI,
+) -> None:
+    """set_dosing_parameters must not bypass the pH/ORP/chlorine safety bounds."""
+    with pytest.raises(VioletSetpointError, match="outside the valid range"):
+        await api_client.set_dosing_parameters({TARGET_PH: 20.0})
+
+
+@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,
@@ -1063,6 +1118,38 @@ async def test_get_system_services(
     }
 
 
+@pytest.mark.asyncio
+async def test_get_system_services_accepts_decimal_state(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """The controller may report service state as a decimal string like '1.0'."""
+    url = "http://192.168.1.100/getServiceStates"
+    mock_aioresponse.get(
+        url,
+        payload={"proftpd": "1.0", "shairport": "0.0"},
+        status=200,
+    )
+
+    result = await api_client.get_system_services()
+
+    assert result["ftp"] is True
+    assert result["shairport"] is False
+
+
+@pytest.mark.asyncio
+async def test_get_system_services_rejects_garbage_state(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """A non-numeric service state must raise, not crash with a bare ValueError."""
+    url = "http://192.168.1.100/getServiceStates"
+    mock_aioresponse.get(url, payload={"proftpd": "not-a-number"}, status=200)
+
+    with pytest.raises(VioletPoolAPIError, match="Invalid service state"):
+        await api_client.get_system_services()
+
+
 # ---------------------------------------------------------------------------
 # OmniTronic + RS485 + LiveTrace (P12 / P13 / P15)
 # ---------------------------------------------------------------------------
@@ -1556,6 +1643,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,
@@ -1730,6 +1851,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,
@@ -1748,6 +1914,40 @@ async def test_server_error_still_counts_for_circuit_breaker(
     assert stats["failure_count"] == 1
 
 
+@pytest.mark.asyncio
+async def test_rate_limiter_reacquired_on_every_retry(
+    mock_aioresponse: aioresponses,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Each retry attempt must re-acquire a rate-limit token, not just the first.
+
+    Regression test: wait_if_needed() used to be awaited once before the
+    retry loop, so retries fired real HTTP requests without ever going
+    through the limiter again.
+    """
+    url = "http://192.168.1.100/getReadings?ALL"
+    mock_aioresponse.get(url, status=500, body="boom", repeat=True)
+    # Backoff sleeps aren't what this test verifies; skip them for speed.
+    monkeypatch.setattr("violet_poolcontroller_api.api.asyncio.sleep", AsyncMock())
+
+    async with aiohttp.ClientSession() as session:
+        api = VioletPoolAPI(host="192.168.1.100", session=session, max_retries=3)
+        call_count = 0
+        original_wait = api._rate_limiter.wait_if_needed  # noqa: SLF001
+
+        async def counting_wait(*args: object, **kwargs: object) -> None:
+            nonlocal call_count
+            call_count += 1
+            await original_wait(*args, **kwargs)
+
+        api._rate_limiter.wait_if_needed = counting_wait  # type: ignore[method-assign]  # noqa: SLF001
+
+        with pytest.raises(VioletPoolAPIError):
+            await api.get_readings()
+
+    assert call_count == 3
+
+
 def test_command_result_error_first_line() -> None:
     """Line 1 of the response decides success per manual section 26.2."""
     result = VioletPoolAPI._command_result("ERROR\nPUMP\nUNKNOWN OUTPUT")
@@ -1781,3 +1981,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.35 → violet_poolcontroller_api-0.0.37}/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)