Merge remote-tracking branch 'upstream/dev' into light_condition_tests_remove_unused_fixture

CODEOWNERS

@@ -711,8 +711,6 @@ build.json @home-assistant/supervisor
 /tests/components/homematic/ @pvizeli
 /homeassistant/components/homematicip_cloud/ @hahn-th
 /tests/components/homematicip_cloud/ @hahn-th
-/homeassistant/components/homevolt/ @danielhiversen
-/tests/components/homevolt/ @danielhiversen
 /homeassistant/components/homewizard/ @DCSBL
 /tests/components/homewizard/ @DCSBL
 /homeassistant/components/honeywell/ @rdfurman @mkmer

homeassistant/components/homevolt/__init__.py

@@ -1,36 +0,0 @@
-"""The Homevolt integration."""
-
-from __future__ import annotations
-
-from homevolt import Homevolt
-
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .coordinator import HomevoltConfigEntry, HomevoltDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:
-    """Set up Homevolt from a config entry."""
-    host: str = entry.data[CONF_HOST]
-    password: str | None = entry.data.get(CONF_PASSWORD)
-
-    websession = async_get_clientsession(hass)
-    client = Homevolt(host, password, websession=websession)
-
-    coordinator = HomevoltDataUpdateCoordinator(hass, entry, client)
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/homevolt/config_flow.py

@@ -1,70 +0,0 @@
-"""Config flow for the Homevolt integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from homevolt import Homevolt, HomevoltAuthenticationError, HomevoltConnectionError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_PASSWORD
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): str,
-        vol.Optional(CONF_PASSWORD): str,
-    }
-)
-
-
-class HomevoltConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Homevolt."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    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:
-            host = user_input[CONF_HOST]
-            password = user_input.get(CONF_PASSWORD)
-            websession = async_get_clientsession(self.hass)
-            client = Homevolt(host, password, websession=websession)
-            try:
-                await client.update_info()
-                device = client.get_device()
-                device_id = device.device_id
-            except HomevoltAuthenticationError:
-                errors["base"] = "invalid_auth"
-            except HomevoltConnectionError:
-                errors["base"] = "cannot_connect"
-            except Exception:
-                _LOGGER.exception(
-                    "Error occurred while connecting to the Homevolt battery"
-                )
-                errors["base"] = "unknown"
-            else:
-                await self.async_set_unique_id(device_id)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title="Homevolt Local",
-                    data={
-                        CONF_HOST: host,
-                        CONF_PASSWORD: password,
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/homevolt/const.py

@@ -1,9 +0,0 @@
-"""Constants for the Homevolt integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-
-DOMAIN = "homevolt"
-MANUFACTURER = "Homevolt"
-SCAN_INTERVAL = timedelta(seconds=15)

homeassistant/components/homevolt/coordinator.py

@@ -1,56 +0,0 @@
-"""Data update coordinator for Homevolt integration."""
-
-from __future__ import annotations
-
-import logging
-
-from homevolt import (
-    Device,
-    Homevolt,
-    HomevoltAuthenticationError,
-    HomevoltConnectionError,
-    HomevoltError,
-)
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, SCAN_INTERVAL
-
-type HomevoltConfigEntry = ConfigEntry[HomevoltDataUpdateCoordinator]
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class HomevoltDataUpdateCoordinator(DataUpdateCoordinator[Device]):
-    """Class to manage fetching Homevolt data."""
-
-    config_entry: HomevoltConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: HomevoltConfigEntry,
-        client: Homevolt,
-    ) -> None:
-        """Initialize the Homevolt coordinator."""
-        self.client = client
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=DOMAIN,
-            update_interval=SCAN_INTERVAL,
-            config_entry=entry,
-        )
-
-    async def _async_update_data(self) -> Device:
-        """Fetch data from the Homevolt API."""
-        try:
-            await self.client.update_info()
-            return self.client.get_device()
-        except HomevoltAuthenticationError as err:
-            raise ConfigEntryAuthFailed from err
-        except (HomevoltConnectionError, HomevoltError) as err:
-            raise UpdateFailed(f"Error communicating with device: {err}") from err

homeassistant/components/homevolt/manifest.json

@@ -1,12 +0,0 @@
-{
-  "domain": "homevolt",
-  "name": "Homevolt",
-  "codeowners": ["@danielhiversen"],
-  "config_flow": true,
-  "dependencies": [],
-  "documentation": "https://www.home-assistant.io/integrations/homevolt",
-  "integration_type": "device",
-  "iot_class": "local_polling",
-  "quality_scale": "bronze",
-  "requirements": ["homevolt==0.2.4"]
-}

homeassistant/components/homevolt/quality_scale.yaml

@@ -1,70 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom 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: Integration does not register custom actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Local_polling without 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: Integration does not register custom actions.
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: Integration does not have an options flow.
-  docs-installation-parameters: todo
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: todo
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/homevolt/sensor.py

@@ -1,162 +0,0 @@
-"""Support for Homevolt sensors."""
-
-from __future__ import annotations
-
-from homevolt.models import SensorType
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import (
-    PERCENTAGE,
-    SIGNAL_STRENGTH_DECIBELS,
-    UnitOfElectricCurrent,
-    UnitOfElectricPotential,
-    UnitOfEnergy,
-    UnitOfFrequency,
-    UnitOfPower,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.typing import StateType
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN, MANUFACTURER
-from .coordinator import HomevoltConfigEntry, HomevoltDataUpdateCoordinator
-
-PARALLEL_UPDATES = 0  # Coordinator-based updates
-
-SENSORS: tuple[SensorEntityDescription, ...] = (
-    SensorEntityDescription(
-        key=SensorType.COUNT,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-    ),
-    SensorEntityDescription(
-        key=SensorType.ENERGY_TOTAL,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL,
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-    ),
-    SensorEntityDescription(
-        key=SensorType.ENERGY_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-    ),
-    SensorEntityDescription(
-        key=SensorType.FREQUENCY,
-        device_class=SensorDeviceClass.FREQUENCY,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-    ),
-    SensorEntityDescription(
-        key=SensorType.PERCENTAGE,
-        device_class=SensorDeviceClass.BATTERY,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=PERCENTAGE,
-    ),
-    SensorEntityDescription(
-        key=SensorType.POWER,
-        device_class=SensorDeviceClass.POWER,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfPower.WATT,
-    ),
-    SensorEntityDescription(
-        key=SensorType.SCHEDULE_TYPE,
-    ),
-    SensorEntityDescription(
-        key=SensorType.SIGNAL_STRENGTH,
-        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
-    ),
-    SensorEntityDescription(
-        key=SensorType.TEMPERATURE,
-        device_class=SensorDeviceClass.TEMPERATURE,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    ),
-    SensorEntityDescription(
-        key=SensorType.TEXT,
-    ),
-    SensorEntityDescription(
-        key=SensorType.VOLTAGE,
-        device_class=SensorDeviceClass.VOLTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-    ),
-    SensorEntityDescription(
-        key=SensorType.CURRENT,
-        device_class=SensorDeviceClass.CURRENT,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: HomevoltConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Homevolt sensor."""
-    coordinator = entry.runtime_data
-    entities = []
-    sensors_by_key = {sensor.key: sensor for sensor in SENSORS}
-    for sensor_key, sensor in coordinator.data.sensors.items():
-        if (description := sensors_by_key.get(sensor.type)) is None:
-            continue
-        entities.append(
-            HomevoltSensor(
-                description,
-                coordinator,
-                sensor_key,
-            )
-        )
-    async_add_entities(entities)
-
-
-class HomevoltSensor(CoordinatorEntity[HomevoltDataUpdateCoordinator], SensorEntity):
-    """Representation of a Homevolt sensor."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        description: SensorEntityDescription,
-        coordinator: HomevoltDataUpdateCoordinator,
-        sensor_key: str,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        device_id = coordinator.data.device_id
-        self._attr_unique_id = f"{device_id}_{sensor_key}"
-        sensor_data = coordinator.data.sensors[sensor_key]
-        self._attr_translation_key = sensor_data.slug
-        self._sensor_key = sensor_key
-        device_metadata = coordinator.data.device_metadata.get(
-            sensor_data.device_identifier
-        )
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"{device_id}_{sensor_data.device_identifier}")},
-            configuration_url=coordinator.client.base_url,
-            manufacturer=MANUFACTURER,
-            model=device_metadata.model if device_metadata else None,
-            name=device_metadata.name if device_metadata else None,
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return super().available and self._sensor_key in self.coordinator.data.sensors
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the native value of the sensor."""
-        return self.coordinator.data.sensors[self._sensor_key].value

homeassistant/components/homevolt/strings.json

@@ -1,198 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "host": "The IP address or hostname of your Homevolt battery on your local network.",
-          "password": "The local password configured for your Homevolt battery, if required."
-        },
-        "description": "Connect Home Assistant to your Homevolt battery over the local network.",
-        "title": "Homevolt Local"
-      }
-    }
-  },
-  "entity": {
-    "sensor": {
-      "available_charging_energy": {
-        "name": "Available charging energy"
-      },
-      "available_charging_power": {
-        "name": "Available charging power"
-      },
-      "available_discharge_energy": {
-        "name": "Available discharge energy"
-      },
-      "available_discharge_power": {
-        "name": "Available discharge power"
-      },
-      "average_rssi_grid": {
-        "name": "Grid average RSSI"
-      },
-      "average_rssi_load": {
-        "name": "Load average RSSI"
-      },
-      "battery_state_of_charge": {
-        "name": "Battery state of charge"
-      },
-      "charge_cycles": {
-        "name": "Charge cycles"
-      },
-      "energy_exported_grid": {
-        "name": "Grid exported energy"
-      },
-      "energy_exported_load": {
-        "name": "Load exported energy"
-      },
-      "energy_imported_grid": {
-        "name": "Grid imported energy"
-      },
-      "energy_imported_load": {
-        "name": "Load imported energy"
-      },
-      "exported_energy": {
-        "name": "Exported energy"
-      },
-      "frequency": {
-        "name": "Frequency"
-      },
-      "imported_energy": {
-        "name": "Imported energy"
-      },
-      "l1_current": {
-        "name": "L1 current"
-      },
-      "l1_current_grid": {
-        "name": "Grid L1 current"
-      },
-      "l1_current_load": {
-        "name": "Load L1 current"
-      },
-      "l1_l2_voltage": {
-        "name": "L1-L2 voltage"
-      },
-      "l1_power_grid": {
-        "name": "Grid L1 power"
-      },
-      "l1_power_load": {
-        "name": "Load L1 power"
-      },
-      "l1_voltage": {
-        "name": "L1 voltage"
-      },
-      "l1_voltage_grid": {
-        "name": "Grid L1 voltage"
-      },
-      "l1_voltage_load": {
-        "name": "Load L1 voltage"
-      },
-      "l2_current": {
-        "name": "L2 current"
-      },
-      "l2_current_grid": {
-        "name": "Grid L2 current"
-      },
-      "l2_current_load": {
-        "name": "Load L2 current"
-      },
-      "l2_l3_voltage": {
-        "name": "L2-L3 voltage"
-      },
-      "l2_power_grid": {
-        "name": "Grid L2 power"
-      },
-      "l2_power_load": {
-        "name": "Load L2 power"
-      },
-      "l2_voltage": {
-        "name": "L2 voltage"
-      },
-      "l2_voltage_grid": {
-        "name": "Grid L2 voltage"
-      },
-      "l2_voltage_load": {
-        "name": "Load L2 voltage"
-      },
-      "l3_current": {
-        "name": "L3 current"
-      },
-      "l3_current_grid": {
-        "name": "Grid L3 current"
-      },
-      "l3_current_load": {
-        "name": "Load L3 current"
-      },
-      "l3_l1_voltage": {
-        "name": "L3-L1 voltage"
-      },
-      "l3_power_grid": {
-        "name": "Grid L3 power"
-      },
-      "l3_power_load": {
-        "name": "Load L3 power"
-      },
-      "l3_voltage": {
-        "name": "L3 voltage"
-      },
-      "l3_voltage_grid": {
-        "name": "Grid L3 voltage"
-      },
-      "l3_voltage_load": {
-        "name": "Load L3 voltage"
-      },
-      "power": {
-        "name": "Power"
-      },
-      "power_grid": {
-        "name": "Grid power"
-      },
-      "power_load": {
-        "name": "Load power"
-      },
-      "rssi_grid": {
-        "name": "Grid RSSI"
-      },
-      "rssi_load": {
-        "name": "Load RSSI"
-      },
-      "schedule_id": {
-        "name": "Schedule ID"
-      },
-      "schedule_max_discharge": {
-        "name": "Schedule max discharge"
-      },
-      "schedule_max_power": {
-        "name": "Schedule max power"
-      },
-      "schedule_power_setpoint": {
-        "name": "Schedule power setpoint"
-      },
-      "schedule_type": {
-        "name": "Schedule type"
-      },
-      "state_of_charge": {
-        "name": "State of charge"
-      },
-      "system_temperature": {
-        "name": "System temperature"
-      },
-      "tmax": {
-        "name": "Maximum temperature"
-      },
-      "tmin": {
-        "name": "Minimum temperature"
-      }
-    }
-  }
-}

homeassistant/generated/config_flows.py

@@ -294,7 +294,6 @@ FLOWS = {
         "homekit",
         "homekit_controller",
         "homematicip_cloud",
-        "homevolt",
         "homewizard",
         "homeworks",
         "honeywell",

homeassistant/generated/integrations.json

@@ -2836,12 +2836,6 @@
         "zwave"
       ]
     },
-    "homevolt": {
-      "name": "Homevolt",
-      "integration_type": "device",
-      "config_flow": true,
-      "iot_class": "local_polling"
-    },
     "homewizard": {
       "name": "HomeWizard",
       "integration_type": "device",

requirements_all.txt

@@ -1226,9 +1226,6 @@ homelink-integration-api==0.0.1
 # homeassistant.components.homematicip_cloud
 homematicip==2.4.0
 
-# homeassistant.components.homevolt
-homevolt==0.2.4
-
 # homeassistant.components.horizon
 horimote==0.4.1
 

requirements_test_all.txt

@@ -1084,9 +1084,6 @@ homelink-integration-api==0.0.1
 # homeassistant.components.homematicip_cloud
 homematicip==2.4.0
 
-# homeassistant.components.homevolt
-homevolt==0.2.4
-
 # homeassistant.components.remember_the_milk
 httplib2==0.20.4
 

tests/components/homevolt/__init__.py

@@ -1 +0,0 @@
-"""Tests for the Homevolt integration."""

tests/components/homevolt/conftest.py

@@ -1,110 +0,0 @@
-"""Common fixtures for the Homevolt tests."""
-
-from collections.abc import Generator
-from unittest.mock import AsyncMock, MagicMock, patch
-
-from homevolt import Device, DeviceMetadata, Sensor, SensorType
-import pytest
-
-from homeassistant.components.homevolt.const import DOMAIN
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, Platform
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry
-
-
-@pytest.fixture
-def mock_setup_entry() -> Generator[AsyncMock]:
-    """Override async_setup_entry."""
-    with patch(
-        "homeassistant.components.homevolt.async_setup_entry", return_value=True
-    ) as mock_setup_entry:
-        yield mock_setup_entry
-
-
-@pytest.fixture
-def mock_config_entry() -> MockConfigEntry:
-    """Return the default mocked config entry."""
-    return MockConfigEntry(
-        title="Homevolt",
-        domain=DOMAIN,
-        data={
-            CONF_HOST: "127.0.0.1",
-            CONF_PASSWORD: "test-password",
-        },
-        unique_id="40580137858664",
-    )
-
-
-@pytest.fixture
-def mock_homevolt_client() -> Generator[MagicMock]:
-    """Return a mocked Homevolt client."""
-    with (
-        patch(
-            "homeassistant.components.homevolt.Homevolt",
-            autospec=True,
-        ) as homevolt_mock,
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt",
-            new=homevolt_mock,
-        ),
-    ):
-        client = homevolt_mock.return_value
-        client.base_url = "http://127.0.0.1"
-        client.update_info = AsyncMock()
-
-        # Create a mock Device with sensors
-        device = MagicMock(spec=Device)
-        device.device_id = "40580137858664"
-        device.sensors = {
-            "L1 Voltage": Sensor(
-                value=234.5,
-                type=SensorType.VOLTAGE,
-                device_identifier="ems_40580137858664",
-                slug="l1_voltage",
-            ),
-            "Battery State of Charge": Sensor(
-                value=80.6,
-                type=SensorType.PERCENTAGE,
-                device_identifier="ems_40580137858664",
-                slug="battery_state_of_charge",
-            ),
-            "Power": Sensor(
-                value=-12,
-                type=SensorType.POWER,
-                device_identifier="ems_40580137858664",
-                slug="power",
-            ),
-        }
-        device.device_metadata = {
-            "ems_40580137858664": DeviceMetadata(
-                name="Homevolt EMS",
-                model="EMS-1000",
-            ),
-        }
-        client.get_device.return_value = device
-
-        yield client
-
-
-@pytest.fixture
-def platforms() -> list[Platform]:
-    """Return the platforms to test."""
-    return [Platform.SENSOR]
-
-
-@pytest.fixture
-async def init_integration(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_homevolt_client: MagicMock,
-    platforms: list[Platform],
-) -> MockConfigEntry:
-    """Set up the Homevolt integration for testing."""
-    mock_config_entry.add_to_hass(hass)
-
-    with patch("homeassistant.components.homevolt.PLATFORMS", platforms):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-    return mock_config_entry

tests/components/homevolt/snapshots/test_sensor.ambr

@@ -1,169 +0,0 @@
-# serializer version: 1
-# name: test_entities[sensor.homevolt_ems_battery_state_of_charge-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-    }),
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.homevolt_ems_battery_state_of_charge',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Battery state of charge',
-    'options': dict({
-    }),
-    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
-    'original_icon': None,
-    'original_name': 'Battery state of charge',
-    'platform': 'homevolt',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'battery_state_of_charge',
-    'unique_id': '40580137858664_Battery State of Charge',
-    'unit_of_measurement': '%',
-  })
-# ---
-# name: test_entities[sensor.homevolt_ems_battery_state_of_charge-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'battery',
-      'friendly_name': 'Homevolt EMS Battery state of charge',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': '%',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.homevolt_ems_battery_state_of_charge',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': '80.6',
-  })
-# ---
-# name: test_entities[sensor.homevolt_ems_l1_voltage-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-    }),
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.homevolt_ems_l1_voltage',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'L1 voltage',
-    'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 0,
-      }),
-    }),
-    'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
-    'original_icon': None,
-    'original_name': 'L1 voltage',
-    'platform': 'homevolt',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'l1_voltage',
-    'unique_id': '40580137858664_L1 Voltage',
-    'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
-  })
-# ---
-# name: test_entities[sensor.homevolt_ems_l1_voltage-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'voltage',
-      'friendly_name': 'Homevolt EMS L1 voltage',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.homevolt_ems_l1_voltage',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': '234.5',
-  })
-# ---
-# name: test_entities[sensor.homevolt_ems_power-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-    }),
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.homevolt_ems_power',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Power',
-    'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 0,
-      }),
-    }),
-    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
-    'original_icon': None,
-    'original_name': 'Power',
-    'platform': 'homevolt',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'power',
-    'unique_id': '40580137858664_Power',
-    'unit_of_measurement': <UnitOfPower.WATT: 'W'>,
-  })
-# ---
-# name: test_entities[sensor.homevolt_ems_power-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'power',
-      'friendly_name': 'Homevolt EMS Power',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfPower.WATT: 'W'>,
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.homevolt_ems_power',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': '-12',
-  })
-# ---

tests/components/homevolt/test_config_flow.py

@@ -1,170 +0,0 @@
-"""Tests for the Homevolt config flow."""
-
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock, patch
-
-from homevolt import HomevoltAuthenticationError, HomevoltConnectionError
-import pytest
-
-from homeassistant.components.homevolt.const import DOMAIN
-from homeassistant.config_entries import SOURCE_USER
-from homeassistant.const import CONF_HOST, CONF_PASSWORD
-from homeassistant.core import HomeAssistant
-from homeassistant.data_entry_flow import FlowResultType
-
-from tests.common import MockConfigEntry
-
-
-async def test_full_flow_success(
-    hass: HomeAssistant, mock_setup_entry: AsyncMock
-) -> None:
-    """Test a complete successful user flow."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-    assert result["errors"] == {}
-
-    user_input = {
-        CONF_HOST: "192.168.1.100",
-        CONF_PASSWORD: "test-password",
-    }
-
-    with (
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt.update_info",
-            new_callable=AsyncMock,
-        ),
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt.get_device",
-        ) as mock_get_device,
-    ):
-        mock_device = MagicMock()
-        mock_device.device_id = "40580137858664"
-        mock_get_device.return_value = mock_device
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            user_input,
-        )
-        await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["title"] == "Homevolt Local"
-    assert result["data"] == user_input
-    assert len(mock_setup_entry.mock_calls) == 1
-
-
-@pytest.mark.parametrize(
-    ("exception", "expected_error"),
-    [
-        (HomevoltAuthenticationError, "invalid_auth"),
-        (HomevoltConnectionError, "cannot_connect"),
-        (Exception, "unknown"),
-    ],
-)
-async def test_step_user_errors(
-    hass: HomeAssistant,
-    mock_setup_entry: AsyncMock,
-    exception: Exception,
-    expected_error: str,
-) -> None:
-    """Test error cases for the user step with recovery."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-    assert result["errors"] == {}
-
-    user_input = {
-        CONF_HOST: "192.168.1.100",
-        CONF_PASSWORD: "test-password",
-    }
-
-    with patch(
-        "homeassistant.components.homevolt.config_flow.Homevolt.update_info",
-        new_callable=AsyncMock,
-    ) as mock_update_info:
-        mock_update_info.side_effect = exception
-
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            user_input,
-        )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-    assert result["errors"] == {"base": expected_error}
-
-    with (
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt.update_info",
-            new_callable=AsyncMock,
-        ),
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt.get_device",
-        ) as mock_get_device,
-    ):
-        mock_device = MagicMock()
-        mock_device.device_id = "40580137858664"
-        mock_get_device.return_value = mock_device
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            user_input,
-        )
-        await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["title"] == "Homevolt Local"
-    assert result["data"] == user_input
-    assert len(mock_setup_entry.mock_calls) == 1
-
-
-async def test_duplicate_entry(
-    hass: HomeAssistant,
-    mock_setup_entry: AsyncMock,
-) -> None:
-    """Test that a duplicate device_id aborts the flow."""
-    existing_entry = MockConfigEntry(
-        domain=DOMAIN,
-        data={CONF_HOST: "192.168.1.100", CONF_PASSWORD: "test-password"},
-        unique_id="40580137858664",
-    )
-    existing_entry.add_to_hass(hass)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-    assert result["errors"] == {}
-
-    user_input = {
-        CONF_HOST: "192.168.1.200",
-        CONF_PASSWORD: "test-password",
-    }
-
-    with (
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt.update_info",
-            new_callable=AsyncMock,
-        ),
-        patch(
-            "homeassistant.components.homevolt.config_flow.Homevolt.get_device",
-        ) as mock_get_device,
-    ):
-        mock_device = MagicMock()
-        mock_device.device_id = "40580137858664"
-        mock_get_device.return_value = mock_device
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            user_input,
-        )
-
-    assert result["type"] is FlowResultType.ABORT
-    assert result["reason"] == "already_configured"

tests/components/homevolt/test_init.py

@@ -1,65 +0,0 @@
-"""Test the Homevolt init module."""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock
-
-from homevolt import HomevoltAuthenticationError, HomevoltConnectionError
-
-from homeassistant.config_entries import ConfigEntryState
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry
-
-
-async def test_load_unload_entry(
-    hass: HomeAssistant,
-    mock_homevolt_client: MagicMock,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test load and unload entry."""
-    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.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_homevolt_client: MagicMock,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test the Homevolt configuration entry not ready."""
-    mock_homevolt_client.update_info.side_effect = HomevoltConnectionError(
-        "Connection failed"
-    )
-    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
-
-
-async def test_config_entry_auth_failed(
-    hass: HomeAssistant,
-    mock_homevolt_client: MagicMock,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test the Homevolt configuration entry authentication failed."""
-    mock_homevolt_client.update_info.side_effect = HomevoltAuthenticationError(
-        "Authentication failed"
-    )
-    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_ERROR

tests/components/homevolt/test_sensor.py

@@ -1,60 +0,0 @@
-"""Tests for the Homevolt sensor platform."""
-
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-from homeassistant.components.homevolt.const import DOMAIN
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
-
-from tests.common import MockConfigEntry, snapshot_platform
-
-pytestmark = pytest.mark.usefixtures(
-    "entity_registry_enabled_by_default", "init_integration"
-)
-
-
-async def test_entities(
-    hass: HomeAssistant,
-    snapshot: SnapshotAssertion,
-    entity_registry: er.EntityRegistry,
-    device_registry: dr.DeviceRegistry,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test the sensor entities."""
-    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
-
-    device_entry = device_registry.async_get_device(
-        identifiers={(DOMAIN, "40580137858664_ems_40580137858664")}
-    )
-    assert device_entry
-    entity_entries = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    for entity_entry in entity_entries:
-        assert entity_entry.device_id == device_entry.id
-
-
-async def test_sensor_exposes_values_from_coordinator(
-    hass: HomeAssistant,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-    mock_homevolt_client,
-) -> None:
-    """Ensure sensor entities are created and expose values from the coordinator."""
-    unique_id = "40580137858664_L1 Voltage"
-    entity_id = entity_registry.async_get_entity_id("sensor", DOMAIN, unique_id)
-    assert entity_id is not None
-
-    state = hass.states.get(entity_id)
-    assert state is not None
-    assert float(state.state) == 234.5
-
-    mock_homevolt_client.get_device.return_value.sensors["L1 Voltage"].value = 240.1
-    coordinator = mock_config_entry.runtime_data
-    await coordinator.async_refresh()
-    await hass.async_block_till_done()
-
-    state = hass.states.get(entity_id)
-    assert state is not None
-    assert float(state.state) == 240.1

tests/components/light/test_condition.py

@@ -5,7 +5,7 @@ from typing import Any
 import pytest
 
 from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.core import HomeAssistant
 
 from tests.components import (
     ConditionStateDescription,
@@ -137,7 +137,6 @@ async def test_light_state_condition_behavior_any(
 )
 async def test_light_state_condition_behavior_all(
     hass: HomeAssistant,
-    service_calls: list[ServiceCall],
     target_lights: list[str],
     condition_target_config: dict,
     entity_id: str,