python-openevse-http 0.4.1__tar.gz → 0.4.3__tar.gz

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/.github/workflows/autolabeler.yml

@@ -32,7 +32,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/.github/workflows/links.yml

@@ -15,7 +15,7 @@ jobs:
   linkChecker:
     runs-on: ubuntu-latest
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/.github/workflows/publish-to-pypi.yml

@@ -21,7 +21,7 @@ jobs:
       contents: read
       id-token: write
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 
@@ -31,7 +31,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@1edb52594c857e2b5b13128931090f0640537287  # v5.3.0
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b  # v8.1.0
         with:
           enable-cache: true
           version: "0.10.9"
@@ -43,4 +43,4 @@ jobs:
         run: uv build
 
       - name: Publish release to PyPI
-        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  # v1.12.4
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b  # v1.14.0

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/.github/workflows/release-drafter.yml

@@ -13,7 +13,7 @@ jobs:
   update_release_draft:
     runs-on: ubuntu-latest
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/.github/workflows/test.yml

@@ -18,7 +18,7 @@ jobs:
   prek:
     runs-on: ubuntu-latest
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 
@@ -41,7 +41,7 @@ jobs:
           - "3.14"
 
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 
@@ -69,7 +69,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: build
     steps:
-      - uses: step-security/harden-runner@fe104658747b27e96e4f7e80cd0a94068e53901d  # v2.16.1
+      - uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411  # v2.19.4
         with:
           egress-policy: audit
 

{python_openevse_http-0.4.1/python_openevse_http.egg-info → python_openevse_http-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.4.1
+Version: 0.4.3
 Summary: Python wrapper for OpenEVSE HTTP API
 Home-page: https://github.com/firstof9/python-openevse-http
 Download-URL: https://github.com/firstof9/python-openevse-http

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/openevsehttp/client.py

@@ -183,12 +183,12 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             return (False, "")
         return (value["cmd"], value["ret"])
 
-    async def update(self) -> None:
+    async def update(self, force_status: bool = False) -> None:
         """Update the values."""
         # TODO: add addiontal endpoints to update
         urls = [f"{self.url}config"]
 
-        if not self._ws_listening:
+        if not self._ws_listening or force_status or self.ota_update:
             urls = [f"{self.url}status", f"{self.url}config"]
 
         for url in urls:
@@ -196,7 +196,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             response = await self.process_request(url, method="get")
             if "/status" in url:
                 if isinstance(response, Mapping) and "error" not in response:
-                    self._status = dict(response)
+                    self._status.update(dict(response))
                     _LOGGER.debug("Status update: %s", self._status)
                 elif isinstance(response, Mapping):
                     _LOGGER.warning(

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/openevsehttp/commands.py

@@ -39,13 +39,27 @@ class CommandsMixin:
     async def send_command(self, command: str) -> tuple:
         raise NotImplementedError
 
-    async def update(self) -> None:
+    async def update(self, force_status: bool = False) -> None:
         raise NotImplementedError
 
     def _normalize_response(self, response: Any) -> dict[str, Any] | list[Any]:
         """Normalize response to a dict or list."""
         raise NotImplementedError
 
+    def _flag_ota_if_started(self, response: Any) -> None:
+        """Flag OTA as active if response indicates firmware update has started."""
+        normalized = self._normalize_response(response)
+        if isinstance(normalized, dict) and (
+            normalized.get("msg") == "started"
+            or normalized.get("msg") in SUCCESS_ANSWERS
+        ):
+            _LOGGER.debug("Firmware update started, setting ota_update flag.")
+            self._status["ota_update"] = 1
+        else:
+            _LOGGER.debug(
+                "Firmware update response did not indicate start: %s", normalized
+            )
+
     async def get_schedule(self) -> Mapping[str, Any] | list[Any]:
         """Return the current schedule."""
         url = f"{self.url}schedule"
@@ -122,7 +136,12 @@ class CommandsMixin:
         time_limit: int | None = None,
         auto_release: bool | None = None,
     ) -> Any:
-        """Set the manual override status."""
+        """Set the manual override status.
+
+        Fetches the current override payload first and merges existing values
+        into the request payload. This prevents the firmware from clearing/resetting
+        previously configured properties that are not passed in the function call.
+        """
         if not self._version_check("4.0.1"):
             _LOGGER.debug("Feature not supported for older firmware.")
             raise UnsupportedFeature
@@ -140,6 +159,18 @@ class CommandsMixin:
             raise ValueError
 
         data: dict[str, Any] = {}
+        if isinstance(response, Mapping):
+            for key in (
+                "state",
+                "charge_current",
+                "max_current",
+                "energy_limit",
+                "time_limit",
+                "auto_release",
+            ):
+                if key in response:
+                    data[key] = response[key]
+
         if auto_release is not None:
             data["auto_release"] = auto_release
 
@@ -372,6 +403,7 @@ class CommandsMixin:
                 url = f"{base_url}ESP32_WiFi_V4.x/releases/latest"
             else:
                 url = f"{base_url}ESP8266_WiFi_v2.x/releases/latest"
+            _LOGGER.debug("Firmware check URL: %s", url)
         except AwesomeVersionCompareException:
             _LOGGER.debug("Non-semver firmware version detected.")
             return None
@@ -403,6 +435,7 @@ class CommandsMixin:
             method,
         )
         async with http_method(url) as resp:
+            _LOGGER.debug("Firmware check response status: %d", resp.status)
             if resp.status != 200:
                 return None
             message = await resp.text()
@@ -413,19 +446,51 @@ class CommandsMixin:
                 return None
 
             if not isinstance(message, dict):
+                _LOGGER.debug(
+                    "Invalid JSON response type from GitHub: %s", type(message)
+                )
                 return None
 
+            _LOGGER.debug(
+                "GitHub release metadata successfully fetched for version: %s",
+                message.get("tag_name"),
+            )
+
             # Match browser_download_url based on buildenv
             download_url = None
             buildenv = self._config.get("buildenv")
             assets = message.get("assets", [])
 
-            if buildenv and assets:
+            if not buildenv:
+                _LOGGER.debug(
+                    "Cannot resolve firmware asset: missing buildenv in config."
+                )
+                assets = []
+            elif not isinstance(assets, list):
+                _LOGGER.debug("Invalid GitHub assets payload: %r", assets)
+                assets = []
+            else:
+                _LOGGER.debug("Matching buildenv '%s' against assets", buildenv)
                 target_filename = f"{buildenv}.bin"
                 for asset in assets:
+                    if not isinstance(asset, Mapping):
+                        continue
                     if asset.get("name") == target_filename:
                         download_url = asset.get("browser_download_url")
+                        _LOGGER.debug("Found matching firmware asset: %s", download_url)
                         break
+            if buildenv and not download_url:
+                _LOGGER.debug(
+                    "Could not find asset matching target filename '%s.bin' in assets: %s",
+                    buildenv,
+                    [
+                        asset.get("name")
+                        for asset in assets
+                        if isinstance(asset, Mapping)
+                    ]
+                    if assets
+                    else "None",
+                )
 
             return {
                 "latest_version": message.get("tag_name"),
@@ -452,10 +517,16 @@ class CommandsMixin:
             raise UnsupportedFeature
 
         if firmware_bytes is not None and firmware_url is not None:
+            _LOGGER.error("Cannot specify both firmware_bytes and firmware_url")
             raise ValueError("Cannot specify both firmware_bytes and firmware_url")
 
+        if firmware_bytes is not None and len(firmware_bytes) == 0:
+            _LOGGER.error("Empty firmware bytes provided")
+            raise ValueError("Empty firmware bytes provided")
+
         if firmware_url is not None:
             if not isinstance(firmware_url, str) or not firmware_url.strip():
+                _LOGGER.error("Invalid firmware_url: %s", firmware_url)
                 raise ValueError("Invalid firmware_url")
 
         url = f"{self.url}update"
@@ -473,12 +544,23 @@ class CommandsMixin:
                 "Uploading firmware binary to %s (%d bytes)", url, len(firmware_bytes)
             )
             # Rapi is mapped to http request's data kwarg in process_request
-            return await self.process_request(url=url, method="post", rapi=form_data)
+            response = await self.process_request(
+                url=url, method="post", rapi=form_data
+            )
+            _LOGGER.debug("Firmware upload request completed. Response: %s", response)
+            self._flag_ota_if_started(response)
+            return response
 
         # 2. Resolve URL from GitHub if not specified
         if firmware_url is None:
+            _LOGGER.debug(
+                "No firmware URL provided. Resolving latest matching firmware from GitHub."
+            )
             check_result = await self.firmware_check()
             if not check_result or not check_result.get("browser_download_url"):
+                _LOGGER.error(
+                    "Could not resolve latest firmware download URL from GitHub."
+                )
                 raise RuntimeError(
                     "Could not resolve latest firmware download URL from GitHub."
                 )
@@ -489,7 +571,10 @@ class CommandsMixin:
         _LOGGER.debug(
             "Requesting OpenEVSE to download and update from: %s", firmware_url
         )
-        return await self.process_request(url=url, method="post", data=data)
+        response = await self.process_request(url=url, method="post", data=data)
+        _LOGGER.debug("Firmware update request completed. Response: %s", response)
+        self._flag_ota_if_started(response)
+        return response
 
     async def set_led_brightness(self, level: int) -> None:
         """Set LED brightness level."""

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/pyproject.toml

@@ -32,7 +32,7 @@ ignore = [
 max-complexity = 18
 
 [build-system]
-requires = ["setuptools>=61.0.0", "setuptools-scm>=8.0"]
+requires = ["setuptools>=82.0.1", "setuptools-scm>=10.0.5"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3/python_openevse_http.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.4.1
+Version: 0.4.3
 Summary: Python wrapper for OpenEVSE HTTP API
 Home-page: https://github.com/firstof9/python-openevse-http
 Download-URL: https://github.com/firstof9/python-openevse-http

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/requirements_test.txt

@@ -6,6 +6,5 @@ pytest-timeout==2.4.0
 pytest-asyncio
 requests_mock
 aiohttp
-aioresponses
 tox==4.55.0
 freezegun

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/tests/conftest.py

@@ -1,9 +1,12 @@
 """Provide common pytest fixtures."""
 
 import json
+from typing import Any, NamedTuple
+from unittest.mock import patch
 
+import aiohttp
 import pytest
-from aioresponses import aioresponses
+from multidict import CIMultiDict
 
 import openevsehttp as main
 from tests.common import load_fixture
@@ -226,10 +229,180 @@ def test_charger_v4_0(mock_aioclient):
     return main.OpenEVSE(TEST_TLD)
 
 
+class MockResponse:
+    def __init__(
+        self,
+        method: str,
+        url: str,
+        status: int,
+        body: Any,
+        headers: dict | None,
+        content_type: str,
+    ):
+        self.method = method
+        self.url = url
+        self.status = status
+        self._body = body
+        self.headers = CIMultiDict(headers or {})
+        if content_type:
+            self.headers.setdefault("content-type", content_type)
+
+    async def text(self, encoding: str | None = None, errors: str = "strict") -> str:
+        if isinstance(self._body, bytes):
+            return self._body.decode(encoding or "utf-8", errors=errors)
+        if isinstance(self._body, str):
+            return self._body
+
+        return json.dumps(self._body)
+
+    async def read(self) -> bytes:
+        if isinstance(self._body, bytes):
+            return self._body
+        if isinstance(self._body, str):
+            return self._body.encode("utf-8")
+
+        return json.dumps(self._body).encode("utf-8")
+
+    async def json(self, *args, **kwargs) -> Any:
+        if isinstance(self._body, bytes):
+            return json.loads(self._body.decode("utf-8"))
+        if isinstance(self._body, str):
+            return json.loads(self._body)
+        return self._body
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+
+class RegisteredMock(NamedTuple):
+    method: str
+    url_pattern: Any
+    status: int
+    body: Any
+    exception: Any
+    repeat: bool
+    content_type: str
+    headers: dict | None
+
+
+class AiohttpClientMocker:
+    def __init__(self):
+        self.mocks = []
+        self.requests = []
+        self._patcher = None
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    def start(self):
+        self._patcher = patch.object(
+            aiohttp.ClientSession, "_request", new=self._request_mock
+        )
+        self._patcher.start()
+
+    def stop(self):
+        if self._patcher:
+            self._patcher.stop()
+
+    def add(
+        self,
+        method: str,
+        url: Any,
+        status: int = 200,
+        body: Any = "",
+        exception: Any = None,
+        repeat: bool = False,
+        content_type: str = "application/json",
+        headers: dict | None = None,
+    ):
+        self.mocks.append(
+            RegisteredMock(
+                method=method.upper(),
+                url_pattern=url,
+                status=status,
+                body=body,
+                exception=exception,
+                repeat=repeat,
+                content_type=content_type,
+                headers=headers,
+            )
+        )
+
+    def get(self, *args, **kwargs):
+        self.add("GET", *args, **kwargs)
+
+    def post(self, *args, **kwargs):
+        self.add("POST", *args, **kwargs)
+
+    def put(self, *args, **kwargs):
+        self.add("PUT", *args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        self.add("DELETE", *args, **kwargs)
+
+    def patch(self, *args, **kwargs):
+        self.add("PATCH", *args, **kwargs)
+
+    def head(self, *args, **kwargs):
+        self.add("HEAD", *args, **kwargs)
+
+    def options(self, *args, **kwargs):
+        self.add("OPTIONS", *args, **kwargs)
+
+    async def _request_mock(self, method: str, str_or_url: Any, **kwargs: Any):
+        url_str = str(str_or_url)
+        method_upper = method.upper()
+        self.requests.append((method_upper, url_str, kwargs))
+
+        matching_mock = None
+        matching_index = -1
+
+        for i, mock in enumerate(self.mocks):
+            if mock.method != method_upper:
+                continue
+            matched = False
+            if hasattr(mock.url_pattern, "match"):
+                if mock.url_pattern.match(url_str):
+                    matched = True
+            elif isinstance(mock.url_pattern, str):
+                if mock.url_pattern == url_str:
+                    matched = True
+
+            if matched:
+                matching_mock = mock
+                matching_index = i
+                break
+
+        if not matching_mock:
+            raise AssertionError(f"No mock registered for {method_upper} {url_str}")
+
+        if not matching_mock.repeat:
+            self.mocks.pop(matching_index)
+
+        if matching_mock.exception:
+            raise matching_mock.exception
+
+        return MockResponse(
+            method=method_upper,
+            url=url_str,
+            status=matching_mock.status,
+            body=matching_mock.body,
+            headers=matching_mock.headers,
+            content_type=matching_mock.content_type,
+        )
+
+
 @pytest.fixture
 def aioclient_mock():
     """Fixture to mock aioclient calls."""
-    with aioresponses() as mock_aiohttp:
+    with AiohttpClientMocker() as mock_aiohttp:
         mock_headers = {"content-type": "application/json"}
         mock_aiohttp.get(
             "ws://openevse.test.tld/ws",
@@ -244,5 +417,5 @@ def aioclient_mock():
 @pytest.fixture
 def mock_aioclient():
     """Fixture to mock aioclient calls."""
-    with aioresponses() as m:
+    with AiohttpClientMocker() as m:
         yield m

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/tests/test_client.py

@@ -117,6 +117,55 @@ async def test_get_status_auth_err(test_charger_auth_err):
         await test_charger_auth_err.update()
 
 
+async def test_update_force_status(mock_aioclient):
+    """Test force_status parameter when ws is listening."""
+    unique_host = "force-status.test.tld"
+    charger = OpenEVSE(unique_host)
+    url_status = f"http://{unique_host}/status"
+    url_config = f"http://{unique_host}/config"
+
+    mock_aioclient.get(
+        url_status,
+        status=200,
+        body='{"state": 2, "wifi_serial": "123"}',
+    )
+    mock_aioclient.get(
+        url_config,
+        status=200,
+        body='{"wifi_serial": "123", "version": "4.0.1"}',
+    )
+    charger._ws_listening = True
+    charger._status = {"transient_key": "preserved"}
+    await charger.update(force_status=True)
+    assert charger._status["state"] == 2
+    assert charger._status["transient_key"] == "preserved"
+
+
+async def test_update_ota_active(mock_aioclient):
+    """Test automatic status polling when ota_update is active."""
+    unique_host = "ota-active.test.tld"
+    charger = OpenEVSE(unique_host)
+    url_status = f"http://{unique_host}/status"
+    url_config = f"http://{unique_host}/config"
+
+    mock_aioclient.get(
+        url_status,
+        status=200,
+        body='{"state": 2, "ota_update": 1}',
+    )
+    mock_aioclient.get(
+        url_config,
+        status=200,
+        body='{"wifi_serial": "123", "version": "4.0.1"}',
+    )
+    charger._ws_listening = True
+    charger._status = {"ota_update": 1, "ota_progress": 50}
+    await charger.update()
+    assert charger._status["state"] == 2
+    assert charger._status["ota_progress"] == 50
+    assert charger.ota_update is True
+
+
 # ── send_command ──────────────────────────────────────────────────────
 
 

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/tests/test_commands.py

@@ -1060,6 +1060,9 @@ async def test_update_firmware_bytes(test_charger, mock_aioclient, caplog):
             "Uploading firmware binary to http://openevse.test.tld/update (14 bytes)"
             in caplog.text
         )
+        assert "Firmware upload request completed. Response: OK" in caplog.text
+        assert "Firmware update started, setting ota_update flag." in caplog.text
+        assert test_charger.ota_update is True
 
 
 async def test_update_firmware_url(test_charger, mock_aioclient, caplog):
@@ -1079,6 +1082,12 @@ async def test_update_firmware_url(test_charger, mock_aioclient, caplog):
             "Requesting OpenEVSE to download and update from: http://github.com/release.bin"
             in caplog.text
         )
+        assert (
+            "Firmware update request completed. Response: {'msg': 'started'}"
+            in caplog.text
+        )
+        assert "Firmware update started, setting ota_update flag." in caplog.text
+        assert test_charger.ota_update is True
 
 
 async def test_update_firmware_auto(test_charger, mock_aioclient, caplog):
@@ -1118,13 +1127,43 @@ async def test_update_firmware_auto(test_charger, mock_aioclient, caplog):
     with caplog.at_level(logging.DEBUG):
         response = await test_charger.update_firmware()
         assert response == {"msg": "started"}
+        assert (
+            "No firmware URL provided. Resolving latest matching firmware from GitHub."
+            in caplog.text
+        )
+        assert "Detected firmware: 4.1.7" in caplog.text
+        assert "Using version: 4.1.7" in caplog.text
+        assert (
+            "Firmware check URL: https://api.github.com/repos/OpenEVSE/ESP32_WiFi_V4.x/releases/latest"
+            in caplog.text
+        )
+        assert "Firmware check response status: 200" in caplog.text
+        assert (
+            "GitHub release metadata successfully fetched for version: v4.1.2"
+            in caplog.text
+        )
+        assert (
+            "Matching buildenv 'openevse_esp32-gateway' against assets" in caplog.text
+        )
+        assert (
+            "Found matching firmware asset: https://github.com/OpenEVSE/releases/download/v4.1.2/openevse_esp32-gateway.bin"
+            in caplog.text
+        )
         assert (
             "Requesting OpenEVSE to download and update from: https://github.com/OpenEVSE/releases/download/v4.1.2/openevse_esp32-gateway.bin"
             in caplog.text
         )
+        assert (
+            "Firmware update request completed. Response: {'msg': 'started'}"
+            in caplog.text
+        )
+        assert "Firmware update started, setting ota_update flag." in caplog.text
+        assert test_charger.ota_update is True
 
 
-async def test_update_firmware_auto_missing_buildenv(test_charger, mock_aioclient):
+async def test_update_firmware_auto_missing_buildenv(
+    test_charger, mock_aioclient, caplog
+):
     """Test update_firmware raises RuntimeError when buildenv asset is missing."""
     test_charger._config = {"version": "4.1.7", "buildenv": "openevse_esp32-gateway"}
 
@@ -1147,35 +1186,47 @@ async def test_update_firmware_auto_missing_buildenv(test_charger, mock_aioclien
         body=json.dumps(github_response),
     )
 
-    with pytest.raises(
-        RuntimeError,
-        match="Could not resolve latest firmware download URL from GitHub.",
-    ):
-        await test_charger.update_firmware()
+    with caplog.at_level(logging.DEBUG):
+        with pytest.raises(
+            RuntimeError,
+            match=r"Could not resolve latest firmware download URL from GitHub\.",
+        ):
+            await test_charger.update_firmware()
+        assert (
+            "Could not find asset matching target filename 'openevse_esp32-gateway.bin' in assets: ['other_env.bin']"
+            in caplog.text
+        )
+        assert (
+            "Could not resolve latest firmware download URL from GitHub." in caplog.text
+        )
 
 
-async def test_update_firmware_both_provided(test_charger):
+async def test_update_firmware_both_provided(test_charger, caplog):
     """Test update_firmware raises ValueError when both bytes and URL are provided."""
     test_charger._config["version"] = "4.1.7"
-    with pytest.raises(
-        ValueError, match="Cannot specify both firmware_bytes and firmware_url"
-    ):
-        await test_charger.update_firmware(
-            firmware_url="http://url", firmware_bytes=b"bytes"
-        )
+    with caplog.at_level(logging.DEBUG):
+        with pytest.raises(ValueError):
+            await test_charger.update_firmware(
+                firmware_url="http://url", firmware_bytes=b"bytes"
+            )
+        assert "Cannot specify both firmware_bytes and firmware_url" in caplog.text
 
 
-async def test_update_firmware_url_invalid(test_charger):
+async def test_update_firmware_url_invalid(test_charger, caplog):
     """Test update_firmware raises ValueError when firmware_url is empty or invalid type."""
     test_charger._config["version"] = "4.1.7"
-    with pytest.raises(ValueError, match="Invalid firmware_url"):
-        await test_charger.update_firmware(firmware_url="")
+    with caplog.at_level(logging.DEBUG):
+        with pytest.raises(ValueError):
+            await test_charger.update_firmware(firmware_url="")
+        assert "Invalid firmware_url: " in caplog.text
 
-    with pytest.raises(ValueError, match="Invalid firmware_url"):
-        await test_charger.update_firmware(firmware_url="   ")
+        with pytest.raises(ValueError):
+            await test_charger.update_firmware(firmware_url="   ")
+        assert "Invalid firmware_url:    " in caplog.text
 
-    with pytest.raises(ValueError, match="Invalid firmware_url"):
-        await test_charger.update_firmware(firmware_url=123)  # type: ignore
+        with pytest.raises(ValueError):
+            await test_charger.update_firmware(firmware_url=123)  # type: ignore
+        assert "Invalid firmware_url: 123" in caplog.text
 
 
 async def test_update_firmware_unsupported(test_charger):
@@ -1183,3 +1234,100 @@ async def test_update_firmware_unsupported(test_charger):
     test_charger._config["version"] = "4.1.2"
     with pytest.raises(UnsupportedFeature):
         await test_charger.update_firmware(firmware_url="http://url")
+
+
+async def test_update_firmware_error_response(test_charger, mock_aioclient, caplog):
+    """Test update_firmware doesn't set ota_update on error responses."""
+    test_charger._config["version"] = "4.1.7"
+    test_charger._status = {}
+    mock_aioclient.post(
+        "http://openevse.test.tld/update",
+        status=200,
+        body='{"msg":"error"}',
+    )
+    with caplog.at_level(logging.DEBUG):
+        response = await test_charger.update_firmware(
+            firmware_url="http://github.com/release.bin"
+        )
+        assert response == {"msg": "error"}
+        assert (
+            "Firmware update response did not indicate start: {'msg': 'error'}"
+            in caplog.text
+        )
+        assert test_charger.ota_update is False
+
+
+async def test_update_firmware_assets_invalid_type(
+    test_charger, mock_aioclient, caplog
+):
+    """Test update_firmware handles non-list assets gracefully."""
+    test_charger._config = {"version": "4.1.7", "buildenv": "openevse_esp32-gateway"}
+
+    # Mock GitHub releases but with assets as a dict (invalid type)
+    github_response = {
+        "tag_name": "v4.1.2",
+        "body": "release notes",
+        "html_url": "https://github.com/OpenEVSE/releases/v4.1.2",
+        "assets": {"name": "not_a_list"},
+    }
+
+    mock_aioclient.get(
+        "https://api.github.com/repos/OpenEVSE/ESP32_WiFi_V4.x/releases/latest",
+        status=200,
+        body=json.dumps(github_response),
+    )
+
+    with caplog.at_level(logging.DEBUG):
+        with pytest.raises(
+            RuntimeError,
+            match=r"Could not resolve latest firmware download URL from GitHub\.",
+        ):
+            await test_charger.update_firmware()
+        assert "Invalid GitHub assets payload: {'name': 'not_a_list'}" in caplog.text
+
+
+async def test_update_firmware_assets_invalid_item(
+    test_charger, mock_aioclient, caplog
+):
+    """Test update_firmware handles non-mapping assets gracefully."""
+    test_charger._config = {"version": "4.1.7", "buildenv": "openevse_esp32-gateway"}
+
+    # Mock GitHub releases with assets list containing non-mapping elements (e.g., a string)
+    github_response = {
+        "tag_name": "v4.1.2",
+        "body": "release notes",
+        "html_url": "https://github.com/OpenEVSE/releases/v4.1.2",
+        "assets": [
+            "invalid_asset_string",
+            {
+                "name": "openevse_esp32-gateway.bin",
+                "browser_download_url": "http://url",
+            },
+        ],
+    }
+
+    mock_aioclient.get(
+        "https://api.github.com/repos/OpenEVSE/ESP32_WiFi_V4.x/releases/latest",
+        status=200,
+        body=json.dumps(github_response),
+    )
+
+    mock_aioclient.post(
+        "http://openevse.test.tld/update",
+        status=200,
+        body='{"msg":"started"}',
+    )
+
+    with caplog.at_level(logging.DEBUG):
+        response = await test_charger.update_firmware()
+        assert response == {"msg": "started"}
+        assert "Found matching firmware asset: http://url" in caplog.text
+
+
+async def test_update_firmware_bytes_empty(test_charger, caplog):
+    """Test update_firmware raises ValueError when empty firmware_bytes are provided."""
+    test_charger._config["version"] = "4.1.7"
+    with caplog.at_level(logging.DEBUG):
+        with pytest.raises(ValueError):
+            await test_charger.update_firmware(firmware_bytes=b"")
+        assert "Empty firmware bytes provided" in caplog.text

{python_openevse_http-0.4.1 → python_openevse_http-0.4.3}/tests/test_managers.py

@@ -48,7 +48,15 @@ async def test_set_override(
     with caplog.at_level(logging.DEBUG):
         status = await test_charger.set_override("active")
         assert status == {"msg": "OK"}
-        assert "Override data: {'state': 'active'}" in caplog.text
+        assert mock_aioclient.requests[-1][2]["json"] == {
+            "state": "active",
+            "charge_current": 0,
+            "max_current": 0,
+            "energy_limit": 0,
+            "time_limit": 0,
+            "auto_release": True,
+        }
+        caplog.clear()
 
         mock_aioclient.post(
             TEST_URL_OVERRIDE,
@@ -56,44 +64,79 @@ async def test_set_override(
             body='{"msg": "OK"}',
         )
         status = await test_charger.set_override("active", 30)
-        assert "Override data: {'state': 'active', 'charge_current': 30}" in caplog.text
+        assert mock_aioclient.requests[-1][2]["json"] == {
+            "state": "active",
+            "charge_current": 30,
+            "max_current": 0,
+            "energy_limit": 0,
+            "time_limit": 0,
+            "auto_release": True,
+        }
+        caplog.clear()
+
         mock_aioclient.post(
             TEST_URL_OVERRIDE,
             status=200,
             body='{"msg": "OK"}',
         )
         status = await test_charger.set_override(charge_current=30)
-        assert "Override data: {'charge_current': 30}" in caplog.text
+        assert mock_aioclient.requests[-1][2]["json"] == {
+            "state": "active",
+            "charge_current": 30,
+            "max_current": 0,
+            "energy_limit": 0,
+            "time_limit": 0,
+            "auto_release": True,
+        }
+        caplog.clear()
+
         mock_aioclient.post(
             TEST_URL_OVERRIDE,
             status=200,
             body='{"msg": "OK"}',
         )
         status = await test_charger.set_override("active", 30, 32)
-        assert (
-            "Override data: {'state': 'active', 'charge_current': 30, 'max_current': 32}"
-            in caplog.text
-        )
+        assert mock_aioclient.requests[-1][2]["json"] == {
+            "state": "active",
+            "charge_current": 30,
+            "max_current": 32,
+            "energy_limit": 0,
+            "time_limit": 0,
+            "auto_release": True,
+        }
+        caplog.clear()
+
         mock_aioclient.post(
             TEST_URL_OVERRIDE,
             status=200,
             body='{"msg": "OK"}',
         )
         status = await test_charger.set_override("active", 30, 32, 2000)
-        assert (
-            "Override data: {'state': 'active', 'charge_current': 30, 'max_current': 32, 'energy_limit': 2000}"
-            in caplog.text
-        )
+        assert mock_aioclient.requests[-1][2]["json"] == {
+            "state": "active",
+            "charge_current": 30,
+            "max_current": 32,
+            "energy_limit": 2000,
+            "time_limit": 0,
+            "auto_release": True,
+        }
+        caplog.clear()
+
         mock_aioclient.post(
             TEST_URL_OVERRIDE,
             status=200,
             body='{"msg": "OK"}',
         )
         status = await test_charger.set_override("active", 30, 32, 2000, 5000)
-        assert (
-            "Override data: {'state': 'active', 'charge_current': 30, 'max_current': 32, 'energy_limit': 2000, 'time_limit': 5000}"
-            in caplog.text
-        )
+        assert mock_aioclient.requests[-1][2]["json"] == {
+            "state": "active",
+            "charge_current": 30,
+            "max_current": 32,
+            "energy_limit": 2000,
+            "time_limit": 5000,
+            "auto_release": True,
+        }
+        caplog.clear()
 
     with pytest.raises(ValueError):
         with caplog.at_level(logging.DEBUG):