feat(update): Firmware-Update aus dem Ordner mit Einmal-URLs und WLAN-Sicherung

tests/conftest.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Generator
 from copy import deepcopy
+from pathlib import Path
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -101,3 +102,11 @@ def mock_setup_entry() -> Generator[AsyncMock]:
     """Flow tests must not set the entry up for real."""
     with patch("custom_components.ninlight.async_setup_entry", return_value=True) as mock:
         yield mock
+
+
+@pytest.fixture(autouse=True)
+def firmware_dir(tmp_path: Path) -> Generator[Path]:
+    """Every Home Assistant test gets its own, initially empty firmware folder."""
+    directory = tmp_path / "ninlight_firmware"
+    with patch("custom_components.ninlight.shared.firmware_directory", return_value=directory):
+        yield directory

tests/test_diagnostics.py

@@ -10,6 +10,8 @@ from pytest_homeassistant_custom_component.components.diagnostics import (
 )
 from pytest_homeassistant_custom_component.typing import ClientSessionGenerator
 
+from custom_components.ninlight.shared import DATA_SHARED, async_scan_catalog
+from tests_unit.images import build_image
 from tests_unit.samples import HOST_RGB, MAC_RGB, TOKEN
 
 
@@ -22,3 +24,15 @@ async def test_diagnostics_redacts_secrets(
         assert secret not in text, secret
     assert diagnostics["info"]["device_type"] == "gu10_rgb"
     assert diagnostics["state"]["brightness"] == 37
+
+
+async def test_diagnostics_lists_matching_firmware(
+    hass: HomeAssistant, hass_client: ClientSessionGenerator, init_integration, firmware_dir
+) -> None:
+    (firmware_dir / "rgb.img").write_bytes(build_image("gu10_rgb", "0.3.8-47-g71a57"))
+    (firmware_dir / "cw.img").write_bytes(build_image("gu10_cw", "0.3.8-47-g71a57"))
+    await async_scan_catalog(hass, hass.data[DATA_SHARED])
+    diagnostics = await get_diagnostics_for_config_entry(hass, hass_client, init_integration)
+    assert diagnostics["firmware_images"] == [
+        {"file": "rgb.img", "device_type": "gu10_rgb", "version": "0.3.8-47-g71a57"}
+    ]

tests/test_http.py

@@ -0,0 +1,84 @@
+"""One-time firmware URLs and the address lamps use to reach Home Assistant."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from homeassistant.core import HomeAssistant
+from homeassistant.core_config import async_process_ha_core_config
+from homeassistant.exceptions import HomeAssistantError
+import pytest
+from pytest_homeassistant_custom_component.typing import ClientSessionGenerator
+
+from custom_components.ninlight.const import CONF_LAMP_BASE_URL
+from custom_components.ninlight.http import OtaRegistry, lamp_base_url
+from custom_components.ninlight.shared import DATA_SHARED
+from tests_unit.images import build_image
+
+
+def test_registry_keys_are_unique_and_43_characters() -> None:
+    registry = OtaRegistry()
+    keys = {registry.create(Path("/tmp/a.img")) for _ in range(50)}
+    assert len(keys) == 50
+    assert all(len(key) == 43 for key in keys)
+    assert len(registry) == 50
+
+
+async def test_view_serves_only_registered_keys(
+    hass: HomeAssistant,
+    hass_client_no_auth: ClientSessionGenerator,
+    init_integration,
+    firmware_dir: Path,
+) -> None:
+    path = firmware_dir / "a.img"
+    path.write_bytes(build_image())
+    registry = hass.data[DATA_SHARED].registry
+    other = firmware_dir / "b.img"
+    other.write_bytes(build_image(version="0.3.9-rc1"))
+    key = registry.create(path)
+    client = await hass_client_no_auth()
+
+    response = await client.get(f"/api/ninlight/firmware/{key}")
+    assert response.status == 200
+    assert await response.read() == path.read_bytes()
+
+    assert (await client.get("/api/ninlight/firmware/" + "x" * 43)).status == 404
+    registry.revoke(key)
+    assert (await client.get(f"/api/ninlight/firmware/{key}")).status == 404
+
+
+async def test_view_returns_404_when_file_vanished(
+    hass: HomeAssistant,
+    hass_client_no_auth: ClientSessionGenerator,
+    init_integration,
+    firmware_dir: Path,
+) -> None:
+    key = hass.data[DATA_SHARED].registry.create(firmware_dir / "gone.img")
+    client = await hass_client_no_auth()
+    assert (await client.get(f"/api/ninlight/firmware/{key}")).status == 404
+
+
+async def test_base_url_prefers_option(hass: HomeAssistant) -> None:
+    await async_process_ha_core_config(hass, {"internal_url": "http://192.168.1.60:8123"})
+    assert (
+        lamp_base_url(hass, {CONF_LAMP_BASE_URL: "http://192.168.1.50:8123"})
+        == "http://192.168.1.50:8123"
+    )
+
+
+async def test_base_url_falls_back_to_internal_http_url(hass: HomeAssistant) -> None:
+    await async_process_ha_core_config(hass, {"internal_url": "http://192.168.1.60:8123"})
+    assert lamp_base_url(hass, {}) == "http://192.168.1.60:8123"
+
+
+async def test_base_url_rejects_https(hass: HomeAssistant) -> None:
+    await async_process_ha_core_config(hass, {"internal_url": "https://ha.local:8123"})
+    with pytest.raises(HomeAssistantError) as raised:
+        lamp_base_url(hass, {})
+    assert raised.value.translation_key == "no_http_url"
+
+
+async def test_base_url_without_any_url(hass: HomeAssistant) -> None:
+    with pytest.raises(HomeAssistantError) as raised:
+        lamp_base_url(hass, {})
+    assert raised.value.translation_key == "no_http_url"

tests/test_update.py

@@ -0,0 +1,339 @@
+"""Firmware update entity: offer, Wi-Fi guard, install flow."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock
+from urllib.parse import urlsplit
+
+from homeassistant.components.update import (
+    ATTR_IN_PROGRESS,
+    ATTR_INSTALLED_VERSION,
+    ATTR_LATEST_VERSION,
+    SERVICE_INSTALL,
+)
+from homeassistant.components.update import (
+    DOMAIN as UPDATE_DOMAIN,
+)
+from homeassistant.const import ATTR_ENTITY_ID, CONF_HOST, CONF_TOKEN, STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.core_config import async_process_ha_core_config
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import issue_registry as ir
+import pytest
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+from pytest_homeassistant_custom_component.typing import ClientSessionGenerator
+
+from custom_components.ninlight import update as update_module
+from custom_components.ninlight.api import NinlightBusyError, NinlightConnectionError
+from custom_components.ninlight.const import CONF_LAMP_BASE_URL, DOMAIN
+from custom_components.ninlight.shared import DATA_SHARED, async_scan_catalog
+from custom_components.ninlight.update import depends_on_compiled_wifi
+from tests.helpers import entity_id_for
+from tests_unit.images import CONTENT_WITH_SSID, CONTENT_WITHOUT_SSID, build_image
+from tests_unit.samples import HOST_RGB, MAC_RGB, SETTINGS_COMPILED, SETTINGS_STORED, TOKEN
+
+BASE = "http://192.168.1.50:8123"
+INSTALLED = "0.3.8-36-gca9bb"
+NEWER = "0.3.8-47-g71a57"
+NEWEST = "0.3.9-rc1"
+
+
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    return MockConfigEntry(
+        domain=DOMAIN,
+        title="Klyqa GU10 RGB CW/WW 06b8",
+        unique_id=MAC_RGB,
+        data={CONF_HOST: HOST_RGB, CONF_TOKEN: TOKEN},
+        options={CONF_LAMP_BASE_URL: BASE},
+    )
+
+
+@pytest.fixture(autouse=True)
+def fast_polling(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(update_module, "OTA_POLL_INTERVAL_S", 0)
+
+
+def put(directory: Path, name: str, **kwargs: Any) -> Path:
+    path = directory / name
+    path.write_bytes(build_image(**kwargs))
+    return path
+
+
+async def rescan(hass: HomeAssistant) -> None:
+    await async_scan_catalog(hass, hass.data[DATA_SHARED])
+    await hass.async_block_till_done()
+
+
+def wifi_issue(hass: HomeAssistant, entry: MockConfigEntry) -> ir.IssueEntry | None:
+    return ir.async_get(hass).async_get_issue(DOMAIN, f"wifi_guard_{entry.entry_id}")
+
+
+async def install(hass: HomeAssistant) -> None:
+    await hass.services.async_call(
+        UPDATE_DOMAIN,
+        SERVICE_INSTALL,
+        {ATTR_ENTITY_ID: entity_id_for(hass, "update", "firmware")},
+        blocking=True,
+    )
+
+
+def test_only_stored_wifi_is_independent() -> None:
+    assert not depends_on_compiled_wifi(SETTINGS_STORED)
+    assert depends_on_compiled_wifi(SETTINGS_COMPILED)
+    assert depends_on_compiled_wifi({"wifi": {"ssid": ""}})
+    assert depends_on_compiled_wifi({"wifi": {"source": "flash"}})
+    assert depends_on_compiled_wifi({})
+
+
+async def test_no_images_no_update(hass: HomeAssistant, init_integration) -> None:
+    state = hass.states.get(entity_id_for(hass, "update", "firmware"))
+    assert state.state == STATE_OFF
+    assert state.attributes[ATTR_INSTALLED_VERSION] == INSTALLED
+    assert state.attributes[ATTR_LATEST_VERSION] == INSTALLED
+
+
+async def test_newer_image_with_credentials_is_offered(
+    hass: HomeAssistant, init_integration, firmware_dir: Path
+) -> None:
+    put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    state = hass.states.get(entity_id_for(hass, "update", "firmware"))
+    assert state.state == STATE_ON
+    assert state.attributes[ATTR_LATEST_VERSION] == NEWER
+    assert wifi_issue(hass, init_integration) is None
+
+
+@pytest.mark.parametrize(
+    "image",
+    [
+        {
+            "device_type": "gu10_cw",
+            "version": "0.4.0",
+        },  # other type that only differs in the suffix
+        {"device_type": "gu10_rgb", "version": "0.3.8-36-gffff0"},  # same version, other hash
+        {"device_type": "gu10_rgb", "version": "0.3.8"},  # older
+    ],
+)
+async def test_unsuitable_images_are_not_offered(
+    hass: HomeAssistant, init_integration, firmware_dir: Path, image: dict[str, str]
+) -> None:
+    put(firmware_dir, "a.img", content=CONTENT_WITH_SSID, **image)
+    await rescan(hass)
+    assert hass.states.get(entity_id_for(hass, "update", "firmware")).state == STATE_OFF
+
+
+async def test_wifi_guard_blocks_image_without_credentials(
+    hass: HomeAssistant, init_integration, firmware_dir: Path
+) -> None:
+    nocreds = put(firmware_dir, "nocreds.img", version=NEWEST, content=CONTENT_WITHOUT_SSID)
+    await rescan(hass)
+    entity_id = entity_id_for(hass, "update", "firmware")
+    assert hass.states.get(entity_id).state == STATE_OFF
+    issue = wifi_issue(hass, init_integration)
+    assert issue is not None
+    assert issue.translation_placeholders == {
+        "name": "Klyqa GU10 RGB CW/WW 06b8",
+        "version": NEWEST,
+        "device_type": "gu10_rgb",
+        "ssid": "ninIOT",
+    }
+
+    put(firmware_dir, "creds.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    assert hass.states.get(entity_id).attributes[ATTR_LATEST_VERSION] == NEWER
+    assert wifi_issue(hass, init_integration) is not None  # the newer, blocked one is still there
+
+    nocreds.unlink()
+    await rescan(hass)
+    assert hass.states.get(entity_id).attributes[ATTR_LATEST_VERSION] == NEWER
+    assert wifi_issue(hass, init_integration) is None
+
+
+async def test_lamp_with_stored_wifi_gets_image_without_credentials(
+    hass: HomeAssistant, init_integration, firmware_dir: Path, lamp_settings: dict[str, Any]
+) -> None:
+    lamp_settings.clear()
+    lamp_settings.update(SETTINGS_STORED)
+    put(firmware_dir, "nocreds.img", version=NEWEST, content=CONTENT_WITHOUT_SSID)
+    await rescan(hass)
+    assert (
+        hass.states.get(entity_id_for(hass, "update", "firmware")).attributes[ATTR_LATEST_VERSION]
+        == NEWEST
+    )
+    assert wifi_issue(hass, init_integration) is None
+
+
+async def test_lamp_without_ssid_gets_nothing(
+    hass: HomeAssistant, init_integration, firmware_dir: Path, lamp_info: dict[str, Any]
+) -> None:
+    lamp_info["wifi"]["ssid"] = ""
+    await init_integration.runtime_data.async_refresh()
+    put(firmware_dir, "creds.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    assert hass.states.get(entity_id_for(hass, "update", "firmware")).state == STATE_OFF
+
+
+async def test_unreadable_settings_keep_previous_offer(
+    hass: HomeAssistant, init_integration, firmware_dir: Path, mock_client: MagicMock
+) -> None:
+    mock_client.get_settings.side_effect = NinlightConnectionError("down")
+    put(firmware_dir, "creds.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    assert hass.states.get(entity_id_for(hass, "update", "firmware")).state == STATE_OFF
+
+
+async def test_install_serves_image_once_and_waits_for_new_version(
+    hass: HomeAssistant,
+    hass_client_no_auth: ClientSessionGenerator,
+    init_integration,
+    mock_client: MagicMock,
+    lamp_info: dict[str, Any],
+    firmware_dir: Path,
+) -> None:
+    path = put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    client = await hass_client_no_auth()
+    served: dict[str, Any] = {}
+
+    async def lamp_downloads(url: str) -> None:
+        served["url"] = url
+        response = await client.get(urlsplit(url).path)
+        served["status"] = response.status
+        served["body"] = await response.read()
+        served["ota_flag"] = init_integration.runtime_data.ota_in_progress
+        lamp_info["fw_version"] = NEWER
+        lamp_info["uptime"] = 4
+
+    mock_client.fw_update.side_effect = lamp_downloads
+    await install(hass)
+    await hass.async_block_till_done()
+
+    assert served["url"].startswith(f"{BASE}/api/ninlight/firmware/")
+    assert (served["status"], served["body"]) == (200, path.read_bytes())
+    assert served["ota_flag"] is True
+    assert (await client.get(urlsplit(served["url"]).path)).status == 404
+    assert len(hass.data[DATA_SHARED].registry) == 0
+    state = hass.states.get(entity_id_for(hass, "update", "firmware"))
+    assert state.attributes[ATTR_INSTALLED_VERSION] == NEWER
+    assert state.attributes[ATTR_IN_PROGRESS] is False
+    assert state.state == STATE_OFF
+    assert init_integration.runtime_data.ota_in_progress is False
+
+
+@pytest.mark.parametrize(
+    ("lamp_reaction", "key", "reason_part"),
+    [
+        ({"last_ota_error": "hash"}, "update_failed", "hash"),
+        ({"uptime": 3}, "update_failed", INSTALLED),  # rebooted, still the old firmware
+    ],
+)
+async def test_install_reports_lamp_failures(
+    hass: HomeAssistant,
+    init_integration,
+    mock_client: MagicMock,
+    lamp_info: dict[str, Any],
+    firmware_dir: Path,
+    lamp_reaction: dict[str, Any],
+    key: str,
+    reason_part: str,
+) -> None:
+    put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+
+    async def lamp_fails(url: str) -> None:
+        lamp_info.update(lamp_reaction)
+
+    mock_client.fw_update.side_effect = lamp_fails
+    with pytest.raises(HomeAssistantError) as raised:
+        await install(hass)
+    assert raised.value.translation_key == key
+    assert reason_part in raised.value.translation_placeholders["reason"]
+    assert len(hass.data[DATA_SHARED].registry) == 0
+    assert init_integration.runtime_data.ota_in_progress is False
+
+
+async def test_install_busy_lamp(
+    hass: HomeAssistant, init_integration, mock_client: MagicMock, firmware_dir: Path
+) -> None:
+    put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    mock_client.fw_update.side_effect = NinlightBusyError(409, "an update is already running")
+    with pytest.raises(HomeAssistantError) as raised:
+        await install(hass)
+    assert raised.value.translation_key == "update_busy"
+    assert len(hass.data[DATA_SHARED].registry) == 0
+
+
+async def test_install_times_out(
+    hass: HomeAssistant, init_integration, firmware_dir: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(update_module, "OTA_TIMEOUT_S", 0)
+    put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    with pytest.raises(HomeAssistantError) as raised:
+        await install(hass)
+    assert raised.value.translation_key == "update_timeout"
+
+
+async def test_install_needs_http_address(
+    hass: HomeAssistant, mock_client: MagicMock, firmware_dir: Path
+) -> None:
+    await async_process_ha_core_config(hass, {"internal_url": "https://ha.local:8123"})
+    entry = MockConfigEntry(
+        domain=DOMAIN, unique_id=MAC_RGB, data={CONF_HOST: HOST_RGB, CONF_TOKEN: TOKEN}
+    )
+    entry.add_to_hass(hass)
+    assert await hass.config_entries.async_setup(entry.entry_id)
+    put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    with pytest.raises(HomeAssistantError) as raised:
+        await install(hass)
+    assert raised.value.translation_key == "no_http_url"
+    mock_client.fw_update.assert_not_awaited()
+
+
+async def test_install_rechecks_wifi_right_before_sending(
+    hass: HomeAssistant,
+    init_integration,
+    mock_client: MagicMock,
+    firmware_dir: Path,
+    lamp_settings: dict[str, Any],
+) -> None:
+    lamp_settings.clear()
+    lamp_settings.update(SETTINGS_STORED)
+    put(firmware_dir, "nocreds.img", version=NEWEST, content=CONTENT_WITHOUT_SSID)
+    await rescan(hass)
+    assert hass.states.get(entity_id_for(hass, "update", "firmware")).state == STATE_ON
+
+    lamp_settings["wifi"]["source"] = "compiled"  # the lamp forgot its stored Wi-Fi meanwhile
+    with pytest.raises(HomeAssistantError) as raised:
+        await install(hass)
+    assert raised.value.translation_key == "wifi_guard"
+    assert raised.value.translation_placeholders == {"ssid": "ninIOT"}
+    mock_client.fw_update.assert_not_awaited()
+
+
+async def test_install_rejects_changed_file(
+    hass: HomeAssistant, init_integration, mock_client: MagicMock, firmware_dir: Path
+) -> None:
+    path = put(firmware_dir, "a.img", version=NEWER, content=CONTENT_WITH_SSID)
+    await rescan(hass)
+    path.write_bytes(build_image(version=NEWEST, content=CONTENT_WITH_SSID))
+    with pytest.raises(HomeAssistantError) as raised:
+        await install(hass)
+    assert raised.value.translation_key == "image_invalid"
+    mock_client.fw_update.assert_not_awaited()
+
+
+async def test_removing_the_entry_clears_the_wifi_issue(
+    hass: HomeAssistant, init_integration, firmware_dir: Path
+) -> None:
+    put(firmware_dir, "nocreds.img", version=NEWEST, content=CONTENT_WITHOUT_SSID)
+    await rescan(hass)
+    assert wifi_issue(hass, init_integration) is not None
+    assert await hass.config_entries.async_remove(init_integration.entry_id)
+    await hass.async_block_till_done()
+    assert wifi_issue(hass, init_integration) is None