From abd3466d197a860120679665315c9b8367230883 Mon Sep 17 00:00:00 2001 From: Klaas Schoute Date: Wed, 4 Dec 2024 00:35:50 +0100 Subject: [PATCH] Add powerfox integration (#131640) --- .strict-typing | 1 + CODEOWNERS | 2 + homeassistant/components/powerfox/__init__.py | 55 +++ .../components/powerfox/config_flow.py | 57 +++ homeassistant/components/powerfox/const.py | 11 + .../components/powerfox/coordinator.py | 40 ++ homeassistant/components/powerfox/entity.py | 32 ++ .../components/powerfox/manifest.json | 16 + .../components/powerfox/quality_scale.yaml | 92 +++++ homeassistant/components/powerfox/sensor.py | 147 +++++++ .../components/powerfox/strings.json | 46 +++ homeassistant/generated/config_flows.py | 1 + homeassistant/generated/integrations.json | 6 + homeassistant/generated/zeroconf.py | 4 + mypy.ini | 10 + requirements_all.txt | 3 + requirements_test_all.txt | 3 + tests/components/powerfox/__init__.py | 14 + tests/components/powerfox/conftest.py | 87 +++++ .../powerfox/snapshots/test_sensor.ambr | 358 ++++++++++++++++++ tests/components/powerfox/test_config_flow.py | 145 +++++++ tests/components/powerfox/test_init.py | 45 +++ tests/components/powerfox/test_sensor.py | 53 +++ 23 files changed, 1228 insertions(+) create mode 100644 homeassistant/components/powerfox/__init__.py create mode 100644 homeassistant/components/powerfox/config_flow.py create mode 100644 homeassistant/components/powerfox/const.py create mode 100644 homeassistant/components/powerfox/coordinator.py create mode 100644 homeassistant/components/powerfox/entity.py create mode 100644 homeassistant/components/powerfox/manifest.json create mode 100644 homeassistant/components/powerfox/quality_scale.yaml create mode 100644 homeassistant/components/powerfox/sensor.py create mode 100644 homeassistant/components/powerfox/strings.json create mode 100644 tests/components/powerfox/__init__.py create mode 100644 tests/components/powerfox/conftest.py create mode 100644 tests/components/powerfox/snapshots/test_sensor.ambr create mode 100644 tests/components/powerfox/test_config_flow.py create mode 100644 tests/components/powerfox/test_init.py create mode 100644 tests/components/powerfox/test_sensor.py diff --git a/.strict-typing b/.strict-typing index ed698c26ea0..42f35b52153 100644 --- a/.strict-typing +++ b/.strict-typing @@ -365,6 +365,7 @@ homeassistant.components.persistent_notification.* homeassistant.components.pi_hole.* homeassistant.components.ping.* homeassistant.components.plugwise.* +homeassistant.components.powerfox.* homeassistant.components.powerwall.* homeassistant.components.private_ble_device.* homeassistant.components.prometheus.* diff --git a/CODEOWNERS b/CODEOWNERS index 7755c3eb4ae..916ff63e696 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -1133,6 +1133,8 @@ build.json @home-assistant/supervisor /tests/components/point/ @fredrike /homeassistant/components/poolsense/ @haemishkyd /tests/components/poolsense/ @haemishkyd +/homeassistant/components/powerfox/ @klaasnicolaas +/tests/components/powerfox/ @klaasnicolaas /homeassistant/components/powerwall/ @bdraco @jrester @daniel-simpson /tests/components/powerwall/ @bdraco @jrester @daniel-simpson /homeassistant/components/private_ble_device/ @Jc2k diff --git a/homeassistant/components/powerfox/__init__.py b/homeassistant/components/powerfox/__init__.py new file mode 100644 index 00000000000..243f3aacc4f --- /dev/null +++ b/homeassistant/components/powerfox/__init__.py @@ -0,0 +1,55 @@ +"""The Powerfox integration.""" + +from __future__ import annotations + +import asyncio + +from powerfox import Powerfox, PowerfoxConnectionError + +from homeassistant.config_entries import ConfigEntry +from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, Platform +from homeassistant.core import HomeAssistant +from homeassistant.exceptions import ConfigEntryNotReady +from homeassistant.helpers.aiohttp_client import async_get_clientsession + +from .coordinator import PowerfoxDataUpdateCoordinator + +PLATFORMS: list[Platform] = [Platform.SENSOR] + +type PowerfoxConfigEntry = ConfigEntry[list[PowerfoxDataUpdateCoordinator]] + + +async def async_setup_entry(hass: HomeAssistant, entry: PowerfoxConfigEntry) -> bool: + """Set up Powerfox from a config entry.""" + client = Powerfox( + username=entry.data[CONF_EMAIL], + password=entry.data[CONF_PASSWORD], + session=async_get_clientsession(hass), + ) + + try: + devices = await client.all_devices() + except PowerfoxConnectionError as err: + await client.close() + raise ConfigEntryNotReady from err + + coordinators: list[PowerfoxDataUpdateCoordinator] = [ + PowerfoxDataUpdateCoordinator(hass, client, device) for device in devices + ] + + await asyncio.gather( + *[ + coordinator.async_config_entry_first_refresh() + for coordinator in coordinators + ] + ) + + entry.runtime_data = coordinators + + await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) + return True + + +async def async_unload_entry(hass: HomeAssistant, entry: PowerfoxConfigEntry) -> bool: + """Unload a config entry.""" + return await hass.config_entries.async_unload_platforms(entry, PLATFORMS) diff --git a/homeassistant/components/powerfox/config_flow.py b/homeassistant/components/powerfox/config_flow.py new file mode 100644 index 00000000000..b4eddeb6fce --- /dev/null +++ b/homeassistant/components/powerfox/config_flow.py @@ -0,0 +1,57 @@ +"""Config flow for Powerfox integration.""" + +from __future__ import annotations + +from typing import Any + +from powerfox import Powerfox, PowerfoxAuthenticationError, PowerfoxConnectionError +import voluptuous as vol + +from homeassistant.config_entries import ConfigFlow, ConfigFlowResult +from homeassistant.const import CONF_EMAIL, CONF_PASSWORD +from homeassistant.helpers.aiohttp_client import async_get_clientsession + +from .const import DOMAIN + +STEP_USER_DATA_SCHEMA = vol.Schema( + { + vol.Required(CONF_EMAIL): str, + vol.Required(CONF_PASSWORD): str, + } +) + + +class PowerfoxConfigFlow(ConfigFlow, domain=DOMAIN): + """Handle a config flow for Powerfox.""" + + async def async_step_user( + self, user_input: dict[str, Any] | None = None + ) -> ConfigFlowResult: + """Handle the initial step.""" + errors: dict[str, str] = {} + if user_input is not None: + self._async_abort_entries_match({CONF_EMAIL: user_input[CONF_EMAIL]}) + client = Powerfox( + username=user_input[CONF_EMAIL], + password=user_input[CONF_PASSWORD], + session=async_get_clientsession(self.hass), + ) + try: + await client.all_devices() + except PowerfoxAuthenticationError: + errors["base"] = "invalid_auth" + except PowerfoxConnectionError: + errors["base"] = "cannot_connect" + else: + return self.async_create_entry( + title=user_input[CONF_EMAIL], + data={ + CONF_EMAIL: user_input[CONF_EMAIL], + CONF_PASSWORD: user_input[CONF_PASSWORD], + }, + ) + return self.async_show_form( + step_id="user", + errors=errors, + data_schema=STEP_USER_DATA_SCHEMA, + ) diff --git a/homeassistant/components/powerfox/const.py b/homeassistant/components/powerfox/const.py new file mode 100644 index 00000000000..24f1310f970 --- /dev/null +++ b/homeassistant/components/powerfox/const.py @@ -0,0 +1,11 @@ +"""Constants for the Powerfox integration.""" + +from __future__ import annotations + +from datetime import timedelta +import logging +from typing import Final + +DOMAIN: Final = "powerfox" +LOGGER = logging.getLogger(__package__) +SCAN_INTERVAL = timedelta(minutes=5) diff --git a/homeassistant/components/powerfox/coordinator.py b/homeassistant/components/powerfox/coordinator.py new file mode 100644 index 00000000000..6fd9b2af189 --- /dev/null +++ b/homeassistant/components/powerfox/coordinator.py @@ -0,0 +1,40 @@ +"""Coordinator for Powerfox integration.""" + +from __future__ import annotations + +from powerfox import Device, Powerfox, PowerfoxConnectionError, Poweropti + +from homeassistant.config_entries import ConfigEntry +from homeassistant.core import HomeAssistant +from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed + +from .const import DOMAIN, LOGGER, SCAN_INTERVAL + + +class PowerfoxDataUpdateCoordinator(DataUpdateCoordinator[Poweropti]): + """Class to manage fetching Powerfox data from the API.""" + + config_entry: ConfigEntry + + def __init__( + self, + hass: HomeAssistant, + client: Powerfox, + device: Device, + ) -> None: + """Initialize global Powerfox data updater.""" + super().__init__( + hass, + LOGGER, + name=DOMAIN, + update_interval=SCAN_INTERVAL, + ) + self.client = client + self.device = device + + async def _async_update_data(self) -> Poweropti: + """Fetch data from Powerfox API.""" + try: + return await self.client.device(device_id=self.device.id) + except PowerfoxConnectionError as error: + raise UpdateFailed(error) from error diff --git a/homeassistant/components/powerfox/entity.py b/homeassistant/components/powerfox/entity.py new file mode 100644 index 00000000000..0ab7200ffe8 --- /dev/null +++ b/homeassistant/components/powerfox/entity.py @@ -0,0 +1,32 @@ +"""Generic entity for Powerfox.""" + +from __future__ import annotations + +from powerfox import Device + +from homeassistant.helpers.device_registry import DeviceInfo +from homeassistant.helpers.update_coordinator import CoordinatorEntity + +from .const import DOMAIN +from .coordinator import PowerfoxDataUpdateCoordinator + + +class PowerfoxEntity(CoordinatorEntity[PowerfoxDataUpdateCoordinator]): + """Base entity for Powerfox.""" + + _attr_has_entity_name = True + + def __init__( + self, + coordinator: PowerfoxDataUpdateCoordinator, + device: Device, + ) -> None: + """Initialize Powerfox entity.""" + super().__init__(coordinator) + self._attr_device_info = DeviceInfo( + identifiers={(DOMAIN, device.id)}, + manufacturer="Powerfox", + model=device.type.human_readable, + name=device.name, + serial_number=device.id, + ) diff --git a/homeassistant/components/powerfox/manifest.json b/homeassistant/components/powerfox/manifest.json new file mode 100644 index 00000000000..a7285bb213f --- /dev/null +++ b/homeassistant/components/powerfox/manifest.json @@ -0,0 +1,16 @@ +{ + "domain": "powerfox", + "name": "Powerfox", + "codeowners": ["@klaasnicolaas"], + "config_flow": true, + "documentation": "https://www.home-assistant.io/integrations/powerfox", + "iot_class": "cloud_polling", + "quality_scale": "bronze", + "requirements": ["powerfox==1.0.0"], + "zeroconf": [ + { + "type": "_http._tcp.local.", + "name": "powerfox*" + } + ] +} diff --git a/homeassistant/components/powerfox/quality_scale.yaml b/homeassistant/components/powerfox/quality_scale.yaml new file mode 100644 index 00000000000..5b1fa9e6398 --- /dev/null +++ b/homeassistant/components/powerfox/quality_scale.yaml @@ -0,0 +1,92 @@ +rules: + # Bronze + action-setup: + status: exempt + comment: | + This integration does not provide additional actions. + appropriate-polling: done + brands: done + common-modules: done + config-flow-test-coverage: done + config-flow: done + dependency-transparency: done + docs-actions: + status: exempt + comment: | + This integration does not provide additional actions. + docs-high-level-description: done + docs-installation-instructions: done + docs-removal-instructions: done + entity-event-setup: + status: exempt + comment: | + Entities of this integration does not explicitly subscribe to events. + entity-unique-id: done + has-entity-name: done + runtime-data: done + test-before-configure: done + test-before-setup: done + unique-config-entry: done + + # Silver + action-exceptions: + status: exempt + comment: | + This integration does not provide additional actions. + config-entry-unloading: done + docs-configuration-parameters: + status: exempt + comment: | + This integration does not have an options flow. + docs-installation-parameters: done + entity-unavailable: done + integration-owner: done + log-when-unavailable: done + parallel-updates: + status: exempt + comment: | + This integration uses a coordinator to handle updates. + reauthentication-flow: todo + test-coverage: done + + # Gold + devices: done + diagnostics: todo + discovery-update-info: + status: exempt + comment: | + This integration is connecting to a cloud service. + discovery: + status: exempt + comment: | + It can find poweropti devices via zeroconf, but will start a normal user flow. + docs-data-update: done + docs-examples: todo + docs-known-limitations: done + docs-supported-devices: done + docs-supported-functions: done + docs-troubleshooting: todo + docs-use-cases: done + dynamic-devices: todo + entity-category: done + entity-device-class: done + entity-disabled-by-default: + status: exempt + comment: | + This integration does not have any entities that should disabled by default. + entity-translations: done + exception-translations: done + icon-translations: + status: exempt + comment: | + There is no need for icon translations. + reconfiguration-flow: todo + repair-issues: + status: exempt + comment: | + This integration doesn't have any cases where raising an issue is needed. + stale-devices: todo + # Platinum + async-dependency: done + inject-websession: done + strict-typing: done diff --git a/homeassistant/components/powerfox/sensor.py b/homeassistant/components/powerfox/sensor.py new file mode 100644 index 00000000000..af6f0301b0c --- /dev/null +++ b/homeassistant/components/powerfox/sensor.py @@ -0,0 +1,147 @@ +"""Sensors for Powerfox integration.""" + +from __future__ import annotations + +from collections.abc import Callable +from dataclasses import dataclass +from typing import Generic, TypeVar + +from powerfox import Device, PowerMeter, WaterMeter + +from homeassistant.components.sensor import ( + SensorDeviceClass, + SensorEntity, + SensorEntityDescription, + SensorStateClass, +) +from homeassistant.const import UnitOfEnergy, UnitOfPower, UnitOfVolume +from homeassistant.core import HomeAssistant +from homeassistant.helpers.entity_platform import AddEntitiesCallback + +from . import PowerfoxConfigEntry +from .coordinator import PowerfoxDataUpdateCoordinator +from .entity import PowerfoxEntity + +T = TypeVar("T", PowerMeter, WaterMeter) + + +@dataclass(frozen=True, kw_only=True) +class PowerfoxSensorEntityDescription(Generic[T], SensorEntityDescription): + """Describes Poweropti sensor entity.""" + + value_fn: Callable[[T], float | int | None] + + +SENSORS_POWER: tuple[PowerfoxSensorEntityDescription[PowerMeter], ...] = ( + PowerfoxSensorEntityDescription[PowerMeter]( + key="power", + native_unit_of_measurement=UnitOfPower.WATT, + device_class=SensorDeviceClass.POWER, + state_class=SensorStateClass.MEASUREMENT, + value_fn=lambda meter: meter.power, + ), + PowerfoxSensorEntityDescription[PowerMeter]( + key="energy_usage", + translation_key="energy_usage", + native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR, + device_class=SensorDeviceClass.ENERGY, + state_class=SensorStateClass.TOTAL_INCREASING, + value_fn=lambda meter: meter.energy_usage, + ), + PowerfoxSensorEntityDescription[PowerMeter]( + key="energy_usage_low_tariff", + translation_key="energy_usage_low_tariff", + native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR, + device_class=SensorDeviceClass.ENERGY, + state_class=SensorStateClass.TOTAL_INCREASING, + value_fn=lambda meter: meter.energy_usage_low_tariff, + ), + PowerfoxSensorEntityDescription[PowerMeter]( + key="energy_usage_high_tariff", + translation_key="energy_usage_high_tariff", + native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR, + device_class=SensorDeviceClass.ENERGY, + state_class=SensorStateClass.TOTAL_INCREASING, + value_fn=lambda meter: meter.energy_usage_high_tariff, + ), + PowerfoxSensorEntityDescription[PowerMeter]( + key="energy_return", + translation_key="energy_return", + native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR, + device_class=SensorDeviceClass.ENERGY, + state_class=SensorStateClass.TOTAL_INCREASING, + value_fn=lambda meter: meter.energy_return, + ), +) + + +SENSORS_WATER: tuple[PowerfoxSensorEntityDescription[WaterMeter], ...] = ( + PowerfoxSensorEntityDescription[WaterMeter]( + key="cold_water", + translation_key="cold_water", + native_unit_of_measurement=UnitOfVolume.CUBIC_METERS, + device_class=SensorDeviceClass.WATER, + state_class=SensorStateClass.TOTAL_INCREASING, + value_fn=lambda meter: meter.cold_water, + ), + PowerfoxSensorEntityDescription[WaterMeter]( + key="warm_water", + translation_key="warm_water", + native_unit_of_measurement=UnitOfVolume.CUBIC_METERS, + device_class=SensorDeviceClass.WATER, + state_class=SensorStateClass.TOTAL_INCREASING, + value_fn=lambda meter: meter.warm_water, + ), +) + + +async def async_setup_entry( + hass: HomeAssistant, + entry: PowerfoxConfigEntry, + async_add_entities: AddEntitiesCallback, +) -> None: + """Set up Powerfox sensors based on a config entry.""" + entities: list[SensorEntity] = [] + for coordinator in entry.runtime_data: + if isinstance(coordinator.data, PowerMeter): + entities.extend( + PowerfoxSensorEntity( + coordinator=coordinator, + description=description, + device=coordinator.device, + ) + for description in SENSORS_POWER + if description.value_fn(coordinator.data) is not None + ) + if isinstance(coordinator.data, WaterMeter): + entities.extend( + PowerfoxSensorEntity( + coordinator=coordinator, + description=description, + device=coordinator.device, + ) + for description in SENSORS_WATER + ) + async_add_entities(entities) + + +class PowerfoxSensorEntity(PowerfoxEntity, SensorEntity): + """Defines a powerfox power meter sensor.""" + + entity_description: PowerfoxSensorEntityDescription + + def __init__( + self, + coordinator: PowerfoxDataUpdateCoordinator, + device: Device, + description: PowerfoxSensorEntityDescription, + ) -> None: + """Initialize Powerfox power meter sensor.""" + super().__init__(coordinator, device) + self.entity_description = description + self._attr_unique_id = f"{device.id}_{description.key}" + + @property + def native_value(self) -> float | int | None: + """Return the state of the entity.""" + return self.entity_description.value_fn(self.coordinator.data) diff --git a/homeassistant/components/powerfox/strings.json b/homeassistant/components/powerfox/strings.json new file mode 100644 index 00000000000..451100f3b42 --- /dev/null +++ b/homeassistant/components/powerfox/strings.json @@ -0,0 +1,46 @@ +{ + "config": { + "step": { + "user": { + "description": "Connect to your Powerfox account to get information about your energy, heat or water consumption.", + "data": { + "email": "[%key:common::config_flow::data::email%]", + "password": "[%key:common::config_flow::data::password%]" + }, + "data_description": { + "email": "The email address of your Powerfox account.", + "password": "The password of your Powerfox account." + } + } + }, + "error": { + "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]", + "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]" + }, + "abort": { + "already_configured": "[%key:common::config_flow::abort::already_configured_account%]" + } + }, + "entity": { + "sensor": { + "energy_usage": { + "name": "Energy usage" + }, + "energy_usage_low_tariff": { + "name": "Energy usage low tariff" + }, + "energy_usage_high_tariff": { + "name": "Energy usage high tariff" + }, + "energy_return": { + "name": "Energy return" + }, + "cold_water": { + "name": "Cold water" + }, + "warm_water": { + "name": "Warm water" + } + } + } +} diff --git a/homeassistant/generated/config_flows.py b/homeassistant/generated/config_flows.py index 9a75ac32ea1..5cd9dd786fe 100644 --- a/homeassistant/generated/config_flows.py +++ b/homeassistant/generated/config_flows.py @@ -461,6 +461,7 @@ FLOWS = { "plum_lightpad", "point", "poolsense", + "powerfox", "powerwall", "private_ble_device", "profiler", diff --git a/homeassistant/generated/integrations.json b/homeassistant/generated/integrations.json index ae7e0dd6c59..d2f0a90065a 100644 --- a/homeassistant/generated/integrations.json +++ b/homeassistant/generated/integrations.json @@ -4763,6 +4763,12 @@ "integration_type": "virtual", "supported_by": "opower" }, + "powerfox": { + "name": "Powerfox", + "integration_type": "hub", + "config_flow": true, + "iot_class": "cloud_polling" + }, "private_ble_device": { "name": "Private BLE Device", "integration_type": "hub", diff --git a/homeassistant/generated/zeroconf.py b/homeassistant/generated/zeroconf.py index 5f7161a8245..9bfff93cc2f 100644 --- a/homeassistant/generated/zeroconf.py +++ b/homeassistant/generated/zeroconf.py @@ -542,6 +542,10 @@ ZEROCONF = { "manufacturer": "nettigo", }, }, + { + "domain": "powerfox", + "name": "powerfox*", + }, { "domain": "pure_energie", "name": "smartbridge*", diff --git a/mypy.ini b/mypy.ini index 22e85244843..8e675ff6481 100644 --- a/mypy.ini +++ b/mypy.ini @@ -3406,6 +3406,16 @@ disallow_untyped_defs = true warn_return_any = true warn_unreachable = true +[mypy-homeassistant.components.powerfox.*] +check_untyped_defs = true +disallow_incomplete_defs = true +disallow_subclassing_any = true +disallow_untyped_calls = true +disallow_untyped_decorators = true +disallow_untyped_defs = true +warn_return_any = true +warn_unreachable = true + [mypy-homeassistant.components.powerwall.*] check_untyped_defs = true disallow_incomplete_defs = true diff --git a/requirements_all.txt b/requirements_all.txt index 18f7bc2fb20..0df4ba65c86 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -1633,6 +1633,9 @@ pmsensor==0.4 # homeassistant.components.poolsense poolsense==0.0.8 +# homeassistant.components.powerfox +powerfox==1.0.0 + # homeassistant.components.reddit praw==7.5.0 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index ebfc47c764d..ab8d4663a86 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -1340,6 +1340,9 @@ plumlightpad==0.0.11 # homeassistant.components.poolsense poolsense==0.0.8 +# homeassistant.components.powerfox +powerfox==1.0.0 + # homeassistant.components.reddit praw==7.5.0 diff --git a/tests/components/powerfox/__init__.py b/tests/components/powerfox/__init__.py new file mode 100644 index 00000000000..d24e52eba9b --- /dev/null +++ b/tests/components/powerfox/__init__.py @@ -0,0 +1,14 @@ +"""Tests for the Powerfox integration.""" + +from homeassistant.core import HomeAssistant + +from tests.common import MockConfigEntry + +MOCK_DIRECT_HOST = "1.1.1.1" + + +async def setup_integration(hass: HomeAssistant, config_entry: MockConfigEntry) -> None: + """Fixture for setting up the integration.""" + config_entry.add_to_hass(hass) + + await hass.config_entries.async_setup(config_entry.entry_id) diff --git a/tests/components/powerfox/conftest.py b/tests/components/powerfox/conftest.py new file mode 100644 index 00000000000..14ccc5996e5 --- /dev/null +++ b/tests/components/powerfox/conftest.py @@ -0,0 +1,87 @@ +"""Common fixtures for the Powerfox tests.""" + +from collections.abc import Generator +from datetime import UTC, datetime +from unittest.mock import AsyncMock, patch + +from powerfox import Device, DeviceType, PowerMeter, WaterMeter +import pytest + +from homeassistant.components.powerfox.const import DOMAIN +from homeassistant.const import CONF_EMAIL, CONF_PASSWORD + +from tests.common import MockConfigEntry + + +@pytest.fixture +def mock_setup_entry() -> Generator[AsyncMock]: + """Override async_setup_entry.""" + with patch( + "homeassistant.components.powerfox.async_setup_entry", return_value=True + ) as mock_setup_entry: + yield mock_setup_entry + + +@pytest.fixture +def mock_powerfox_client() -> Generator[AsyncMock]: + """Mock a Powerfox client.""" + with ( + patch( + "homeassistant.components.powerfox.Powerfox", + autospec=True, + ) as mock_client, + patch( + "homeassistant.components.powerfox.config_flow.Powerfox", + new=mock_client, + ), + ): + client = mock_client.return_value + client.all_devices.return_value = [ + Device( + id="9x9x1f12xx3x", + date_added=datetime(2024, 11, 26, 9, 22, 35, tzinfo=UTC), + main_device=True, + bidirectional=True, + type=DeviceType.POWER_METER, + name="Poweropti", + ), + Device( + id="9x9x1f12xx4x", + date_added=datetime(2024, 11, 26, 9, 22, 35, tzinfo=UTC), + main_device=False, + bidirectional=False, + type=DeviceType.COLD_WATER_METER, + name="Wateropti", + ), + ] + client.device.side_effect = [ + PowerMeter( + outdated=False, + timestamp=datetime(2024, 11, 26, 10, 48, 51, tzinfo=UTC), + power=111, + energy_usage=1111.111, + energy_return=111.111, + energy_usage_high_tariff=111.111, + energy_usage_low_tariff=111.111, + ), + WaterMeter( + outdated=False, + timestamp=datetime(2024, 11, 26, 10, 48, 51, tzinfo=UTC), + cold_water=1111.111, + warm_water=0.0, + ), + ] + yield client + + +@pytest.fixture +def mock_config_entry() -> MockConfigEntry: + """Mock a Powerfox config entry.""" + return MockConfigEntry( + domain=DOMAIN, + title="Powerfox", + data={ + CONF_EMAIL: "test@powerfox.test", + CONF_PASSWORD: "test-password", + }, + ) diff --git a/tests/components/powerfox/snapshots/test_sensor.ambr b/tests/components/powerfox/snapshots/test_sensor.ambr new file mode 100644 index 00000000000..dda162d4eeb --- /dev/null +++ b/tests/components/powerfox/snapshots/test_sensor.ambr @@ -0,0 +1,358 @@ +# serializer version: 1 +# name: test_all_sensors[sensor.poweropti_energy_return-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.poweropti_energy_return', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy return', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'energy_return', + 'unique_id': '9x9x1f12xx3x_energy_return', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_return-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Poweropti Energy return', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.poweropti_energy_return', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '111.111', + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_usage-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.poweropti_energy_usage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy usage', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'energy_usage', + 'unique_id': '9x9x1f12xx3x_energy_usage', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_usage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Poweropti Energy usage', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.poweropti_energy_usage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1111.111', + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_usage_high_tariff-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.poweropti_energy_usage_high_tariff', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy usage high tariff', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'energy_usage_high_tariff', + 'unique_id': '9x9x1f12xx3x_energy_usage_high_tariff', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_usage_high_tariff-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Poweropti Energy usage high tariff', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.poweropti_energy_usage_high_tariff', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '111.111', + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_usage_low_tariff-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.poweropti_energy_usage_low_tariff', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy usage low tariff', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'energy_usage_low_tariff', + 'unique_id': '9x9x1f12xx3x_energy_usage_low_tariff', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.poweropti_energy_usage_low_tariff-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Poweropti Energy usage low tariff', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.poweropti_energy_usage_low_tariff', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '111.111', + }) +# --- +# name: test_all_sensors[sensor.poweropti_power-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.poweropti_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '9x9x1f12xx3x_power', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.poweropti_power-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power', + 'friendly_name': 'Poweropti Power', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.poweropti_power', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '111', + }) +# --- +# name: test_all_sensors[sensor.wateropti_cold_water-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.wateropti_cold_water', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Cold water', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'cold_water', + 'unique_id': '9x9x1f12xx4x_cold_water', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.wateropti_cold_water-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'water', + 'friendly_name': 'Wateropti Cold water', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.wateropti_cold_water', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1111.111', + }) +# --- +# name: test_all_sensors[sensor.wateropti_warm_water-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.wateropti_warm_water', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Warm water', + 'platform': 'powerfox', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'warm_water', + 'unique_id': '9x9x1f12xx4x_warm_water', + 'unit_of_measurement': , + }) +# --- +# name: test_all_sensors[sensor.wateropti_warm_water-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'water', + 'friendly_name': 'Wateropti Warm water', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.wateropti_warm_water', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.0', + }) +# --- diff --git a/tests/components/powerfox/test_config_flow.py b/tests/components/powerfox/test_config_flow.py new file mode 100644 index 00000000000..b99470880a0 --- /dev/null +++ b/tests/components/powerfox/test_config_flow.py @@ -0,0 +1,145 @@ +"""Test the Powerfox config flow.""" + +from unittest.mock import AsyncMock + +from powerfox import PowerfoxAuthenticationError, PowerfoxConnectionError +import pytest + +from homeassistant.components import zeroconf +from homeassistant.components.powerfox.const import DOMAIN +from homeassistant.config_entries import SOURCE_USER, SOURCE_ZEROCONF +from homeassistant.const import CONF_EMAIL, CONF_PASSWORD +from homeassistant.core import HomeAssistant +from homeassistant.data_entry_flow import FlowResultType + +from . import MOCK_DIRECT_HOST + +from tests.common import MockConfigEntry + +MOCK_ZEROCONF_DISCOVERY_INFO = zeroconf.ZeroconfServiceInfo( + ip_address=MOCK_DIRECT_HOST, + ip_addresses=[MOCK_DIRECT_HOST], + hostname="powerfox.local", + name="Powerfox", + port=443, + type="_http._tcp", + properties={}, +) + + +async def test_full_user_flow( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_setup_entry: AsyncMock, +) -> None: + """Test the full user configuration flow.""" + result = await hass.config_entries.flow.async_init( + DOMAIN, context={"source": SOURCE_USER} + ) + + assert result.get("type") is FlowResultType.FORM + assert result.get("step_id") == "user" + assert not result.get("errors") + + result = await hass.config_entries.flow.async_configure( + result["flow_id"], + user_input={CONF_EMAIL: "test@powerfox.test", CONF_PASSWORD: "test-password"}, + ) + + assert result.get("type") is FlowResultType.CREATE_ENTRY + assert result.get("title") == "test@powerfox.test" + assert result.get("data") == { + CONF_EMAIL: "test@powerfox.test", + CONF_PASSWORD: "test-password", + } + assert len(mock_powerfox_client.all_devices.mock_calls) == 1 + assert len(mock_setup_entry.mock_calls) == 1 + + +async def test_zeroconf_discovery( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_setup_entry: AsyncMock, +) -> None: + """Test zeroconf discovery.""" + result = await hass.config_entries.flow.async_init( + DOMAIN, + context={"source": SOURCE_ZEROCONF}, + data=MOCK_ZEROCONF_DISCOVERY_INFO, + ) + + assert result.get("type") is FlowResultType.FORM + assert result.get("step_id") == "user" + assert not result.get("errors") + + result = await hass.config_entries.flow.async_configure( + result["flow_id"], + user_input={CONF_EMAIL: "test@powerfox.test", CONF_PASSWORD: "test-password"}, + ) + + assert result.get("type") is FlowResultType.CREATE_ENTRY + assert result.get("title") == "test@powerfox.test" + assert result.get("data") == { + CONF_EMAIL: "test@powerfox.test", + CONF_PASSWORD: "test-password", + } + assert len(mock_powerfox_client.all_devices.mock_calls) == 1 + assert len(mock_setup_entry.mock_calls) == 1 + + +async def test_duplicate_entry( + hass: HomeAssistant, + mock_config_entry: MockConfigEntry, + mock_powerfox_client: AsyncMock, +) -> None: + """Test abort when setting up duplicate entry.""" + mock_config_entry.add_to_hass(hass) + result = await hass.config_entries.flow.async_init( + DOMAIN, context={"source": SOURCE_USER} + ) + + assert result.get("type") is FlowResultType.FORM + assert not result.get("errors") + + result = await hass.config_entries.flow.async_configure( + result["flow_id"], + user_input={CONF_EMAIL: "test@powerfox.test", CONF_PASSWORD: "test-password"}, + ) + + assert result.get("type") is FlowResultType.ABORT + assert result.get("reason") == "already_configured" + + +@pytest.mark.parametrize( + ("exception", "error"), + [ + (PowerfoxConnectionError, "cannot_connect"), + (PowerfoxAuthenticationError, "invalid_auth"), + ], +) +async def test_exceptions( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_setup_entry: AsyncMock, + exception: Exception, + error: str, +) -> None: + """Test exceptions during config flow.""" + mock_powerfox_client.all_devices.side_effect = exception + result = await hass.config_entries.flow.async_init( + DOMAIN, context={"source": SOURCE_USER} + ) + result = await hass.config_entries.flow.async_configure( + result["flow_id"], + user_input={CONF_EMAIL: "test@powerfox.test", CONF_PASSWORD: "test-password"}, + ) + assert result.get("type") is FlowResultType.FORM + assert result.get("errors") == {"base": error} + + mock_powerfox_client.all_devices.side_effect = None + + result = await hass.config_entries.flow.async_configure( + result["flow_id"], + user_input={CONF_EMAIL: "test@powerfox.test", CONF_PASSWORD: "test-password"}, + ) + assert result.get("type") is FlowResultType.CREATE_ENTRY diff --git a/tests/components/powerfox/test_init.py b/tests/components/powerfox/test_init.py new file mode 100644 index 00000000000..900c7b60ae0 --- /dev/null +++ b/tests/components/powerfox/test_init.py @@ -0,0 +1,45 @@ +"""Test the Powerfox init module.""" + +from __future__ import annotations + +from unittest.mock import AsyncMock + +from powerfox import PowerfoxConnectionError + +from homeassistant.config_entries import ConfigEntryState +from homeassistant.core import HomeAssistant + +from . import setup_integration + +from tests.common import MockConfigEntry + + +async def test_load_unload_entry( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_config_entry: MockConfigEntry, +) -> None: + """Test load and unload entry.""" + await setup_integration(hass, mock_config_entry) + + assert mock_config_entry.state is ConfigEntryState.LOADED + + await hass.config_entries.async_remove(mock_config_entry.entry_id) + await hass.async_block_till_done() + + assert mock_config_entry.state is ConfigEntryState.NOT_LOADED + + +async def test_config_entry_not_ready( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_config_entry: MockConfigEntry, +) -> None: + """Test the Powerfox configuration entry not ready.""" + mock_powerfox_client.all_devices.side_effect = PowerfoxConnectionError + mock_config_entry.add_to_hass(hass) + + await hass.config_entries.async_setup(mock_config_entry.entry_id) + await hass.async_block_till_done() + + assert mock_config_entry.state is ConfigEntryState.SETUP_RETRY diff --git a/tests/components/powerfox/test_sensor.py b/tests/components/powerfox/test_sensor.py new file mode 100644 index 00000000000..547d8de202c --- /dev/null +++ b/tests/components/powerfox/test_sensor.py @@ -0,0 +1,53 @@ +"""Test the sensors provided by the Powerfox integration.""" + +from __future__ import annotations + +from datetime import timedelta +from unittest.mock import AsyncMock, patch + +from freezegun.api import FrozenDateTimeFactory +from powerfox import PowerfoxConnectionError +from syrupy import SnapshotAssertion + +from homeassistant.config_entries import ConfigEntryState +from homeassistant.const import STATE_UNAVAILABLE, Platform +from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er + +from . import setup_integration + +from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform + + +async def test_all_sensors( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_config_entry: MockConfigEntry, + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, +) -> None: + """Test the Powerfox sensors.""" + with patch("homeassistant.components.powerfox.PLATFORMS", [Platform.SENSOR]): + await setup_integration(hass, mock_config_entry) + + await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id) + + +async def test_update_failed( + hass: HomeAssistant, + mock_powerfox_client: AsyncMock, + mock_config_entry: MockConfigEntry, + freezer: FrozenDateTimeFactory, +) -> None: + """Test entities become unavailable after failed update.""" + await setup_integration(hass, mock_config_entry) + assert mock_config_entry.state is ConfigEntryState.LOADED + + assert hass.states.get("sensor.poweropti_energy_usage").state is not None + + mock_powerfox_client.device.side_effect = PowerfoxConnectionError + freezer.tick(timedelta(minutes=5)) + async_fire_time_changed(hass) + await hass.async_block_till_done() + + assert hass.states.get("sensor.poweropti_energy_usage").state == STATE_UNAVAILABLE