Refactor Vodafone Station tests (#134956)

This commit is contained in:
Simone Chemelli 2025-01-09 16:22:37 -05:00 committed by GitHub
parent 1abcac5fb5
commit 0deb46295d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 789 additions and 406 deletions

View File

@ -1 +1,13 @@
"""Tests for the Vodafone Station integration.""" """Tests for the Vodafone Station integration."""
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
async def setup_integration(hass: HomeAssistant, config_entry: MockConfigEntry) -> None:
"""Fixture for setting up the component."""
config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()

View File

@ -2,11 +2,31 @@
from datetime import UTC, datetime from datetime import UTC, datetime
from aiovodafone import VodafoneStationDevice
import pytest import pytest
from .const import DEVICE_DATA_QUERY, SENSOR_DATA_QUERY from homeassistant.components.vodafone_station import DOMAIN
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
from tests.common import AsyncMock, Generator, patch from .const import DEVICE_1_MAC
from tests.common import (
AsyncMock,
Generator,
MockConfigEntry,
load_json_object_fixture,
patch,
)
@pytest.fixture
def mock_setup_entry() -> Generator[AsyncMock]:
"""Override async_setup_entry."""
with patch(
"homeassistant.components.vodafone_station.async_setup_entry",
return_value=True,
) as mock_setup_entry:
yield mock_setup_entry
@pytest.fixture @pytest.fixture
@ -17,12 +37,41 @@ def mock_vodafone_station_router() -> Generator[AsyncMock]:
"homeassistant.components.vodafone_station.coordinator.VodafoneStationSercommApi", "homeassistant.components.vodafone_station.coordinator.VodafoneStationSercommApi",
autospec=True, autospec=True,
) as mock_router, ) as mock_router,
patch(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi",
new=mock_router,
),
): ):
router = mock_router.return_value router = mock_router.return_value
router.get_devices_data.return_value = DEVICE_DATA_QUERY router.get_devices_data.return_value = {
router.get_sensor_data.return_value = SENSOR_DATA_QUERY DEVICE_1_MAC: VodafoneStationDevice(
connected=True,
connection_type="wifi",
ip_address="192.168.1.10",
name="WifiDevice0",
mac=DEVICE_1_MAC,
type="laptop",
wifi="2.4G",
),
}
router.get_sensor_data.return_value = load_json_object_fixture(
"get_sensor_data.json", DOMAIN
)
router.convert_uptime.return_value = datetime( router.convert_uptime.return_value = datetime(
2024, 11, 19, 20, 19, 0, tzinfo=UTC 2024, 11, 19, 20, 19, 0, tzinfo=UTC
) )
router.base_url = "https://fake_host" router.base_url = "https://fake_host"
yield router yield router
@pytest.fixture
def mock_config_entry() -> Generator[MockConfigEntry]:
"""Mock a Vodafone Station config entry."""
return MockConfigEntry(
domain=DOMAIN,
data={
CONF_HOST: "fake_host",
CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
},
)

View File

@ -1,118 +1,3 @@
"""Common stuff for Vodafone Station tests.""" """Common stuff for Vodafone Station tests."""
from aiovodafone.api import VodafoneStationDevice
from homeassistant.components.vodafone_station.const import DOMAIN
from homeassistant.const import CONF_DEVICES, CONF_HOST, CONF_PASSWORD, CONF_USERNAME
MOCK_CONFIG = {
DOMAIN: {
CONF_DEVICES: [
{
CONF_HOST: "fake_host",
CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
}
]
}
}
MOCK_USER_DATA = MOCK_CONFIG[DOMAIN][CONF_DEVICES][0]
DEVICE_1_MAC = "xx:xx:xx:xx:xx:xx" DEVICE_1_MAC = "xx:xx:xx:xx:xx:xx"
DEVICE_1 = {
DEVICE_1_MAC: VodafoneStationDevice(
connected=True,
connection_type="wifi",
ip_address="192.168.1.10",
name="WifiDevice0",
mac=DEVICE_1_MAC,
type="laptop",
wifi="2.4G",
),
}
DEVICE_DATA_QUERY = DEVICE_1
SERIAL = "m123456789"
SENSOR_DATA_QUERY = {
"sys_serial_number": SERIAL,
"sys_firmware_version": "XF6_4.0.05.04",
"sys_bootloader_version": "0220",
"sys_hardware_version": "RHG3006 v1",
"omci_software_version": "\t\t1.0.0.1_41032\t\t\n",
"sys_uptime": "12:16:41",
"sys_cpu_usage": "97%",
"sys_reboot_cause": "Web Reboot",
"sys_memory_usage": "51.94%",
"sys_wireless_driver_version": "17.10.188.75;17.10.188.75",
"sys_wireless_driver_version_5g": "17.10.188.75;17.10.188.75",
"vf_internet_key_online_since": "",
"vf_internet_key_ip_addr": "0.0.0.0",
"vf_internet_key_system": "0.0.0.0",
"vf_internet_key_mode": "Auto",
"sys_voip_version": "v02.01.00_01.13a\n",
"sys_date_time": "20.10.2024 | 03:44 pm",
"sys_build_time": "Sun Jun 23 17:55:49 CST 2024\n",
"sys_model_name": "RHG3006",
"inter_ip_address": "1.1.1.1",
"inter_gateway": "1.1.1.2",
"inter_primary_dns": "1.1.1.3",
"inter_secondary_dns": "1.1.1.4",
"inter_firewall": "601036",
"inter_wan_ip_address": "1.1.1.1",
"inter_ipv6_link_local_address": "",
"inter_ipv6_link_global_address": "",
"inter_ipv6_gateway": "",
"inter_ipv6_prefix_delegation": "",
"inter_ipv6_dns_address1": "",
"inter_ipv6_dns_address2": "",
"lan_ip_network": "192.168.0.1/24",
"lan_default_gateway": "192.168.0.1",
"lan_subnet_address_subnet1": "",
"lan_mac_address": "11:22:33:44:55:66",
"lan_dhcp_server": "601036",
"lan_dhcpv6_server": "601036",
"lan_router_advertisement": "601036",
"lan_ipv6_default_gateway": "fe80::1",
"lan_port1_switch_mode": "1301722",
"lan_port2_switch_mode": "1301722",
"lan_port3_switch_mode": "1301722",
"lan_port4_switch_mode": "1301722",
"lan_port1_switch_speed": "10",
"lan_port2_switch_speed": "100",
"lan_port3_switch_speed": "1000",
"lan_port4_switch_speed": "1000",
"lan_port1_switch_status": "1301724",
"lan_port2_switch_status": "1301724",
"lan_port3_switch_status": "1301724",
"lan_port4_switch_status": "1301724",
"wifi_status": "601036",
"wifi_name": "Wifi-Main-Network",
"wifi_mac_address": "AA:BB:CC:DD:EE:FF",
"wifi_security": "401027",
"wifi_channel": "8",
"wifi_bandwidth": "573",
"guest_wifi_status": "601037",
"guest_wifi_name": "Wifi-Guest",
"guest_wifi_mac_addr": "AA:BB:CC:DD:EE:GG",
"guest_wifi_security": "401027",
"guest_wifi_channel": "N/A",
"guest_wifi_ip": "192.168.2.1",
"guest_wifi_subnet_addr": "255.255.255.0",
"guest_wifi_dhcp_server": "192.168.2.1",
"wifi_status_5g": "601036",
"wifi_name_5g": "Wifi-Main-Network",
"wifi_mac_address_5g": "AA:BB:CC:DD:EE:HH",
"wifi_security_5g": "401027",
"wifi_channel_5g": "36",
"wifi_bandwidth_5g": "4803",
"guest_wifi_status_5g": "601037",
"guest_wifi_name_5g": "Wifi-Guest",
"guest_wifi_mac_addr_5g": "AA:BB:CC:DD:EE:II",
"guest_wifi_channel_5g": "N/A",
"guest_wifi_security_5g": "401027",
"guest_wifi_ip_5g": "192.168.2.1",
"guest_wifi_subnet_addr_5g": "255.255.255.0",
"guest_wifi_dhcp_server_5g": "192.168.2.1",
}

View File

@ -0,0 +1,81 @@
{
"sys_serial_number": "m123456789",
"sys_firmware_version": "XF6_4.0.05.04",
"sys_bootloader_version": "0220",
"sys_hardware_version": "RHG3006 v1",
"omci_software_version": "\t\t1.0.0.1_41032\t\t\n",
"sys_uptime": "12:16:41",
"sys_cpu_usage": "97%",
"sys_reboot_cause": "Web Reboot",
"sys_memory_usage": "51.94%",
"sys_wireless_driver_version": "17.10.188.75;17.10.188.75",
"sys_wireless_driver_version_5g": "17.10.188.75;17.10.188.75",
"vf_internet_key_online_since": "",
"vf_internet_key_ip_addr": "0.0.0.0",
"vf_internet_key_system": "0.0.0.0",
"vf_internet_key_mode": "Auto",
"sys_voip_version": "v02.01.00_01.13a\n",
"sys_date_time": "20.10.2024 | 03:44 pm",
"sys_build_time": "Sun Jun 23 17:55:49 CST 2024\n",
"sys_model_name": "RHG3006",
"inter_ip_address": "1.1.1.1",
"inter_gateway": "1.1.1.2",
"inter_primary_dns": "1.1.1.3",
"inter_secondary_dns": "1.1.1.4",
"inter_firewall": "601036",
"inter_wan_ip_address": "1.1.1.1",
"inter_ipv6_link_local_address": "",
"inter_ipv6_link_global_address": "",
"inter_ipv6_gateway": "",
"inter_ipv6_prefix_delegation": "",
"inter_ipv6_dns_address1": "",
"inter_ipv6_dns_address2": "",
"lan_ip_network": "192.168.0.1/24",
"lan_default_gateway": "192.168.0.1",
"lan_subnet_address_subnet1": "",
"lan_mac_address": "11:22:33:44:55:66",
"lan_dhcp_server": "601036",
"lan_dhcpv6_server": "601036",
"lan_router_advertisement": "601036",
"lan_ipv6_default_gateway": "fe80::1",
"lan_port1_switch_mode": "1301722",
"lan_port2_switch_mode": "1301722",
"lan_port3_switch_mode": "1301722",
"lan_port4_switch_mode": "1301722",
"lan_port1_switch_speed": "10",
"lan_port2_switch_speed": "100",
"lan_port3_switch_speed": "1000",
"lan_port4_switch_speed": "1000",
"lan_port1_switch_status": "1301724",
"lan_port2_switch_status": "1301724",
"lan_port3_switch_status": "1301724",
"lan_port4_switch_status": "1301724",
"wifi_status": "601036",
"wifi_name": "Wifi-Main-Network",
"wifi_mac_address": "AA:BB:CC:DD:EE:FF",
"wifi_security": "401027",
"wifi_channel": "8",
"wifi_bandwidth": "573",
"guest_wifi_status": "601037",
"guest_wifi_name": "Wifi-Guest",
"guest_wifi_mac_addr": "AA:BB:CC:DD:EE:GG",
"guest_wifi_security": "401027",
"guest_wifi_channel": "N/A",
"guest_wifi_ip": "192.168.2.1",
"guest_wifi_subnet_addr": "255.255.255.0",
"guest_wifi_dhcp_server": "192.168.2.1",
"wifi_status_5g": "601036",
"wifi_name_5g": "Wifi-Main-Network",
"wifi_mac_address_5g": "AA:BB:CC:DD:EE:HH",
"wifi_security_5g": "401027",
"wifi_channel_5g": "36",
"wifi_bandwidth_5g": "4803",
"guest_wifi_status_5g": "601037",
"guest_wifi_name_5g": "Wifi-Guest",
"guest_wifi_mac_addr_5g": "AA:BB:CC:DD:EE:II",
"guest_wifi_channel_5g": "N/A",
"guest_wifi_security_5g": "401027",
"guest_wifi_ip_5g": "192.168.2.1",
"guest_wifi_subnet_addr_5g": "255.255.255.0",
"guest_wifi_dhcp_server_5g": "192.168.2.1"
}

View File

@ -0,0 +1,48 @@
# serializer version: 1
# name: test_all_entities[button.vodafone_station_m123456789_restart-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'button',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'button.vodafone_station_m123456789_restart',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <ButtonDeviceClass.RESTART: 'restart'>,
'original_icon': None,
'original_name': 'Restart',
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': 'm123456789_reboot',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[button.vodafone_station_m123456789_restart-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'restart',
'friendly_name': 'Vodafone Station (m123456789) Restart',
}),
'context': <ANY>,
'entity_id': 'button.vodafone_station_m123456789_restart',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---

View File

@ -0,0 +1,50 @@
# serializer version: 1
# name: test_all_entities[device_tracker.vodafone_station_xx_xx_xx_xx_xx_xx-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'device_tracker',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'device_tracker.vodafone_station_xx_xx_xx_xx_xx_xx',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': None,
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'device_tracker',
'unique_id': 'xx:xx:xx:xx:xx:xx',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[device_tracker.vodafone_station_xx_xx_xx_xx_xx_xx-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'host_name': 'WifiDevice0',
'ip': '192.168.1.10',
'mac': 'xx:xx:xx:xx:xx:xx',
'source_type': <SourceType.ROUTER: 'router'>,
}),
'context': <ANY>,
'entity_id': 'device_tracker.vodafone_station_xx_xx_xx_xx_xx_xx',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'home',
})
# ---

View File

@ -0,0 +1,246 @@
# serializer version: 1
# name: test_all_entities[sensor.vodafone_station_m123456789_active_connection-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'dsl',
'fiber',
'internet_key',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.vodafone_station_m123456789_active_connection',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'Active connection',
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'active_connection',
'unique_id': 'm123456789_inter_ip_address',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_active_connection-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'enum',
'friendly_name': 'Vodafone Station (m123456789) Active connection',
'options': list([
'dsl',
'fiber',
'internet_key',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.vodafone_station_m123456789_active_connection',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_cpu_usage-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.vodafone_station_m123456789_cpu_usage',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'CPU usage',
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'sys_cpu_usage',
'unique_id': 'm123456789_sys_cpu_usage',
'unit_of_measurement': '%',
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_cpu_usage-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Vodafone Station (m123456789) CPU usage',
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.vodafone_station_m123456789_cpu_usage',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '97.0',
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_memory_usage-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.vodafone_station_m123456789_memory_usage',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Memory usage',
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'sys_memory_usage',
'unique_id': 'm123456789_sys_memory_usage',
'unit_of_measurement': '%',
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_memory_usage-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Vodafone Station (m123456789) Memory usage',
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.vodafone_station_m123456789_memory_usage',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '51.94',
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_reboot_cause-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.vodafone_station_m123456789_reboot_cause',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Reboot cause',
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'sys_reboot_cause',
'unique_id': 'm123456789_sys_reboot_cause',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_reboot_cause-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Vodafone Station (m123456789) Reboot cause',
}),
'context': <ANY>,
'entity_id': 'sensor.vodafone_station_m123456789_reboot_cause',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'Web Reboot',
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_uptime-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.vodafone_station_m123456789_uptime',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TIMESTAMP: 'timestamp'>,
'original_icon': None,
'original_name': 'Uptime',
'platform': 'vodafone_station',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'sys_uptime',
'unique_id': 'm123456789_sys_uptime',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[sensor.vodafone_station_m123456789_uptime-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'timestamp',
'friendly_name': 'Vodafone Station (m123456789) Uptime',
}),
'context': <ANY>,
'entity_id': 'sensor.vodafone_station_m123456789_uptime',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '2024-11-19T20:19:00+00:00',
})
# ---

View File

@ -1,56 +1,48 @@
"""Tests for Vodafone Station button platform.""" """Tests for Vodafone Station button platform."""
from unittest.mock import patch from unittest.mock import AsyncMock, patch
from syrupy import SnapshotAssertion
from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
from homeassistant.components.vodafone_station.const import DOMAIN from homeassistant.const import ATTR_ENTITY_ID, Platform
from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_registry import EntityRegistry from homeassistant.helpers import entity_registry as er
from .const import DEVICE_DATA_QUERY, MOCK_USER_DATA, SENSOR_DATA_QUERY, SERIAL from . import setup_integration
from tests.common import MockConfigEntry from tests.common import MockConfigEntry, snapshot_platform
async def test_button(hass: HomeAssistant, entity_registry: EntityRegistry) -> None: async def test_all_entities(
hass: HomeAssistant,
snapshot: SnapshotAssertion,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
entity_registry: er.EntityRegistry,
) -> None:
"""Test all entities."""
with patch(
"homeassistant.components.vodafone_station.PLATFORMS", [Platform.BUTTON]
):
await setup_integration(hass, mock_config_entry)
await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
async def test_pressing_button(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test device restart button.""" """Test device restart button."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) await setup_integration(hass, mock_config_entry)
entry.add_to_hass(hass)
with ( await hass.services.async_call(
patch("aiovodafone.api.VodafoneStationSercommApi.login"), BUTTON_DOMAIN,
patch( SERVICE_PRESS,
"aiovodafone.api.VodafoneStationSercommApi.get_devices_data", {ATTR_ENTITY_ID: "button.vodafone_station_m123456789_restart"},
return_value=DEVICE_DATA_QUERY, blocking=True,
), )
patch( mock_vodafone_station_router.restart_router.assert_called_once()
"aiovodafone.api.VodafoneStationSercommApi.get_sensor_data",
return_value=SENSOR_DATA_QUERY,
),
patch(
"aiovodafone.api.VodafoneStationSercommApi.restart_router",
) as mock_router_restart,
):
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
entity_id = f"button.vodafone_station_{SERIAL}_restart"
# restart button
state = hass.states.get(entity_id)
assert state
assert state.state == STATE_UNKNOWN
entry = entity_registry.async_get(entity_id)
assert entry
assert entry.unique_id == f"{SERIAL}_reboot"
await hass.services.async_call(
BUTTON_DOMAIN,
SERVICE_PRESS,
{ATTR_ENTITY_ID: entity_id},
blocking=True,
)
assert mock_router_restart.call_count == 1

View File

@ -1,8 +1,13 @@
"""Tests for Vodafone Station config flow.""" """Tests for Vodafone Station config flow."""
from unittest.mock import patch from unittest.mock import AsyncMock
from aiovodafone import exceptions as aiovodafone_exceptions from aiovodafone import (
AlreadyLogged,
CannotAuthenticate,
CannotConnect,
ModelNotSupported,
)
import pytest import pytest
from homeassistant.components.device_tracker import CONF_CONSIDER_HOME from homeassistant.components.device_tracker import CONF_CONSIDER_HOME
@ -12,39 +17,36 @@ from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResultType from homeassistant.data_entry_flow import FlowResultType
from .const import MOCK_USER_DATA
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
async def test_user(hass: HomeAssistant) -> None: async def test_user(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_setup_entry: AsyncMock,
) -> None:
"""Test starting a flow by user.""" """Test starting a flow by user."""
with ( result = await hass.config_entries.flow.async_init(
patch( DOMAIN, context={"source": SOURCE_USER}
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.login", )
), assert result["type"] is FlowResultType.FORM
patch( assert result["step_id"] == "user"
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.logout",
),
patch(
"homeassistant.components.vodafone_station.async_setup_entry"
) as mock_setup_entry,
):
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_USER}
)
assert result["type"] is FlowResultType.FORM
assert result["step_id"] == "user"
result = await hass.config_entries.flow.async_configure( result = await hass.config_entries.flow.async_configure(
result["flow_id"], user_input=MOCK_USER_DATA result["flow_id"],
) user_input={
assert result["type"] is FlowResultType.CREATE_ENTRY CONF_HOST: "fake_host",
assert result["data"][CONF_HOST] == "fake_host" CONF_USERNAME: "fake_username",
assert result["data"][CONF_USERNAME] == "fake_username" CONF_PASSWORD: "fake_password",
assert result["data"][CONF_PASSWORD] == "fake_password" },
assert not result["result"].unique_id )
await hass.async_block_till_done() assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["data"] == {
CONF_HOST: "fake_host",
CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
}
assert not result["result"].unique_id
assert mock_setup_entry.called assert mock_setup_entry.called
@ -52,14 +54,20 @@ async def test_user(hass: HomeAssistant) -> None:
@pytest.mark.parametrize( @pytest.mark.parametrize(
("side_effect", "error"), ("side_effect", "error"),
[ [
(aiovodafone_exceptions.CannotConnect, "cannot_connect"), (CannotConnect, "cannot_connect"),
(aiovodafone_exceptions.CannotAuthenticate, "invalid_auth"), (CannotAuthenticate, "invalid_auth"),
(aiovodafone_exceptions.AlreadyLogged, "already_logged"), (AlreadyLogged, "already_logged"),
(aiovodafone_exceptions.ModelNotSupported, "model_not_supported"), (ModelNotSupported, "model_not_supported"),
(ConnectionResetError, "unknown"), (ConnectionResetError, "unknown"),
], ],
) )
async def test_exception_connection(hass: HomeAssistant, side_effect, error) -> None: async def test_exception_connection(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_setup_entry: AsyncMock,
side_effect: Exception,
error: str,
) -> None:
"""Test starting a flow by user with a connection error.""" """Test starting a flow by user with a connection error."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
@ -68,178 +76,153 @@ async def test_exception_connection(hass: HomeAssistant, side_effect, error) ->
assert result.get("type") is FlowResultType.FORM assert result.get("type") is FlowResultType.FORM
assert result.get("step_id") == "user" assert result.get("step_id") == "user"
with patch( mock_vodafone_station_router.login.side_effect = side_effect
"aiovodafone.api.VodafoneStationSercommApi.login",
side_effect=side_effect,
):
result = await hass.config_entries.flow.async_configure(
result["flow_id"], user_input=MOCK_USER_DATA
)
assert result["type"] is FlowResultType.FORM result = await hass.config_entries.flow.async_configure(
assert result["step_id"] == "user" result["flow_id"],
assert result["errors"] is not None user_input={
assert result["errors"]["base"] == error CONF_HOST: "fake_host",
CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
},
)
# Should be recoverable after hits error assert result["type"] is FlowResultType.FORM
with ( assert result["step_id"] == "user"
patch( assert result["errors"] == {"base": error}
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.get_devices_data",
return_value={
"wifi_user": "on|laptop|device-1|xx:xx:xx:xx:xx:xx|192.168.100.1||2.4G",
"ethernet": "laptop|device-2|yy:yy:yy:yy:yy:yy|192.168.100.2|;",
},
),
patch(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.login",
),
patch(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.logout",
),
patch(
"homeassistant.components.vodafone_station.async_setup_entry",
),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_HOST: "fake_host",
CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
},
)
await hass.async_block_till_done()
assert result2["type"] is FlowResultType.CREATE_ENTRY mock_vodafone_station_router.login.side_effect = None
assert result2["title"] == "fake_host"
assert result2["data"] == { result = await hass.config_entries.flow.async_configure(
"host": "fake_host", result["flow_id"],
"username": "fake_username", user_input={
"password": "fake_password", CONF_HOST: "fake_host",
} CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
},
)
assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["title"] == "fake_host"
assert result["data"] == {
"host": "fake_host",
"username": "fake_username",
"password": "fake_password",
}
async def test_reauth_successful(hass: HomeAssistant) -> None: async def test_duplicate_entry(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test starting a flow by user with a duplicate entry."""
mock_config_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"
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_HOST: "fake_host",
CONF_USERNAME: "fake_username",
CONF_PASSWORD: "fake_password",
},
)
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "already_configured"
async def test_reauth_successful(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_setup_entry: AsyncMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test starting a reauthentication flow.""" """Test starting a reauthentication flow."""
mock_config_entry.add_to_hass(hass)
mock_config = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) result = await mock_config_entry.start_reauth_flow(hass)
mock_config.add_to_hass(hass)
result = await mock_config.start_reauth_flow(hass)
assert result["type"] is FlowResultType.FORM assert result["type"] is FlowResultType.FORM
assert result["step_id"] == "reauth_confirm" assert result["step_id"] == "reauth_confirm"
with ( result = await hass.config_entries.flow.async_configure(
patch( result["flow_id"],
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.login", user_input={
), CONF_PASSWORD: "other_fake_password",
patch( },
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.logout", )
),
patch(
"homeassistant.components.vodafone_station.async_setup_entry",
),
):
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_PASSWORD: "other_fake_password",
},
)
await hass.async_block_till_done()
assert result["type"] is FlowResultType.ABORT assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "reauth_successful" assert result["reason"] == "reauth_successful"
@pytest.mark.parametrize( @pytest.mark.parametrize(
("side_effect", "error"), ("side_effect", "error"),
[ [
(aiovodafone_exceptions.CannotConnect, "cannot_connect"), (CannotConnect, "cannot_connect"),
(aiovodafone_exceptions.CannotAuthenticate, "invalid_auth"), (CannotAuthenticate, "invalid_auth"),
(aiovodafone_exceptions.AlreadyLogged, "already_logged"), (AlreadyLogged, "already_logged"),
(ConnectionResetError, "unknown"), (ConnectionResetError, "unknown"),
], ],
) )
async def test_reauth_not_successful(hass: HomeAssistant, side_effect, error) -> None: async def test_reauth_not_successful(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_setup_entry: AsyncMock,
mock_config_entry: MockConfigEntry,
side_effect: Exception,
error: str,
) -> None:
"""Test starting a reauthentication flow but no connection found.""" """Test starting a reauthentication flow but no connection found."""
mock_config_entry.add_to_hass(hass)
mock_config = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) result = await mock_config_entry.start_reauth_flow(hass)
mock_config.add_to_hass(hass)
result = await mock_config.start_reauth_flow(hass)
assert result["type"] is FlowResultType.FORM assert result["type"] is FlowResultType.FORM
assert result["step_id"] == "reauth_confirm" assert result["step_id"] == "reauth_confirm"
with ( mock_vodafone_station_router.login.side_effect = side_effect
patch( result = await hass.config_entries.flow.async_configure(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.login", result["flow_id"],
side_effect=side_effect, user_input={
), CONF_PASSWORD: "other_fake_password",
patch( },
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.logout", )
),
patch(
"homeassistant.components.vodafone_station.async_setup_entry",
),
):
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_PASSWORD: "other_fake_password",
},
)
assert result["type"] is FlowResultType.FORM assert result["type"] is FlowResultType.FORM
assert result["step_id"] == "reauth_confirm" assert result["step_id"] == "reauth_confirm"
assert result["errors"] is not None assert result["errors"] == {"base": error}
assert result["errors"]["base"] == error
# Should be recoverable after hits error mock_vodafone_station_router.login.side_effect = None
with (
patch(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.get_devices_data",
return_value={
"wifi_user": "on|laptop|device-1|xx:xx:xx:xx:xx:xx|192.168.100.1||2.4G",
"ethernet": "laptop|device-2|yy:yy:yy:yy:yy:yy|192.168.100.2|;",
},
),
patch(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.login",
),
patch(
"homeassistant.components.vodafone_station.config_flow.VodafoneStationSercommApi.logout",
),
patch(
"homeassistant.components.vodafone_station.async_setup_entry",
),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_PASSWORD: "fake_password",
},
)
await hass.async_block_till_done()
assert result2["type"] is FlowResultType.ABORT result = await hass.config_entries.flow.async_configure(
assert result2["reason"] == "reauth_successful" result["flow_id"],
user_input={
CONF_PASSWORD: "fake_password",
},
)
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "reauth_successful"
assert mock_config_entry.data[CONF_PASSWORD] == "fake_password"
async def test_options_flow(hass: HomeAssistant) -> None: async def test_options_flow(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_setup_entry: AsyncMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test options flow.""" """Test options flow."""
mock_config_entry.add_to_hass(hass)
mock_config = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) result = await hass.config_entries.options.async_init(mock_config_entry.entry_id)
mock_config.add_to_hass(hass)
result = await hass.config_entries.options.async_init(mock_config.entry_id)
await hass.async_block_till_done()
result = await hass.config_entries.options.async_configure( result = await hass.config_entries.options.async_configure(
result["flow_id"], result["flow_id"],
user_input={ user_input={
CONF_CONSIDER_HOME: 37, CONF_CONSIDER_HOME: 37,
}, },
) )
await hass.async_block_till_done()
assert result["type"] is FlowResultType.CREATE_ENTRY assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["data"] == { assert result["data"] == {

View File

@ -1,43 +1,59 @@
"""Define tests for the Vodafone Station device tracker.""" """Define tests for the Vodafone Station device tracker."""
from unittest.mock import AsyncMock from unittest.mock import AsyncMock, patch
from freezegun.api import FrozenDateTimeFactory from freezegun.api import FrozenDateTimeFactory
import pytest import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.vodafone_station.const import DOMAIN, SCAN_INTERVAL from homeassistant.components.vodafone_station.const import SCAN_INTERVAL
from homeassistant.components.vodafone_station.coordinator import CONSIDER_HOME_SECONDS from homeassistant.components.vodafone_station.coordinator import CONSIDER_HOME_SECONDS
from homeassistant.const import STATE_HOME, STATE_NOT_HOME from homeassistant.const import STATE_HOME, STATE_NOT_HOME, Platform
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .const import DEVICE_1, DEVICE_1_MAC, DEVICE_DATA_QUERY, MOCK_USER_DATA from . import setup_integration
from .const import DEVICE_1_MAC
from tests.common import MockConfigEntry, async_fire_time_changed from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
@pytest.mark.usefixtures("entity_registry_enabled_by_default") @pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_coordinator_consider_home( async def test_all_entities(
hass: HomeAssistant, hass: HomeAssistant,
freezer: FrozenDateTimeFactory, snapshot: SnapshotAssertion,
mock_vodafone_station_router: AsyncMock, mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
entity_registry: er.EntityRegistry,
) -> None:
"""Test all entities."""
with patch(
"homeassistant.components.vodafone_station.PLATFORMS", [Platform.DEVICE_TRACKER]
):
await setup_integration(hass, mock_config_entry)
await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_consider_home(
hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
freezer: FrozenDateTimeFactory,
) -> None: ) -> None:
"""Test if device is considered not_home when disconnected.""" """Test if device is considered not_home when disconnected."""
await setup_integration(hass, mock_config_entry)
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) device_tracker = "device_tracker.vodafone_station_xx_xx_xx_xx_xx_xx"
entry.add_to_hass(hass)
device_tracker = f"device_tracker.vodafone_station_{DEVICE_1_MAC.replace(":", "_")}"
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
state = hass.states.get(device_tracker) state = hass.states.get(device_tracker)
assert state assert state
assert state.state == STATE_HOME assert state.state == STATE_HOME
DEVICE_1[DEVICE_1_MAC].connected = False mock_vodafone_station_router.get_devices_data.return_value[
DEVICE_DATA_QUERY.update(DEVICE_1) DEVICE_1_MAC
mock_vodafone_station_router.get_devices_data.return_value = DEVICE_DATA_QUERY ].connected = False
freezer.tick(SCAN_INTERVAL + CONSIDER_HOME_SECONDS) freezer.tick(SCAN_INTERVAL + CONSIDER_HOME_SECONDS)
async_fire_time_changed(hass) async_fire_time_changed(hass)

View File

@ -2,16 +2,14 @@
from __future__ import annotations from __future__ import annotations
from unittest.mock import patch from unittest.mock import AsyncMock
from syrupy import SnapshotAssertion from syrupy import SnapshotAssertion
from syrupy.filters import props from syrupy.filters import props
from homeassistant.components.vodafone_station.const import DOMAIN
from homeassistant.config_entries import ConfigEntryState
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from .const import DEVICE_DATA_QUERY, MOCK_USER_DATA, SENSOR_DATA_QUERY from . import setup_integration
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
from tests.components.diagnostics import get_diagnostics_for_config_entry from tests.components.diagnostics import get_diagnostics_for_config_entry
@ -20,29 +18,17 @@ from tests.typing import ClientSessionGenerator
async def test_entry_diagnostics( async def test_entry_diagnostics(
hass: HomeAssistant, hass: HomeAssistant,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
hass_client: ClientSessionGenerator, hass_client: ClientSessionGenerator,
snapshot: SnapshotAssertion, snapshot: SnapshotAssertion,
) -> None: ) -> None:
"""Test config entry diagnostics.""" """Test config entry diagnostics."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) await setup_integration(hass, mock_config_entry)
entry.add_to_hass(hass)
with ( assert await get_diagnostics_for_config_entry(
patch("aiovodafone.api.VodafoneStationSercommApi.login"), hass, hass_client, mock_config_entry
patch( ) == snapshot(
"aiovodafone.api.VodafoneStationSercommApi.get_devices_data",
return_value=DEVICE_DATA_QUERY,
),
patch(
"aiovodafone.api.VodafoneStationSercommApi.get_sensor_data",
return_value=SENSOR_DATA_QUERY,
),
):
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert entry.state == ConfigEntryState.LOADED
assert await get_diagnostics_for_config_entry(hass, hass_client, entry) == snapshot(
exclude=props( exclude=props(
"entry_id", "entry_id",
"created_at", "created_at",

View File

@ -1,21 +1,37 @@
"""Tests for Vodafone Station sensor platform.""" """Tests for Vodafone Station sensor platform."""
from copy import deepcopy from unittest.mock import AsyncMock, patch
from unittest.mock import AsyncMock
from aiovodafone import CannotAuthenticate
from aiovodafone.exceptions import AlreadyLogged, CannotConnect
from freezegun.api import FrozenDateTimeFactory from freezegun.api import FrozenDateTimeFactory
import pytest import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.vodafone_station.const import ( from homeassistant.components.vodafone_station.const import LINE_TYPES, SCAN_INTERVAL
DOMAIN, from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN, Platform
LINE_TYPES,
SCAN_INTERVAL,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .const import MOCK_USER_DATA, SENSOR_DATA_QUERY from . import setup_integration
from tests.common import MockConfigEntry, async_fire_time_changed from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
async def test_all_entities(
hass: HomeAssistant,
snapshot: SnapshotAssertion,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
entity_registry: er.EntityRegistry,
) -> None:
"""Test all entities."""
with patch(
"homeassistant.components.vodafone_station.PLATFORMS", [Platform.SENSOR]
):
await setup_integration(hass, mock_config_entry)
await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -30,26 +46,22 @@ async def test_active_connection_type(
hass: HomeAssistant, hass: HomeAssistant,
freezer: FrozenDateTimeFactory, freezer: FrozenDateTimeFactory,
mock_vodafone_station_router: AsyncMock, mock_vodafone_station_router: AsyncMock,
connection_type, mock_config_entry: MockConfigEntry,
index, connection_type: str,
index: int,
) -> None: ) -> None:
"""Test device connection type.""" """Test device connection type."""
await setup_integration(hass, mock_config_entry)
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) active_connection_entity = "sensor.vodafone_station_m123456789_active_connection"
entry.add_to_hass(hass)
active_connection_entity = f"sensor.vodafone_station_{SENSOR_DATA_QUERY['sys_serial_number']}_active_connection"
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
state = hass.states.get(active_connection_entity) state = hass.states.get(active_connection_entity)
assert state assert state
assert state.state == "unknown" assert state.state == STATE_UNKNOWN
sensor_data = deepcopy(SENSOR_DATA_QUERY) mock_vodafone_station_router.get_sensor_data.return_value[connection_type] = (
sensor_data[connection_type] = "1.1.1.1" "1.1.1.1"
mock_vodafone_station_router.get_sensor_data.return_value = sensor_data )
freezer.tick(SCAN_INTERVAL) freezer.tick(SCAN_INTERVAL)
async_fire_time_changed(hass) async_fire_time_changed(hass)
@ -65,19 +77,13 @@ async def test_uptime(
hass: HomeAssistant, hass: HomeAssistant,
freezer: FrozenDateTimeFactory, freezer: FrozenDateTimeFactory,
mock_vodafone_station_router: AsyncMock, mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
) -> None: ) -> None:
"""Test device uptime shift.""" """Test device uptime shift."""
await setup_integration(hass, mock_config_entry)
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass)
uptime = "2024-11-19T20:19:00+00:00" uptime = "2024-11-19T20:19:00+00:00"
uptime_entity = ( uptime_entity = "sensor.vodafone_station_m123456789_uptime"
f"sensor.vodafone_station_{SENSOR_DATA_QUERY['sys_serial_number']}_uptime"
)
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
state = hass.states.get(uptime_entity) state = hass.states.get(uptime_entity)
assert state assert state
@ -92,3 +98,32 @@ async def test_uptime(
state = hass.states.get(uptime_entity) state = hass.states.get(uptime_entity)
assert state assert state
assert state.state == uptime assert state.state == uptime
@pytest.mark.parametrize(
"side_effect",
[
CannotConnect,
CannotAuthenticate,
AlreadyLogged,
ConnectionResetError,
],
)
async def test_coordinator_client_connector_error(
hass: HomeAssistant,
freezer: FrozenDateTimeFactory,
mock_vodafone_station_router: AsyncMock,
mock_config_entry: MockConfigEntry,
side_effect: Exception,
) -> None:
"""Test ClientConnectorError on coordinator update."""
await setup_integration(hass, mock_config_entry)
mock_vodafone_station_router.get_devices_data.side_effect = side_effect
freezer.tick(SCAN_INTERVAL)
async_fire_time_changed(hass)
await hass.async_block_till_done(wait_background_tasks=True)
state = hass.states.get("sensor.vodafone_station_m123456789_uptime")
assert state
assert state.state == STATE_UNAVAILABLE