proconip 2.2.0__tar.gz → 2.2.1__tar.gz

{proconip-2.2.0 → proconip-2.2.1}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.2.1](https://github.com/ylabonte/proconip-pypi/compare/v2.2.0...v2.2.1) (2026-10-08)
+
+
+### Bug Fixes
+
+* support aiohttp 3.14 without deprecation warnings; test against it ([#94](https://github.com/ylabonte/proconip-pypi/issues/94), [#97](https://github.com/ylabonte/proconip-pypi/issues/97)) ([#98](https://github.com/ylabonte/proconip-pypi/issues/98)) ([87dcc3d](https://github.com/ylabonte/proconip-pypi/commit/87dcc3d01ab2d5cae7fb826638086665f2076c7c))
+
 ## [2.2.0](https://github.com/ylabonte/proconip-pypi/compare/v2.1.2...v2.2.0) (2026-06-14)
 
 

{proconip-2.2.0 → proconip-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: proconip
-Version: 2.2.0
+Version: 2.2.1
 Summary: Async Python library for interacting with the ProCon.IP pool controller.
 Project-URL: Homepage, https://github.com/ylabonte/proconip-pypi
 Project-URL: Documentation, https://ylabonte.github.io/proconip-pypi/
@@ -176,8 +176,8 @@ async def manual_dosage_example():
     client_session = aiohttp.ClientSession()
     config = ConfigObject("http://192.168.2.3", "admin", "admin")
     dosage_control = DosageControl(client_session, config)
-    await dosage_control.async_chlorine_dosage(3600) # start for 1 hour
-    await dosage_control.async_ph_minus_dosage(60) # start for 1 minute
+    await dosage_control.async_chlorine_dosage(3600)  # start for 1 hour
+    await dosage_control.async_ph_minus_dosage(60)  # start for 1 minute
     await client_session.close()
 
 
@@ -201,13 +201,12 @@ async def dmx_example():
         print(f"{channel.name} before: {channel.value}")
         dmx_data.set(channel.index, (channel.value + 128) % 256)
         print(f"{channel.name} after: {dmx_data.get_value(channel.index)}")
-      
+
     await dmx_control.async_set(dmx_data)
     await client_session.close()
 
 
 asyncio.run(dmx_example())
-
 ```
 
 ## A brief description of the ProCon.IP pool controller

{proconip-2.2.0 → proconip-2.2.1}/README.md

@@ -148,8 +148,8 @@ async def manual_dosage_example():
     client_session = aiohttp.ClientSession()
     config = ConfigObject("http://192.168.2.3", "admin", "admin")
     dosage_control = DosageControl(client_session, config)
-    await dosage_control.async_chlorine_dosage(3600) # start for 1 hour
-    await dosage_control.async_ph_minus_dosage(60) # start for 1 minute
+    await dosage_control.async_chlorine_dosage(3600)  # start for 1 hour
+    await dosage_control.async_ph_minus_dosage(60)  # start for 1 minute
     await client_session.close()
 
 
@@ -173,13 +173,12 @@ async def dmx_example():
         print(f"{channel.name} before: {channel.value}")
         dmx_data.set(channel.index, (channel.value + 128) % 256)
         print(f"{channel.name} after: {dmx_data.get_value(channel.index)}")
-      
+
     await dmx_control.async_set(dmx_data)
     await client_session.close()
 
 
 asyncio.run(dmx_example())
-
 ```
 
 ## A brief description of the ProCon.IP pool controller

{proconip-2.2.0 → proconip-2.2.1}/pyproject.toml

@@ -37,15 +37,11 @@ test = [
     "pytest",
     "pytest-asyncio",
     "pytest-cov",
-    "aioresponses",
-    # aioresponses 0.7.8 can't build mocked responses against aiohttp 3.14+
-    # (ClientResponse gained a required `stream_writer` kwarg), which breaks
-    # the whole test_api suite. Pin tests to the 3.13.x line HA Core ships.
-    # TODO: lift this cap once a compatible aioresponses release lands.
-    "aiohttp<3.14",
 ]
 docs = [
-    "mkdocs",
+    # MkDocs 2.0 drops the plugin system and the theming that Material and
+    # mkdocstrings rely on, with no migration path — stay on 1.x.
+    "mkdocs<2",
     "mkdocs-material",
     "mkdocstrings[python]",
     "mkdocs-include-markdown-plugin",

{proconip-2.2.0 → proconip-2.2.1}/src/proconip/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.2.1'
+__version_tuple__ = version_tuple = (2, 2, 1)
 
 __commit_id__ = commit_id = None

{proconip-2.2.0 → proconip-2.2.1}/src/proconip/api.py

@@ -26,11 +26,11 @@ subclasses so callers can handle them uniformly.
 """
 
 import asyncio
+import base64
 import contextlib
 import socket
 
 from aiohttp import (
-    BasicAuth,
     ClientError,
     ClientResponse,
     ClientSession,
@@ -84,6 +84,18 @@ class TimeoutException(ProconipApiException):
     """
 
 
+def _auth_headers(config: ConfigObject) -> dict[str, str]:
+    """Build the HTTP Basic ``Authorization`` header for the controller credentials.
+
+    Built by hand rather than via ``aiohttp.BasicAuth`` / ``auth=``, which
+    aiohttp 3.14 deprecates (removal in 4.0), while its replacement
+    ``aiohttp.encode_basic_auth`` doesn't exist on older supported versions.
+    Credentials are latin-1 encoded, matching ``BasicAuth``'s default.
+    """
+    credentials = f"{config.username}:{config.password}".encode("latin1")
+    return {"Authorization": "Basic " + base64.b64encode(credentials).decode("ascii")}
+
+
 async def _handle_response(response: ClientResponse) -> str:
     """Validate the response and return its body, mapping HTTP errors to typed exceptions."""
     if response.status in (401, 403):
@@ -130,10 +142,9 @@ async def async_get_raw_data(
         ProconipApiException: For DNS failures, connection resets, and other
             network-level errors.
     """
-    auth = BasicAuth(config.username, config.password)
     try:
         async with asyncio.timeout(timeout):
-            async with client_session.get(url, auth=auth) as response:
+            async with client_session.get(url, headers=_auth_headers(config)) as response:
                 return await _handle_response(response)
     except TimeoutError as exc:
         raise TimeoutException("API request timed out") from exc
@@ -300,15 +311,16 @@ async def async_post_usrcfg_cgi(
         ProconipApiException: For network-level errors.
     """
     url = URL(config.base_url).with_path(API_PATH_USRCFG)
-    auth = BasicAuth(config.username, config.password)
-    headers = {"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        **_auth_headers(config),
+    }
     try:
         async with asyncio.timeout(timeout):
             async with client_session.post(
                 url=url,
                 headers=headers,
                 data=payload,
-                auth=auth,
             ) as response:
                 return await _handle_response(response)
     except TimeoutError as exc:

{proconip-2.2.0 → proconip-2.2.1}/src/proconip/definitions.py

@@ -585,7 +585,13 @@ class GetStateData:
     @property
     def config_other_enable(self) -> int:
         """Misc configuration flags. Use the `is_*_enabled` methods to query
-        individual bits (TCP/IP boost, SD card, DMX, …)."""
+        individual bits (TCP/IP boost, SD card, DMX, …).
+
+        Not every "Sonstiges" checkbox is mirrored here on current firmware:
+        on 1.7.6, bits 0 (TCP/IP boost), 1 (SD card) and 5 (high bus load)
+        were observed as 0 although those options were enabled, while bit 2
+        (DMX) tracked its checkbox exactly. Bits 3, 4, 6, 7 and 8 are
+        unverified on hardware."""
         return self._config_other_enable
 
     @property
@@ -749,15 +755,28 @@ class GetStateData:
         return NTP_FAULT_STATE[0]
 
     def is_tcpip_boost_enabled(self) -> bool:
-        """True if TCP/IP boost is enabled in the controller config (bit 0)."""
+        """True if bit 0 (TCP/IP boost) of `config_other_enable` is set.
+
+        Unreliable on current firmware: 1.7.6 was observed reporting this bit
+        as 0 while TCP/IP boost was enabled, so ``False`` doesn't prove the
+        feature is off.
+        """
         return self._config_other_enable & 1 == 1
 
     def is_sd_card_enabled(self) -> bool:
-        """True if SD card logging is enabled in the controller config (bit 1)."""
+        """True if bit 1 (SD card) of `config_other_enable` is set.
+
+        Unreliable on current firmware: 1.7.6 was observed reporting this bit
+        as 0 while the SD card was enabled, so ``False`` doesn't prove the
+        feature is off.
+        """
         return self._config_other_enable & 2 == 2
 
     def is_dmx_enabled(self) -> bool:
-        """True if DMX output is enabled in the controller config (bit 2)."""
+        """True if DMX output is enabled in the controller config (bit 2).
+
+        Verified on firmware 1.7.6: the bit follows the "DMX512 aktiv" checkbox.
+        """
         return self._config_other_enable & 4 == 4
 
     def is_avatar_enabled(self) -> bool:
@@ -774,7 +793,12 @@ class GetStateData:
         return self._config_other_enable & 16 == 16
 
     def is_high_bus_load_enabled(self) -> bool:
-        """True if high bus load mode is enabled in the controller config (bit 5)."""
+        """True if bit 5 (high bus load, 1-Wire) of `config_other_enable` is set.
+
+        Unreliable on current firmware: 1.7.6 was observed reporting this bit
+        as 0 while high bus load was enabled, so ``False`` doesn't prove the
+        feature is off.
+        """
         return self._config_other_enable & 32 == 32
 
     def is_flow_sensor_enabled(self) -> bool:

proconip-2.2.1/tests/test_api.py

@@ -0,0 +1,548 @@
+"""Tests for the API module — HTTP layer, error mapping, and class wrappers.
+
+Requests go over a real socket to `FakeController`, an in-process aiohttp
+server, so the suite exercises whichever aiohttp version is installed end to
+end (response construction, auth headers, timeouts) instead of a mocked
+client internals layer.
+"""
+
+import asyncio
+import base64
+import socket
+from collections import defaultdict, deque
+from collections.abc import AsyncIterator, Awaitable, Callable
+from dataclasses import dataclass
+from unittest.mock import patch
+
+import aiohttp
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import RawTestServer
+
+from proconip.api import (
+    BadCredentialsException,
+    BadStatusCodeException,
+    DigitalInputControl,
+    DmxControl,
+    DosageControl,
+    GetState,
+    ProconipApiException,
+    RelaySwitch,
+    TimeoutException,
+    async_get_dmx,
+    async_get_raw_dmx,
+    async_get_raw_state,
+    async_get_state,
+    async_set_auto_mode,
+    async_set_dmx,
+    async_start_dosage,
+    async_switch_off,
+    async_switch_on,
+    async_trigger_digital_input,
+)
+from proconip.definitions import ConfigObject, DosageTarget, GetDmxData, GetStateData
+
+GET_STATE_PATH = "/GetState.csv"
+USRCFG_PATH = "/usrcfg.cgi"
+GET_DMX_PATH = "/GetDmx.csv"
+
+SIMPLE_DMX_CSV = "0,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150\n"
+
+_real_sleep = asyncio.sleep
+
+
+@dataclass
+class RecordedRequest:
+    method: str
+    path_qs: str
+    body: str
+    authorization: str | None
+
+
+@dataclass
+class _QueuedResponse:
+    body: str
+    status: int
+    delay: float
+
+
+class FakeController:
+    """Stand-in ProCon.IP controller with queued responses per method and path.
+
+    Each `add()` queues one response; requests consume them in order. An
+    unmatched request gets a 404 so a wrong URL fails loudly.
+    """
+
+    def __init__(self) -> None:
+        self.base_url = ""
+        self.requests: list[RecordedRequest] = []
+        self._responses: defaultdict[tuple[str, str], deque[_QueuedResponse]] = defaultdict(deque)
+
+    def add(
+        self, method: str, path_qs: str, *, body: str = "", status: int = 200, delay: float = 0.0
+    ) -> None:
+        self._responses[(method, path_qs)].append(_QueuedResponse(body, status, delay))
+
+    def get(self, path_qs: str, *, body: str = "", status: int = 200, delay: float = 0.0) -> None:
+        self.add("GET", path_qs, body=body, status=status, delay=delay)
+
+    def post(self, path_qs: str, *, body: str = "", status: int = 200, delay: float = 0.0) -> None:
+        self.add("POST", path_qs, body=body, status=status, delay=delay)
+
+    def posts_to(self, path: str) -> list[RecordedRequest]:
+        return [r for r in self.requests if r.method == "POST" and r.path_qs == path]
+
+    async def handle(self, request: web.BaseRequest) -> web.Response:
+        self.requests.append(
+            RecordedRequest(
+                method=request.method,
+                path_qs=request.path_qs,
+                body=await request.text(),
+                authorization=request.headers.get("Authorization"),
+            )
+        )
+        queue = self._responses.get((request.method, request.path_qs))
+        if not queue:
+            return web.Response(status=404, text=f"unexpected {request.method} {request.path_qs}")
+        response = queue.popleft()
+        if response.delay:
+            await _real_sleep(response.delay)
+        return web.Response(text=response.body, status=response.status)
+
+
+@pytest.fixture
+async def controller() -> AsyncIterator[FakeController]:
+    fake = FakeController()
+    async with RawTestServer(fake.handle) as server:
+        fake.base_url = f"http://{server.host}:{server.port}"
+        yield fake
+
+
+@pytest.fixture
+def config(controller: FakeController) -> ConfigObject:
+    return ConfigObject(controller.base_url, "admin", "admin")
+
+
+def _sleep_spy(
+    on_hold: Callable[[float], Awaitable[None]],
+) -> Callable[..., Awaitable[object]]:
+    """Patch target for `asyncio.sleep` that only intercepts the hold delay.
+
+    `proconip.api.asyncio` is the global asyncio module, so the patch is seen
+    by aiohttp and the event loop too; every other sleep passes through.
+    """
+
+    async def fake_sleep(delay: float, *args: object) -> object:
+        if delay == 0.6:
+            return await on_hold(delay)
+        return await _real_sleep(delay, *args)
+
+    return fake_sleep
+
+
+# ---------------------------------------------------------------------------
+# async_get_raw_state
+# ---------------------------------------------------------------------------
+
+
+async def test_get_raw_state_happy_path(controller: FakeController, config: ConfigObject) -> None:
+    controller.get(GET_STATE_PATH, body="raw_csv_response", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_get_raw_state(session, config)
+    assert result == "raw_csv_response"
+
+
+async def test_get_raw_state_401_raises_bad_credentials(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.get(GET_STATE_PATH, status=401)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadCredentialsException):
+            await async_get_raw_state(session, config)
+
+
+async def test_get_raw_state_403_raises_bad_credentials(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.get(GET_STATE_PATH, status=403)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadCredentialsException):
+            await async_get_raw_state(session, config)
+
+
+async def test_get_raw_state_500_raises_bad_status_code(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.get(GET_STATE_PATH, status=500)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadStatusCodeException):
+            await async_get_raw_state(session, config)
+
+
+async def test_get_raw_state_timeout_raises_timeout_exception(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.get(GET_STATE_PATH, body="too late", delay=1.0)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(TimeoutException):
+            await async_get_raw_state(session, config, timeout=0.05)
+
+
+async def test_get_raw_state_connection_error_raises_api_exception() -> None:
+    # Bind and release a port so nothing is listening on it.
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+    unreachable = ConfigObject(f"http://127.0.0.1:{port}", "admin", "admin")
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ProconipApiException):
+            await async_get_raw_state(session, unreachable)
+
+
+async def test_requests_send_basic_auth(controller: FakeController, config: ConfigObject) -> None:
+    controller.get(GET_STATE_PATH, body="ok")
+    controller.post(USRCFG_PATH, body="ok")
+    controller.post(USRCFG_PATH, body="ok")
+    async with aiohttp.ClientSession() as session:
+        await async_get_raw_state(session, config)
+        await async_trigger_digital_input(session, config, 0, hold_seconds=0)
+    expected = "Basic " + base64.b64encode(b"admin:admin").decode()
+    assert [r.authorization for r in controller.requests] == [expected] * 3
+
+
+# ---------------------------------------------------------------------------
+# async_get_state
+# ---------------------------------------------------------------------------
+
+
+async def test_get_state_returns_parsed_data(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    controller.get(GET_STATE_PATH, body=get_state_csv, status=200)
+    async with aiohttp.ClientSession() as session:
+        state = await async_get_state(session, config)
+    assert isinstance(state, GetStateData)
+    assert state.version == "1.7.3"
+
+
+# ---------------------------------------------------------------------------
+# async_get_raw_dmx / async_get_dmx
+# ---------------------------------------------------------------------------
+
+
+async def test_get_raw_dmx(controller: FakeController, config: ConfigObject) -> None:
+    controller.get(GET_DMX_PATH, body=SIMPLE_DMX_CSV, status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_get_raw_dmx(session, config)
+    assert result == SIMPLE_DMX_CSV
+
+
+async def test_get_dmx_returns_parsed_data(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.get(GET_DMX_PATH, body=SIMPLE_DMX_CSV, status=200)
+    async with aiohttp.ClientSession() as session:
+        dmx = await async_get_dmx(session, config)
+    assert isinstance(dmx, GetDmxData)
+    assert dmx.get_value(0) == 0
+    assert dmx.get_value(15) == 150
+
+
+async def test_get_dmx_401_raises_bad_credentials(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.get(GET_DMX_PATH, status=401)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadCredentialsException):
+            await async_get_dmx(session, config)
+
+
+# ---------------------------------------------------------------------------
+# async_switch_on / async_switch_off / async_set_auto_mode
+# ---------------------------------------------------------------------------
+
+
+async def test_switch_on_sends_post(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    state = GetStateData(get_state_csv)
+    relay = state.get_relay(0)  # not a dosage relay
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_switch_on(session, config, state, relay)
+    assert result == "ok"
+
+
+async def test_switch_on_dosage_relay_raises_bad_relay(
+    config: ConfigObject, get_state_csv: str
+) -> None:
+    from proconip.definitions import BadRelayException
+
+    state = GetStateData(get_state_csv)
+    # chlorine_dosage_relay_id = 5 from fixture SYSINFO
+    dosage_relay = state.get_relay(5)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadRelayException):
+            await async_switch_on(session, config, state, dosage_relay)
+
+
+async def test_switch_off_sends_post(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    state = GetStateData(get_state_csv)
+    relay = state.get_relay(0)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_switch_off(session, config, state, relay)
+    assert result == "ok"
+
+
+async def test_set_auto_mode_sends_post(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    state = GetStateData(get_state_csv)
+    relay = state.get_relay(0)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_set_auto_mode(session, config, state, relay)
+    assert result == "ok"
+
+
+async def test_switch_on_401_raises_bad_credentials(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    state = GetStateData(get_state_csv)
+    relay = state.get_relay(0)
+    controller.post(USRCFG_PATH, status=401)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadCredentialsException):
+            await async_switch_on(session, config, state, relay)
+
+
+# ---------------------------------------------------------------------------
+# async_start_dosage
+# ---------------------------------------------------------------------------
+
+
+async def test_start_dosage_chlorine(controller: FakeController, config: ConfigObject) -> None:
+    expected_path = "/Command.htm?MAN_DOSAGE=0,60"
+    controller.get(expected_path, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_start_dosage(session, config, DosageTarget.CHLORINE, 60)
+    assert result == "ok"
+
+
+async def test_start_dosage_ph_minus(controller: FakeController, config: ConfigObject) -> None:
+    expected_path = "/Command.htm?MAN_DOSAGE=1,120"
+    controller.get(expected_path, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_start_dosage(session, config, DosageTarget.PH_MINUS, 120)
+    assert result == "ok"
+
+
+# ---------------------------------------------------------------------------
+# async_set_dmx
+# ---------------------------------------------------------------------------
+
+
+async def test_set_dmx_sends_post(
+    controller: FakeController, config: ConfigObject, get_dmx_csv: str
+) -> None:
+    dmx = GetDmxData(get_dmx_csv)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_set_dmx(session, config, dmx)
+    assert result == "ok"
+
+
+# ---------------------------------------------------------------------------
+# async_trigger_digital_input
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("digital_input_id", "expected_mask"),
+    [(0, 1), (1, 2), (2, 4), (3, 8)],
+)
+async def test_trigger_digital_input_sends_posts(
+    controller: FakeController, config: ConfigObject, digital_input_id: int, expected_mask: int
+) -> None:
+    controller.post(USRCFG_PATH, body="press-ok", status=200)
+    controller.post(USRCFG_PATH, body="release-ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        result = await async_trigger_digital_input(
+            session, config, digital_input_id, hold_seconds=0
+        )
+    posts = controller.posts_to(USRCFG_PATH)
+    assert len(posts) == 2
+    assert posts[0].body == f"IO={expected_mask}&WEBIO=1"
+    assert posts[1].body == "IO=0&WEBIO=1"
+    # The function returns the *release* response body.
+    assert result == "release-ok"
+
+
+@pytest.mark.parametrize("digital_input_id", [-1, 4, 99])
+async def test_trigger_digital_input_invalid_id_raises(
+    controller: FakeController, config: ConfigObject, digital_input_id: int
+) -> None:
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError):
+            await async_trigger_digital_input(session, config, digital_input_id)
+    assert controller.posts_to(USRCFG_PATH) == []
+
+
+async def test_trigger_digital_input_401_raises_bad_credentials(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.post(USRCFG_PATH, status=401)
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(BadCredentialsException):
+            await async_trigger_digital_input(session, config, 0)
+
+
+async def test_trigger_digital_input_holds_high_between_posts(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    """By default the input is held HIGH ~600ms between press and release.
+
+    Mirrors the controller's web UI, which waits before clearing the bit.
+    asyncio.sleep is patched so the test stays fast while proving the hold
+    happens *between* the two POSTs (one POST recorded when sleep fires).
+    """
+    posts_at_sleep: list[int] = []
+
+    async def record_sleep(delay: float) -> None:
+        posts_at_sleep.append(len(controller.posts_to(USRCFG_PATH)))
+        assert delay == 0.6
+
+    controller.post(USRCFG_PATH, body="press-ok", status=200)
+    controller.post(USRCFG_PATH, body="release-ok", status=200)
+    with patch("proconip.api.asyncio.sleep", side_effect=_sleep_spy(record_sleep)):
+        async with aiohttp.ClientSession() as session:
+            result = await async_trigger_digital_input(session, config, 0)
+
+    assert result == "release-ok"
+    assert len(controller.posts_to(USRCFG_PATH)) == 2
+    # sleep fired exactly once, after the press POST and before the release.
+    assert posts_at_sleep == [1]
+
+
+async def test_trigger_digital_input_releases_on_cancel(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    """A cancelled hold still attempts a best-effort release, then re-raises.
+
+    Otherwise a press would set the bit and the cancellation would leave the
+    input asserted HIGH with no release.
+    """
+
+    async def cancel_during_hold(delay: float) -> None:
+        raise asyncio.CancelledError
+
+    controller.post(USRCFG_PATH, body="press-ok", status=200)
+    controller.post(USRCFG_PATH, body="release-ok", status=200)
+    with patch("proconip.api.asyncio.sleep", side_effect=_sleep_spy(cancel_during_hold)):
+        async with aiohttp.ClientSession() as session:
+            with pytest.raises(asyncio.CancelledError):
+                await async_trigger_digital_input(session, config, 0)
+    posts = controller.posts_to(USRCFG_PATH)
+    assert [p.body for p in posts] == ["IO=1&WEBIO=1", "IO=0&WEBIO=1"]
+
+
+def test_digital_input_count_is_exported_from_package() -> None:
+    from proconip import DIGITAL_INPUT_COUNT
+
+    assert DIGITAL_INPUT_COUNT == 4
+
+
+# ---------------------------------------------------------------------------
+# OO class wrappers
+# ---------------------------------------------------------------------------
+
+
+async def test_get_state_class_get_raw_state(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    controller.get(GET_STATE_PATH, body=get_state_csv, status=200)
+    async with aiohttp.ClientSession() as session:
+        api = GetState(session, config)
+        raw = await api.async_get_raw_state()
+    assert raw == get_state_csv
+
+
+async def test_get_state_class_get_state(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    controller.get(GET_STATE_PATH, body=get_state_csv, status=200)
+    async with aiohttp.ClientSession() as session:
+        api = GetState(session, config)
+        state = await api.async_get_state()
+    assert isinstance(state, GetStateData)
+
+
+async def test_relay_switch_class(
+    controller: FakeController, config: ConfigObject, get_state_csv: str
+) -> None:
+    state = GetStateData(get_state_csv)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        rs = RelaySwitch(session, config)
+        await rs.async_switch_on(state, 0)
+        await rs.async_switch_off(state, 0)
+        await rs.async_set_auto_mode(state, 0)
+
+
+async def test_dosage_control_class(controller: FakeController, config: ConfigObject) -> None:
+    cmd_url_chlorine = "/Command.htm?MAN_DOSAGE=0,60"
+    cmd_url_ph_minus = "/Command.htm?MAN_DOSAGE=1,30"
+    cmd_url_ph_plus = "/Command.htm?MAN_DOSAGE=2,45"
+    controller.get(cmd_url_chlorine, body="ok", status=200)
+    controller.get(cmd_url_ph_minus, body="ok", status=200)
+    controller.get(cmd_url_ph_plus, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        dc = DosageControl(session, config)
+        await dc.async_chlorine_dosage(60)
+        await dc.async_ph_minus_dosage(30)
+        await dc.async_ph_plus_dosage(45)
+
+
+async def test_dmx_control_class(
+    controller: FakeController, config: ConfigObject, get_dmx_csv: str
+) -> None:
+    dmx = GetDmxData(get_dmx_csv)
+    controller.get(GET_DMX_PATH, body=SIMPLE_DMX_CSV, status=200)
+    controller.get(GET_DMX_PATH, body=SIMPLE_DMX_CSV, status=200)
+    controller.post(USRCFG_PATH, body="ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        dc = DmxControl(session, config)
+        raw = await dc.async_get_raw_dmx()
+        parsed = await dc.async_get_dmx()
+        await dc.async_set(dmx)
+    assert raw == SIMPLE_DMX_CSV
+    assert isinstance(parsed, GetDmxData)
+
+
+async def test_digital_input_control_class(
+    controller: FakeController, config: ConfigObject
+) -> None:
+    controller.post(USRCFG_PATH, body="press-ok", status=200)
+    controller.post(USRCFG_PATH, body="release-ok", status=200)
+    async with aiohttp.ClientSession() as session:
+        dic = DigitalInputControl(session, config)
+        result = await dic.async_trigger(2, hold_seconds=0)
+    posts = controller.posts_to(USRCFG_PATH)
+    assert [p.body for p in posts] == ["IO=4&WEBIO=1", "IO=0&WEBIO=1"]
+    assert result == "release-ok"
+
+
+# ---------------------------------------------------------------------------
+# Exception hierarchy
+# ---------------------------------------------------------------------------
+
+
+def test_exception_hierarchy() -> None:
+    assert issubclass(BadCredentialsException, ProconipApiException)
+    assert issubclass(BadStatusCodeException, ProconipApiException)
+    assert issubclass(TimeoutException, ProconipApiException)

proconip-2.2.0/tests/test_api.py

@@ -1,431 +0,0 @@
-"""Tests for the API module — HTTP layer, error mapping, and class wrappers."""
-
-import asyncio
-from unittest.mock import patch
-
-import aiohttp
-import pytest
-from aioresponses import aioresponses
-
-from proconip.api import (
-    BadCredentialsException,
-    BadStatusCodeException,
-    DigitalInputControl,
-    DmxControl,
-    DosageControl,
-    GetState,
-    ProconipApiException,
-    RelaySwitch,
-    TimeoutException,
-    async_get_dmx,
-    async_get_raw_dmx,
-    async_get_raw_state,
-    async_get_state,
-    async_set_auto_mode,
-    async_set_dmx,
-    async_start_dosage,
-    async_switch_off,
-    async_switch_on,
-    async_trigger_digital_input,
-)
-from proconip.definitions import ConfigObject, DosageTarget, GetDmxData, GetStateData
-
-BASE_URL = "http://127.0.0.1"
-GET_STATE_URL = f"{BASE_URL}/GetState.csv"
-USRCFG_URL = f"{BASE_URL}/usrcfg.cgi"
-GET_DMX_URL = f"{BASE_URL}/GetDmx.csv"
-
-SIMPLE_DMX_CSV = "0,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150\n"
-
-
-# ---------------------------------------------------------------------------
-# async_get_raw_state
-# ---------------------------------------------------------------------------
-
-
-async def test_get_raw_state_happy_path(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, body="raw_csv_response", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_get_raw_state(session, config)
-    assert result == "raw_csv_response"
-
-
-async def test_get_raw_state_401_raises_bad_credentials(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, status=401)
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(BadCredentialsException):
-                await async_get_raw_state(session, config)
-
-
-async def test_get_raw_state_403_raises_bad_credentials(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, status=403)
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(BadCredentialsException):
-                await async_get_raw_state(session, config)
-
-
-async def test_get_raw_state_500_raises_bad_status_code(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, status=500)
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(BadStatusCodeException):
-                await async_get_raw_state(session, config)
-
-
-async def test_get_raw_state_timeout_raises_timeout_exception(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, exception=TimeoutError())
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(TimeoutException):
-                await async_get_raw_state(session, config)
-
-
-async def test_get_raw_state_connection_error_raises_api_exception(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, exception=aiohttp.ClientConnectionError("conn failed"))
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(ProconipApiException):
-                await async_get_raw_state(session, config)
-
-
-# ---------------------------------------------------------------------------
-# async_get_state
-# ---------------------------------------------------------------------------
-
-
-async def test_get_state_returns_parsed_data(config: ConfigObject, get_state_csv: str) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, body=get_state_csv, status=200)
-        async with aiohttp.ClientSession() as session:
-            state = await async_get_state(session, config)
-    assert isinstance(state, GetStateData)
-    assert state.version == "1.7.3"
-
-
-# ---------------------------------------------------------------------------
-# async_get_raw_dmx / async_get_dmx
-# ---------------------------------------------------------------------------
-
-
-async def test_get_raw_dmx(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_DMX_URL, body=SIMPLE_DMX_CSV, status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_get_raw_dmx(session, config)
-    assert result == SIMPLE_DMX_CSV
-
-
-async def test_get_dmx_returns_parsed_data(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_DMX_URL, body=SIMPLE_DMX_CSV, status=200)
-        async with aiohttp.ClientSession() as session:
-            dmx = await async_get_dmx(session, config)
-    assert isinstance(dmx, GetDmxData)
-    assert dmx.get_value(0) == 0
-    assert dmx.get_value(15) == 150
-
-
-async def test_get_dmx_401_raises_bad_credentials(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.get(GET_DMX_URL, status=401)
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(BadCredentialsException):
-                await async_get_dmx(session, config)
-
-
-# ---------------------------------------------------------------------------
-# async_switch_on / async_switch_off / async_set_auto_mode
-# ---------------------------------------------------------------------------
-
-
-async def test_switch_on_sends_post(config: ConfigObject, get_state_csv: str) -> None:
-    state = GetStateData(get_state_csv)
-    relay = state.get_relay(0)  # not a dosage relay
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_switch_on(session, config, state, relay)
-    assert result == "ok"
-
-
-async def test_switch_on_dosage_relay_raises_bad_relay(
-    config: ConfigObject, get_state_csv: str
-) -> None:
-    from proconip.definitions import BadRelayException
-
-    state = GetStateData(get_state_csv)
-    # chlorine_dosage_relay_id = 5 from fixture SYSINFO
-    dosage_relay = state.get_relay(5)
-    async with aiohttp.ClientSession() as session:
-        with pytest.raises(BadRelayException):
-            await async_switch_on(session, config, state, dosage_relay)
-
-
-async def test_switch_off_sends_post(config: ConfigObject, get_state_csv: str) -> None:
-    state = GetStateData(get_state_csv)
-    relay = state.get_relay(0)
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_switch_off(session, config, state, relay)
-    assert result == "ok"
-
-
-async def test_set_auto_mode_sends_post(config: ConfigObject, get_state_csv: str) -> None:
-    state = GetStateData(get_state_csv)
-    relay = state.get_relay(0)
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_set_auto_mode(session, config, state, relay)
-    assert result == "ok"
-
-
-async def test_switch_on_401_raises_bad_credentials(
-    config: ConfigObject, get_state_csv: str
-) -> None:
-    state = GetStateData(get_state_csv)
-    relay = state.get_relay(0)
-    with aioresponses() as m:
-        m.post(USRCFG_URL, status=401)
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(BadCredentialsException):
-                await async_switch_on(session, config, state, relay)
-
-
-# ---------------------------------------------------------------------------
-# async_start_dosage
-# ---------------------------------------------------------------------------
-
-
-async def test_start_dosage_chlorine(config: ConfigObject) -> None:
-    expected_url = f"{BASE_URL}/Command.htm?MAN_DOSAGE=0,60"
-    with aioresponses() as m:
-        m.get(expected_url, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_start_dosage(session, config, DosageTarget.CHLORINE, 60)
-    assert result == "ok"
-
-
-async def test_start_dosage_ph_minus(config: ConfigObject) -> None:
-    expected_url = f"{BASE_URL}/Command.htm?MAN_DOSAGE=1,120"
-    with aioresponses() as m:
-        m.get(expected_url, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_start_dosage(session, config, DosageTarget.PH_MINUS, 120)
-    assert result == "ok"
-
-
-# ---------------------------------------------------------------------------
-# async_set_dmx
-# ---------------------------------------------------------------------------
-
-
-async def test_set_dmx_sends_post(config: ConfigObject, get_dmx_csv: str) -> None:
-    dmx = GetDmxData(get_dmx_csv)
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_set_dmx(session, config, dmx)
-    assert result == "ok"
-
-
-# ---------------------------------------------------------------------------
-# async_trigger_digital_input
-# ---------------------------------------------------------------------------
-
-
-def _usrcfg_posts(m: aioresponses) -> list:
-    """Return the recorded POST calls to /usrcfg.cgi, in order."""
-    return [
-        call
-        for (method, url), calls in m.requests.items()
-        for call in calls
-        if method == "POST" and "usrcfg.cgi" in str(url)
-    ]
-
-
-@pytest.mark.parametrize(
-    ("digital_input_id", "expected_mask"),
-    [(0, 1), (1, 2), (2, 4), (3, 8)],
-)
-async def test_trigger_digital_input_sends_posts(
-    config: ConfigObject, digital_input_id: int, expected_mask: int
-) -> None:
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="press-ok", status=200)
-        m.post(USRCFG_URL, body="release-ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            result = await async_trigger_digital_input(
-                session, config, digital_input_id, hold_seconds=0
-            )
-    posts = _usrcfg_posts(m)
-    assert len(posts) == 2
-    assert posts[0].kwargs["data"] == f"IO={expected_mask}&WEBIO=1"
-    assert posts[1].kwargs["data"] == "IO=0&WEBIO=1"
-    # The function returns the *release* response body.
-    assert result == "release-ok"
-
-
-@pytest.mark.parametrize("digital_input_id", [-1, 4, 99])
-async def test_trigger_digital_input_invalid_id_raises(
-    config: ConfigObject, digital_input_id: int
-) -> None:
-    with aioresponses() as m:
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(ValueError):
-                await async_trigger_digital_input(session, config, digital_input_id)
-    assert _usrcfg_posts(m) == []
-
-
-async def test_trigger_digital_input_401_raises_bad_credentials(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.post(USRCFG_URL, status=401)
-        async with aiohttp.ClientSession() as session:
-            with pytest.raises(BadCredentialsException):
-                await async_trigger_digital_input(session, config, 0)
-
-
-async def test_trigger_digital_input_holds_high_between_posts(config: ConfigObject) -> None:
-    """By default the input is held HIGH ~600ms between press and release.
-
-    Mirrors the controller's web UI, which waits before clearing the bit.
-    asyncio.sleep is patched so the test stays fast while proving the hold
-    happens *between* the two POSTs (one POST recorded when sleep fires).
-    """
-    posts_at_sleep: list[int] = []
-
-    async def record_sleep(delay: float) -> None:
-        posts_at_sleep.append(len(_usrcfg_posts(m)))
-        assert delay == 0.6
-
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="press-ok", status=200)
-        m.post(USRCFG_URL, body="release-ok", status=200)
-        with patch("proconip.api.asyncio.sleep", side_effect=record_sleep):
-            async with aiohttp.ClientSession() as session:
-                result = await async_trigger_digital_input(session, config, 0)
-
-    assert result == "release-ok"
-    assert len(_usrcfg_posts(m)) == 2
-    # sleep fired exactly once, after the press POST and before the release.
-    assert posts_at_sleep == [1]
-
-
-async def test_trigger_digital_input_releases_on_cancel(config: ConfigObject) -> None:
-    """A cancelled hold still attempts a best-effort release, then re-raises.
-
-    Otherwise a press would set the bit and the cancellation would leave the
-    input asserted HIGH with no release.
-    """
-
-    async def cancel_during_hold(delay: float) -> None:
-        raise asyncio.CancelledError
-
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="press-ok", status=200)
-        m.post(USRCFG_URL, body="release-ok", status=200)
-        with patch("proconip.api.asyncio.sleep", side_effect=cancel_during_hold):
-            async with aiohttp.ClientSession() as session:
-                with pytest.raises(asyncio.CancelledError):
-                    await async_trigger_digital_input(session, config, 0)
-    posts = _usrcfg_posts(m)
-    assert [p.kwargs["data"] for p in posts] == ["IO=1&WEBIO=1", "IO=0&WEBIO=1"]
-
-
-def test_digital_input_count_is_exported_from_package() -> None:
-    from proconip import DIGITAL_INPUT_COUNT
-
-    assert DIGITAL_INPUT_COUNT == 4
-
-
-# ---------------------------------------------------------------------------
-# OO class wrappers
-# ---------------------------------------------------------------------------
-
-
-async def test_get_state_class_get_raw_state(config: ConfigObject, get_state_csv: str) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, body=get_state_csv, status=200)
-        async with aiohttp.ClientSession() as session:
-            api = GetState(session, config)
-            raw = await api.async_get_raw_state()
-    assert raw == get_state_csv
-
-
-async def test_get_state_class_get_state(config: ConfigObject, get_state_csv: str) -> None:
-    with aioresponses() as m:
-        m.get(GET_STATE_URL, body=get_state_csv, status=200)
-        async with aiohttp.ClientSession() as session:
-            api = GetState(session, config)
-            state = await api.async_get_state()
-    assert isinstance(state, GetStateData)
-
-
-async def test_relay_switch_class(config: ConfigObject, get_state_csv: str) -> None:
-    state = GetStateData(get_state_csv)
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="ok", status=200)
-        m.post(USRCFG_URL, body="ok", status=200)
-        m.post(USRCFG_URL, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            rs = RelaySwitch(session, config)
-            await rs.async_switch_on(state, 0)
-            await rs.async_switch_off(state, 0)
-            await rs.async_set_auto_mode(state, 0)
-
-
-async def test_dosage_control_class(config: ConfigObject) -> None:
-    cmd_url_chlorine = f"{BASE_URL}/Command.htm?MAN_DOSAGE=0,60"
-    cmd_url_ph_minus = f"{BASE_URL}/Command.htm?MAN_DOSAGE=1,30"
-    cmd_url_ph_plus = f"{BASE_URL}/Command.htm?MAN_DOSAGE=2,45"
-    with aioresponses() as m:
-        m.get(cmd_url_chlorine, body="ok", status=200)
-        m.get(cmd_url_ph_minus, body="ok", status=200)
-        m.get(cmd_url_ph_plus, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            dc = DosageControl(session, config)
-            await dc.async_chlorine_dosage(60)
-            await dc.async_ph_minus_dosage(30)
-            await dc.async_ph_plus_dosage(45)
-
-
-async def test_dmx_control_class(config: ConfigObject, get_dmx_csv: str) -> None:
-    dmx = GetDmxData(get_dmx_csv)
-    with aioresponses() as m:
-        m.get(GET_DMX_URL, body=SIMPLE_DMX_CSV, status=200)
-        m.get(GET_DMX_URL, body=SIMPLE_DMX_CSV, status=200)
-        m.post(USRCFG_URL, body="ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            dc = DmxControl(session, config)
-            raw = await dc.async_get_raw_dmx()
-            parsed = await dc.async_get_dmx()
-            await dc.async_set(dmx)
-    assert raw == SIMPLE_DMX_CSV
-    assert isinstance(parsed, GetDmxData)
-
-
-async def test_digital_input_control_class(config: ConfigObject) -> None:
-    with aioresponses() as m:
-        m.post(USRCFG_URL, body="press-ok", status=200)
-        m.post(USRCFG_URL, body="release-ok", status=200)
-        async with aiohttp.ClientSession() as session:
-            dic = DigitalInputControl(session, config)
-            result = await dic.async_trigger(2, hold_seconds=0)
-    posts = _usrcfg_posts(m)
-    assert [p.kwargs["data"] for p in posts] == ["IO=4&WEBIO=1", "IO=0&WEBIO=1"]
-    assert result == "release-ok"
-
-
-# ---------------------------------------------------------------------------
-# Exception hierarchy
-# ---------------------------------------------------------------------------
-
-
-def test_exception_hierarchy() -> None:
-    assert issubclass(BadCredentialsException, ProconipApiException)
-    assert issubclass(BadStatusCodeException, ProconipApiException)
-    assert issubclass(TimeoutException, ProconipApiException)