Use snapshot_platform in all platform test modules for AVM Fritz!SmartHome (#142093)

use snapshot_platform in all platform test modules
This commit is contained in:
Michael 2025-04-03 00:14:07 +02:00 committed by GitHub
parent 02ca1f2889
commit 33d895bc7d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 1683 additions and 457 deletions

View File

@ -25,7 +25,7 @@ async def setup_config_entry(
device: Mock | None = None, device: Mock | None = None,
fritz: Mock | None = None, fritz: Mock | None = None,
template: Mock | None = None, template: Mock | None = None,
) -> bool: ) -> MockConfigEntry:
"""Do setup of a MockConfigEntry.""" """Do setup of a MockConfigEntry."""
entry = MockConfigEntry( entry = MockConfigEntry(
domain=DOMAIN, domain=DOMAIN,
@ -39,10 +39,10 @@ async def setup_config_entry(
if template is not None and fritz is not None: if template is not None and fritz is not None:
fritz().get_templates.return_value = [template] fritz().get_templates.return_value = [template]
result = await hass.config_entries.async_setup(entry.entry_id) await hass.config_entries.async_setup(entry.entry_id)
if device is not None: if device is not None:
await hass.async_block_till_done() await hass.async_block_till_done()
return result return entry
def set_devices( def set_devices(

View File

@ -0,0 +1,145 @@
# serializer version: 1
# name: test_setup[binary_sensor.fake_name_alarm-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.fake_name_alarm',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.WINDOW: 'window'>,
'original_icon': None,
'original_name': 'Alarm',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'alarm',
'unique_id': '12345 1234567_alarm',
'unit_of_measurement': None,
})
# ---
# name: test_setup[binary_sensor.fake_name_alarm-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'window',
'friendly_name': 'fake_name Alarm',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.fake_name_alarm',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_setup[binary_sensor.fake_name_button_lock_on_device-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'binary_sensor.fake_name_button_lock_on_device',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.LOCK: 'lock'>,
'original_icon': None,
'original_name': 'Button lock on device',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'lock',
'unique_id': '12345 1234567_lock',
'unit_of_measurement': None,
})
# ---
# name: test_setup[binary_sensor.fake_name_button_lock_on_device-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'lock',
'friendly_name': 'fake_name Button lock on device',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.fake_name_button_lock_on_device',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_setup[binary_sensor.fake_name_button_lock_via_ui-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'binary_sensor.fake_name_button_lock_via_ui',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.LOCK: 'lock'>,
'original_icon': None,
'original_name': 'Button lock via UI',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'device_lock',
'unique_id': '12345 1234567_device_lock',
'unit_of_measurement': None,
})
# ---
# name: test_setup[binary_sensor.fake_name_button_lock_via_ui-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'lock',
'friendly_name': 'fake_name Button lock via UI',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.fake_name_button_lock_via_ui',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---

View File

@ -0,0 +1,48 @@
# serializer version: 1
# name: test_setup[button.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'button',
'entity_category': None,
'entity_id': 'button.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup[button.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'fake_name',
}),
'context': <ANY>,
'entity_id': 'button.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---

View File

@ -0,0 +1,80 @@
# serializer version: 1
# name: test_setup[climate.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'hvac_modes': list([
<HVACMode.HEAT: 'heat'>,
<HVACMode.OFF: 'off'>,
]),
'max_temp': 28.0,
'min_temp': 8.0,
'preset_modes': list([
'eco',
'comfort',
'boost',
]),
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': <ClimateEntityFeature: 401>,
'translation_key': 'thermostat',
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup[climate.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'battery_level': 23,
'battery_low': True,
'current_temperature': 18.0,
'friendly_name': 'fake_name',
'holiday_mode': False,
'hvac_modes': list([
<HVACMode.HEAT: 'heat'>,
<HVACMode.OFF: 'off'>,
]),
'max_temp': 28.0,
'min_temp': 8.0,
'preset_mode': None,
'preset_modes': list([
'eco',
'comfort',
'boost',
]),
'summer_mode': False,
'supported_features': <ClimateEntityFeature: 401>,
'temperature': 19.5,
'window_open': 'fake_window',
}),
'context': <ANY>,
'entity_id': 'climate.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'heat',
})
# ---

View File

@ -0,0 +1,51 @@
# serializer version: 1
# name: test_setup[cover.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'cover',
'entity_category': None,
'entity_id': 'cover.fake_name',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <CoverDeviceClass.BLIND: 'blind'>,
'original_icon': None,
'original_name': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': <CoverEntityFeature: 15>,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup[cover.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_position': 100,
'device_class': 'blind',
'friendly_name': 'fake_name',
'supported_features': <CoverEntityFeature: 15>,
}),
'context': <ANY>,
'entity_id': 'cover.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'open',
})
# ---

View File

@ -0,0 +1,278 @@
# serializer version: 1
# name: test_setup[light.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6500,
'max_mireds': 370,
'min_color_temp_kelvin': 2700,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
]),
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup[light.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 100,
'color_mode': <ColorMode.COLOR_TEMP: 'color_temp'>,
'color_temp': 370,
'color_temp_kelvin': 2700,
'friendly_name': 'fake_name',
'hs_color': tuple(
28.395,
65.723,
),
'max_color_temp_kelvin': 6500,
'max_mireds': 370,
'min_color_temp_kelvin': 2700,
'min_mireds': 153,
'rgb_color': tuple(
255,
167,
87,
),
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
]),
'supported_features': <LightEntityFeature: 0>,
'xy_color': tuple(
0.525,
0.388,
),
}),
'context': <ANY>,
'entity_id': 'light.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_setup_color[light.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6500,
'max_mireds': 370,
'min_color_temp_kelvin': 2700,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
]),
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup_color[light.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 100,
'color_mode': <ColorMode.HS: 'hs'>,
'color_temp': None,
'color_temp_kelvin': None,
'friendly_name': 'fake_name',
'hs_color': tuple(
100,
70.0,
),
'max_color_temp_kelvin': 6500,
'max_mireds': 370,
'min_color_temp_kelvin': 2700,
'min_mireds': 153,
'rgb_color': tuple(
136,
255,
77,
),
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
]),
'supported_features': <LightEntityFeature: 0>,
'xy_color': tuple(
0.271,
0.609,
),
}),
'context': <ANY>,
'entity_id': 'light.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_setup_non_color[light.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup_non_color[light.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 100,
'color_mode': <ColorMode.BRIGHTNESS: 'brightness'>,
'friendly_name': 'fake_name',
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_setup_non_color_non_level[light.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.ONOFF: 'onoff'>,
]),
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup_non_color_non_level[light.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'color_mode': <ColorMode.ONOFF: 'onoff'>,
'friendly_name': 'fake_name',
'supported_color_modes': list([
<ColorMode.ONOFF: 'onoff'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

View File

@ -0,0 +1,810 @@
# serializer version: 1
# name: test_setup[FritzDeviceBinarySensorMock][sensor.fake_name_battery-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': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_battery',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
'original_icon': None,
'original_name': 'Battery',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_battery',
'unit_of_measurement': '%',
})
# ---
# name: test_setup[FritzDeviceBinarySensorMock][sensor.fake_name_battery-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'battery',
'friendly_name': 'fake_name Battery',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_battery',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '23',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_battery-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': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_battery',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
'original_icon': None,
'original_name': 'Battery',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_battery',
'unit_of_measurement': '%',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_battery-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'battery',
'friendly_name': 'fake_name Battery',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_battery',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '23',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_comfort_temperature-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_comfort_temperature',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
'original_name': 'Comfort temperature',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'comfort_temperature',
'unique_id': '12345 1234567_comfort_temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_comfort_temperature-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'temperature',
'friendly_name': 'fake_name Comfort temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_comfort_temperature',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '22.0',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_current_scheduled_preset-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_current_scheduled_preset',
'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': 'Current scheduled preset',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'scheduled_preset',
'unique_id': '12345 1234567_scheduled_preset',
'unit_of_measurement': None,
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_current_scheduled_preset-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'fake_name Current scheduled preset',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_current_scheduled_preset',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'eco',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_eco_temperature-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_eco_temperature',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
'original_name': 'Eco temperature',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'eco_temperature',
'unique_id': '12345 1234567_eco_temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_eco_temperature-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'temperature',
'friendly_name': 'fake_name Eco temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_eco_temperature',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '16.0',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_next_scheduled_change_time-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_next_scheduled_change_time',
'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': 'Next scheduled change time',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'nextchange_time',
'unique_id': '12345 1234567_nextchange_time',
'unit_of_measurement': None,
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_next_scheduled_change_time-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'timestamp',
'friendly_name': 'fake_name Next scheduled change time',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_next_scheduled_change_time',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '2024-09-20T18:00:00+00:00',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_next_scheduled_preset-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_next_scheduled_preset',
'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': 'Next scheduled preset',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'nextchange_preset',
'unique_id': '12345 1234567_nextchange_preset',
'unit_of_measurement': None,
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_next_scheduled_preset-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'fake_name Next scheduled preset',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_next_scheduled_preset',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'comfort',
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_next_scheduled_temperature-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_next_scheduled_temperature',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
'original_name': 'Next scheduled temperature',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'nextchange_temperature',
'unique_id': '12345 1234567_nextchange_temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
})
# ---
# name: test_setup[FritzDeviceClimateMock][sensor.fake_name_next_scheduled_temperature-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'temperature',
'friendly_name': 'fake_name Next scheduled temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_next_scheduled_temperature',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '22.0',
})
# ---
# name: test_setup[FritzDeviceSensorMock][sensor.fake_name_battery-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': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_battery',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
'original_icon': None,
'original_name': 'Battery',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_battery',
'unit_of_measurement': '%',
})
# ---
# name: test_setup[FritzDeviceSensorMock][sensor.fake_name_battery-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'battery',
'friendly_name': 'fake_name Battery',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_battery',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '23',
})
# ---
# name: test_setup[FritzDeviceSensorMock][sensor.fake_name_humidity-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.fake_name_humidity',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.HUMIDITY: 'humidity'>,
'original_icon': None,
'original_name': 'Humidity',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_humidity',
'unit_of_measurement': '%',
})
# ---
# name: test_setup[FritzDeviceSensorMock][sensor.fake_name_humidity-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'humidity',
'friendly_name': 'fake_name Humidity',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_humidity',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '42',
})
# ---
# name: test_setup[FritzDeviceSensorMock][sensor.fake_name_temperature-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.fake_name_temperature',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
'original_name': 'Temperature',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
})
# ---
# name: test_setup[FritzDeviceSensorMock][sensor.fake_name_temperature-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'temperature',
'friendly_name': 'fake_name Temperature',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_temperature',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1.23',
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_current-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.fake_name_current',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
'original_name': 'Current',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_electric_current',
'unit_of_measurement': <UnitOfElectricCurrent.AMPERE: 'A'>,
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_current-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'current',
'friendly_name': 'fake_name Current',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfElectricCurrent.AMPERE: 'A'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_current',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.025',
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_energy-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'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.fake_name_energy',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
'original_name': 'Energy',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_total_energy',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_energy-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'energy',
'friendly_name': 'fake_name Energy',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_energy',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1.234',
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_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.fake_name_power',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
'original_name': 'Power',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_power_consumption',
'unit_of_measurement': <UnitOfPower.WATT: 'W'>,
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_power-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'power',
'friendly_name': 'fake_name Power',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfPower.WATT: 'W'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_power',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '5.678',
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_temperature-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': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.fake_name_temperature',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
'original_name': 'Temperature',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_temperature',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_temperature-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'temperature',
'friendly_name': 'fake_name Temperature',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_temperature',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1.23',
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_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.fake_name_voltage',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
'original_name': 'Voltage',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567_voltage',
'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
})
# ---
# name: test_setup[FritzDeviceSwitchMock][sensor.fake_name_voltage-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'voltage',
'friendly_name': 'fake_name Voltage',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
'context': <ANY>,
'entity_id': 'sensor.fake_name_voltage',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '230.0',
})
# ---

View File

@ -0,0 +1,48 @@
# serializer version: 1
# name: test_setup[switch.fake_name-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': None,
'entity_id': 'switch.fake_name',
'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': 'fake_name',
'platform': 'fritzbox',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '12345 1234567',
'unit_of_measurement': None,
})
# ---
# name: test_setup[switch.fake_name-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'fake_name',
}),
'context': <ANY>,
'entity_id': 'switch.fake_name',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

View File

@ -2,87 +2,49 @@
from datetime import timedelta from datetime import timedelta
from unittest import mock from unittest import mock
from unittest.mock import Mock from unittest.mock import Mock, patch
from requests.exceptions import HTTPError from requests.exceptions import HTTPError
from syrupy import SnapshotAssertion
from homeassistant.components.binary_sensor import ( from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
DOMAIN as BINARY_SENSOR_DOMAIN,
BinarySensorDeviceClass,
)
from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
from homeassistant.components.sensor import ( from homeassistant.config_entries import ConfigEntryState
ATTR_STATE_CLASS, from homeassistant.const import CONF_DEVICES, STATE_UNAVAILABLE, Platform
DOMAIN as SENSOR_DOMAIN,
SensorStateClass,
)
from homeassistant.const import (
ATTR_DEVICE_CLASS,
ATTR_FRIENDLY_NAME,
ATTR_UNIT_OF_MEASUREMENT,
CONF_DEVICES,
PERCENTAGE,
STATE_OFF,
STATE_ON,
STATE_UNAVAILABLE,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from . import FritzDeviceBinarySensorMock, set_devices, setup_config_entry from . import FritzDeviceBinarySensorMock, set_devices, setup_config_entry
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{BINARY_SENSOR_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{BINARY_SENSOR_DOMAIN}.{CONF_FAKE_NAME}"
async def test_setup(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform.""" """Test setup of platform."""
device = FritzDeviceBinarySensorMock() device = FritzDeviceBinarySensorMock()
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.BINARY_SENSOR]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(f"{ENTITY_ID}_alarm") await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == STATE_ON
assert state.attributes[ATTR_FRIENDLY_NAME] == f"{CONF_FAKE_NAME} Alarm"
assert state.attributes[ATTR_DEVICE_CLASS] == BinarySensorDeviceClass.WINDOW
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(f"{ENTITY_ID}_button_lock_on_device")
assert state
assert state.state == STATE_OFF
assert (
state.attributes[ATTR_FRIENDLY_NAME]
== f"{CONF_FAKE_NAME} Button lock on device"
)
assert state.attributes[ATTR_DEVICE_CLASS] == BinarySensorDeviceClass.LOCK
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(f"{ENTITY_ID}_button_lock_via_ui")
assert state
assert state.state == STATE_OFF
assert (
state.attributes[ATTR_FRIENDLY_NAME] == f"{CONF_FAKE_NAME} Button lock via UI"
)
assert state.attributes[ATTR_DEVICE_CLASS] == BinarySensorDeviceClass.LOCK
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_battery")
assert state
assert state.state == "23"
assert state.attributes[ATTR_FRIENDLY_NAME] == f"{CONF_FAKE_NAME} Battery"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == PERCENTAGE
assert state.attributes[ATTR_STATE_CLASS] is SensorStateClass.MEASUREMENT
async def test_is_off(hass: HomeAssistant, fritz: Mock) -> None: async def test_is_off(hass: HomeAssistant, fritz: Mock) -> None:
"""Test state of platform.""" """Test state of platform."""
device = FritzDeviceBinarySensorMock() device = FritzDeviceBinarySensorMock()
device.present = False device.present = False
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -102,7 +64,7 @@ async def test_is_off(hass: HomeAssistant, fritz: Mock) -> None:
async def test_update(hass: HomeAssistant, fritz: Mock) -> None: async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update without error.""" """Test update without error."""
device = FritzDeviceBinarySensorMock() device = FritzDeviceBinarySensorMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -121,7 +83,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update with error.""" """Test update with error."""
device = FritzDeviceBinarySensorMock() device = FritzDeviceBinarySensorMock()
device.update.side_effect = [mock.DEFAULT, HTTPError("Boom")] device.update.side_effect = [mock.DEFAULT, HTTPError("Boom")]
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -139,7 +101,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None: async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
"""Test adding new discovered devices during runtime.""" """Test adding new discovered devices during runtime."""
device = FritzDeviceBinarySensorMock() device = FritzDeviceBinarySensorMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )

View File

@ -1,44 +1,50 @@
"""Tests for AVM Fritz!Box templates.""" """Tests for AVM Fritz!Box templates."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import Mock from unittest.mock import Mock, 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.fritzbox.const import DOMAIN as FB_DOMAIN from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
from homeassistant.const import ( from homeassistant.config_entries import ConfigEntryState
ATTR_ENTITY_ID, from homeassistant.const import ATTR_ENTITY_ID, CONF_DEVICES, Platform
ATTR_FRIENDLY_NAME,
CONF_DEVICES,
STATE_UNKNOWN,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from . import FritzEntityBaseMock, set_devices, setup_config_entry from . import FritzEntityBaseMock, set_devices, setup_config_entry
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{BUTTON_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{BUTTON_DOMAIN}.{CONF_FAKE_NAME}"
async def test_setup(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test if is initialized correctly.""" """Test if is initialized correctly."""
template = FritzEntityBaseMock() template = FritzEntityBaseMock()
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.BUTTON]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template entry = await setup_config_entry(
) hass,
MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
fritz=fritz,
template=template,
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.attributes[ATTR_FRIENDLY_NAME] == CONF_FAKE_NAME
assert state.state == STATE_UNKNOWN
async def test_apply_template(hass: HomeAssistant, fritz: Mock) -> None: async def test_apply_template(hass: HomeAssistant, fritz: Mock) -> None:
"""Test if applies works.""" """Test if applies works."""
template = FritzEntityBaseMock() template = FritzEntityBaseMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template
) )
@ -51,7 +57,7 @@ async def test_apply_template(hass: HomeAssistant, fritz: Mock) -> None:
async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None: async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
"""Test adding new discovered devices during runtime.""" """Test adding new discovered devices during runtime."""
template = FritzEntityBaseMock() template = FritzEntityBaseMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template
) )

View File

@ -1,11 +1,12 @@
"""Tests for AVM Fritz!Box climate component.""" """Tests for AVM Fritz!Box climate component."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import Mock, _Call, call from unittest.mock import Mock, _Call, call, patch
from freezegun.api import FrozenDateTimeFactory from freezegun.api import FrozenDateTimeFactory
import pytest import pytest
from requests.exceptions import HTTPError from requests.exceptions import HTTPError
from syrupy import SnapshotAssertion
from homeassistant.components.climate import ( from homeassistant.components.climate import (
ATTR_CURRENT_TEMPERATURE, ATTR_CURRENT_TEMPERATURE,
@ -31,29 +32,15 @@ from homeassistant.components.fritzbox.climate import (
PRESET_SUMMER, PRESET_SUMMER,
) )
from homeassistant.components.fritzbox.const import ( from homeassistant.components.fritzbox.const import (
ATTR_STATE_BATTERY_LOW,
ATTR_STATE_HOLIDAY_MODE, ATTR_STATE_HOLIDAY_MODE,
ATTR_STATE_SUMMER_MODE, ATTR_STATE_SUMMER_MODE,
ATTR_STATE_WINDOW_OPEN,
DOMAIN as FB_DOMAIN, DOMAIN as FB_DOMAIN,
) )
from homeassistant.components.sensor import ( from homeassistant.config_entries import ConfigEntryState
ATTR_STATE_CLASS, from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE, CONF_DEVICES, Platform
DOMAIN as SENSOR_DOMAIN,
SensorStateClass,
)
from homeassistant.const import (
ATTR_BATTERY_LEVEL,
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
ATTR_TEMPERATURE,
ATTR_UNIT_OF_MEASUREMENT,
CONF_DEVICES,
PERCENTAGE,
UnitOfTemperature,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from . import ( from . import (
@ -64,127 +51,31 @@ from . import (
) )
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{CLIMATE_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{CLIMATE_DOMAIN}.{CONF_FAKE_NAME}"
async def test_setup(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform.""" """Test setup of platform."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.CLIMATE]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.attributes[ATTR_BATTERY_LEVEL] == 23
assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 18
assert state.attributes[ATTR_FRIENDLY_NAME] == CONF_FAKE_NAME
assert state.attributes[ATTR_HVAC_MODES] == [HVACMode.HEAT, HVACMode.OFF]
assert state.attributes[ATTR_MAX_TEMP] == 28
assert state.attributes[ATTR_MIN_TEMP] == 8
assert state.attributes[ATTR_PRESET_MODE] is None
assert state.attributes[ATTR_PRESET_MODES] == [
PRESET_ECO,
PRESET_COMFORT,
PRESET_BOOST,
]
assert state.attributes[ATTR_STATE_BATTERY_LOW] is True
assert state.attributes[ATTR_STATE_HOLIDAY_MODE] is False
assert state.attributes[ATTR_STATE_SUMMER_MODE] is False
assert state.attributes[ATTR_STATE_WINDOW_OPEN] == "fake_window"
assert state.attributes[ATTR_TEMPERATURE] == 19.5
assert ATTR_STATE_CLASS not in state.attributes
assert state.state == HVACMode.HEAT
state = hass.states.get(f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_battery")
assert state
assert state.state == "23"
assert state.attributes[ATTR_FRIENDLY_NAME] == f"{CONF_FAKE_NAME} Battery"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == PERCENTAGE
assert state.attributes[ATTR_STATE_CLASS] is SensorStateClass.MEASUREMENT
state = hass.states.get(f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_comfort_temperature")
assert state
assert state.state == "22.0"
assert (
state.attributes[ATTR_FRIENDLY_NAME] == f"{CONF_FAKE_NAME} Comfort temperature"
)
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_eco_temperature")
assert state
assert state.state == "16.0"
assert state.attributes[ATTR_FRIENDLY_NAME] == f"{CONF_FAKE_NAME} Eco temperature"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_next_scheduled_temperature"
)
assert state
assert state.state == "22.0"
assert (
state.attributes[ATTR_FRIENDLY_NAME]
== f"{CONF_FAKE_NAME} Next scheduled temperature"
)
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_next_scheduled_change_time"
)
assert state
assert state.state == "2024-09-20T18:00:00+00:00"
assert (
state.attributes[ATTR_FRIENDLY_NAME]
== f"{CONF_FAKE_NAME} Next scheduled change time"
)
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_next_scheduled_preset")
assert state
assert state.state == PRESET_COMFORT
assert (
state.attributes[ATTR_FRIENDLY_NAME]
== f"{CONF_FAKE_NAME} Next scheduled preset"
)
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_current_scheduled_preset"
)
assert state
assert state.state == PRESET_ECO
assert (
state.attributes[ATTR_FRIENDLY_NAME]
== f"{CONF_FAKE_NAME} Current scheduled preset"
)
assert ATTR_STATE_CLASS not in state.attributes
device.nextchange_temperature = 16
next_update = dt_util.utcnow() + timedelta(seconds=200)
async_fire_time_changed(hass, next_update)
await hass.async_block_till_done(wait_background_tasks=True)
state = hass.states.get(f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_next_scheduled_preset")
assert state
assert state.state == PRESET_ECO
state = hass.states.get(
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_current_scheduled_preset"
)
assert state
assert state.state == PRESET_COMFORT
async def test_hkr_wo_temperature_sensor(hass: HomeAssistant, fritz: Mock) -> None: async def test_hkr_wo_temperature_sensor(hass: HomeAssistant, fritz: Mock) -> None:
"""Test hkr without exposing dedicated temperature sensor data block.""" """Test hkr without exposing dedicated temperature sensor data block."""
device = FritzDeviceClimateWithoutTempSensorMock() device = FritzDeviceClimateWithoutTempSensorMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -197,7 +88,7 @@ async def test_target_temperature_on(hass: HomeAssistant, fritz: Mock) -> None:
"""Test turn device on.""" """Test turn device on."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
device.target_temperature = 127.0 device.target_temperature = 127.0
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -210,7 +101,7 @@ async def test_target_temperature_off(hass: HomeAssistant, fritz: Mock) -> None:
"""Test turn device on.""" """Test turn device on."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
device.target_temperature = 126.5 device.target_temperature = 126.5
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -222,7 +113,7 @@ async def test_target_temperature_off(hass: HomeAssistant, fritz: Mock) -> None:
async def test_update(hass: HomeAssistant, fritz: Mock) -> None: async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update without error.""" """Test update without error."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -253,7 +144,7 @@ async def test_automatic_offset(hass: HomeAssistant, fritz: Mock) -> None:
device.temperature = 18 device.temperature = 18
device.actual_temperature = 19 device.actual_temperature = 19
device.target_temperature = 20 device.target_temperature = 20
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -269,9 +160,10 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update with error.""" """Test update with error."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
fritz().update_devices.side_effect = HTTPError("Boom") fritz().update_devices.side_effect = HTTPError("Boom")
assert not await setup_config_entry( entry = await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
assert entry.state is ConfigEntryState.SETUP_RETRY
assert fritz().update_devices.call_count == 2 assert fritz().update_devices.call_count == 2
assert fritz().login.call_count == 2 assert fritz().login.call_count == 2
@ -312,7 +204,7 @@ async def test_set_temperature(
) -> None: ) -> None:
"""Test setting temperature.""" """Test setting temperature."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -366,7 +258,7 @@ async def test_set_hvac_mode(
else: else:
device.nextchange_endperiod = 0 device.nextchange_endperiod = 0
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -398,7 +290,7 @@ async def test_set_preset_mode_comfort(
"""Test setting preset mode.""" """Test setting preset mode."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
device.comfort_temperature = comfort_temperature device.comfort_temperature = comfort_temperature
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -429,7 +321,7 @@ async def test_set_preset_mode_eco(
"""Test setting preset mode.""" """Test setting preset mode."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
device.eco_temperature = eco_temperature device.eco_temperature = eco_temperature
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -449,7 +341,7 @@ async def test_set_preset_mode_boost(
) -> None: ) -> None:
"""Test setting preset mode.""" """Test setting preset mode."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -468,7 +360,7 @@ async def test_preset_mode_update(hass: HomeAssistant, fritz: Mock) -> None:
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
device.comfort_temperature = 23 device.comfort_temperature = 23
device.eco_temperature = 20 device.eco_temperature = 20
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -513,7 +405,7 @@ async def test_preset_mode_update(hass: HomeAssistant, fritz: Mock) -> None:
async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None: async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
"""Test adding new discovered devices during runtime.""" """Test adding new discovered devices during runtime."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -538,7 +430,7 @@ async def test_holidy_summer_mode(
) -> None: ) -> None:
"""Test holiday and summer mode.""" """Test holiday and summer mode."""
device = FritzDeviceClimateMock() device = FritzDeviceClimateMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )

View File

@ -1,15 +1,13 @@
"""Tests for AVM Fritz!Box switch component.""" """Tests for AVM Fritz!Box switch component."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import Mock, call from unittest.mock import Mock, call, patch
from homeassistant.components.cover import ( from syrupy import SnapshotAssertion
ATTR_CURRENT_POSITION,
ATTR_POSITION, from homeassistant.components.cover import ATTR_POSITION, DOMAIN as COVER_DOMAIN
DOMAIN as COVER_DOMAIN,
CoverState,
)
from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
CONF_DEVICES, CONF_DEVICES,
@ -18,8 +16,10 @@ from homeassistant.const import (
SERVICE_SET_COVER_POSITION, SERVICE_SET_COVER_POSITION,
SERVICE_STOP_COVER, SERVICE_STOP_COVER,
STATE_UNKNOWN, STATE_UNKNOWN,
Platform,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from . import ( from . import (
@ -30,28 +30,32 @@ from . import (
) )
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{COVER_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{COVER_DOMAIN}.{CONF_FAKE_NAME}"
async def test_setup(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform.""" """Test setup of platform."""
device = FritzDeviceCoverMock() device = FritzDeviceCoverMock()
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.COVER]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == CoverState.OPEN
assert state.attributes[ATTR_CURRENT_POSITION] == 100
async def test_unknown_position(hass: HomeAssistant, fritz: Mock) -> None: async def test_unknown_position(hass: HomeAssistant, fritz: Mock) -> None:
"""Test cover with unknown position.""" """Test cover with unknown position."""
device = FritzDeviceCoverUnknownPositionMock() device = FritzDeviceCoverUnknownPositionMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -63,7 +67,7 @@ async def test_unknown_position(hass: HomeAssistant, fritz: Mock) -> None:
async def test_open_cover(hass: HomeAssistant, fritz: Mock) -> None: async def test_open_cover(hass: HomeAssistant, fritz: Mock) -> None:
"""Test opening the cover.""" """Test opening the cover."""
device = FritzDeviceCoverMock() device = FritzDeviceCoverMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -76,7 +80,7 @@ async def test_open_cover(hass: HomeAssistant, fritz: Mock) -> None:
async def test_close_cover(hass: HomeAssistant, fritz: Mock) -> None: async def test_close_cover(hass: HomeAssistant, fritz: Mock) -> None:
"""Test closing the device.""" """Test closing the device."""
device = FritzDeviceCoverMock() device = FritzDeviceCoverMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -89,7 +93,7 @@ async def test_close_cover(hass: HomeAssistant, fritz: Mock) -> None:
async def test_set_position_cover(hass: HomeAssistant, fritz: Mock) -> None: async def test_set_position_cover(hass: HomeAssistant, fritz: Mock) -> None:
"""Test stopping the device.""" """Test stopping the device."""
device = FritzDeviceCoverMock() device = FritzDeviceCoverMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -105,7 +109,7 @@ async def test_set_position_cover(hass: HomeAssistant, fritz: Mock) -> None:
async def test_stop_cover(hass: HomeAssistant, fritz: Mock) -> None: async def test_stop_cover(hass: HomeAssistant, fritz: Mock) -> None:
"""Test stopping the device.""" """Test stopping the device."""
device = FritzDeviceCoverMock() device = FritzDeviceCoverMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -118,7 +122,7 @@ async def test_stop_cover(hass: HomeAssistant, fritz: Mock) -> None:
async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None: async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
"""Test adding new discovered devices during runtime.""" """Test adding new discovered devices during runtime."""
device = FritzDeviceCoverMock() device = FritzDeviceCoverMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )

View File

@ -1,9 +1,10 @@
"""Tests for AVM Fritz!Box light component.""" """Tests for AVM Fritz!Box light component."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import Mock, call from unittest.mock import Mock, call, patch
from requests.exceptions import HTTPError from requests.exceptions import HTTPError
from syrupy import SnapshotAssertion
from homeassistant.components.fritzbox.const import ( from homeassistant.components.fritzbox.const import (
COLOR_MODE, COLOR_MODE,
@ -12,35 +13,36 @@ from homeassistant.components.fritzbox.const import (
) )
from homeassistant.components.light import ( from homeassistant.components.light import (
ATTR_BRIGHTNESS, ATTR_BRIGHTNESS,
ATTR_COLOR_MODE,
ATTR_COLOR_TEMP_KELVIN, ATTR_COLOR_TEMP_KELVIN,
ATTR_HS_COLOR, ATTR_HS_COLOR,
ATTR_MAX_COLOR_TEMP_KELVIN,
ATTR_MIN_COLOR_TEMP_KELVIN,
ATTR_SUPPORTED_COLOR_MODES,
DOMAIN as LIGHT_DOMAIN, DOMAIN as LIGHT_DOMAIN,
ColorMode,
) )
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
CONF_DEVICES, CONF_DEVICES,
SERVICE_TURN_OFF, SERVICE_TURN_OFF,
SERVICE_TURN_ON, SERVICE_TURN_ON,
STATE_ON, Platform,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from . import FritzDeviceLightMock, set_devices, setup_config_entry from . import FritzDeviceLightMock, set_devices, setup_config_entry
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{LIGHT_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{LIGHT_DOMAIN}.{CONF_FAKE_NAME}"
async def test_setup(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform.""" """Test setup of platform."""
device = FritzDeviceLightMock() device = FritzDeviceLightMock()
device.get_color_temps.return_value = [2700, 6500] device.get_color_temps.return_value = [2700, 6500]
@ -50,42 +52,42 @@ async def test_setup(hass: HomeAssistant, fritz: Mock) -> None:
device.color_mode = COLOR_TEMP_MODE device.color_mode = COLOR_TEMP_MODE
device.color_temp = 2700 device.color_temp = 2700
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == STATE_ON
assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name"
assert state.attributes[ATTR_COLOR_MODE] == ColorMode.COLOR_TEMP
assert state.attributes[ATTR_COLOR_TEMP_KELVIN] == 2700
assert state.attributes[ATTR_MIN_COLOR_TEMP_KELVIN] == 2700
assert state.attributes[ATTR_MAX_COLOR_TEMP_KELVIN] == 6500
assert state.attributes[ATTR_HS_COLOR] == (28.395, 65.723)
assert state.attributes[ATTR_SUPPORTED_COLOR_MODES] == ["color_temp", "hs"]
async def test_setup_non_color(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup_non_color(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform of non color bulb.""" """Test setup of platform of non color bulb."""
device = FritzDeviceLightMock() device = FritzDeviceLightMock()
device.has_color = False device.has_color = False
device.get_color_temps.return_value = [] device.get_color_temps.return_value = []
device.get_colors.return_value = {} device.get_colors.return_value = {}
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == STATE_ON
assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name"
assert state.attributes[ATTR_BRIGHTNESS] == 100
assert state.attributes[ATTR_SUPPORTED_COLOR_MODES] == ["brightness"]
async def test_setup_non_color_non_level(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup_non_color_non_level(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform of non color and non level bulb.""" """Test setup of platform of non color and non level bulb."""
device = FritzDeviceLightMock() device = FritzDeviceLightMock()
device.has_color = False device.has_color = False
@ -93,22 +95,21 @@ async def test_setup_non_color_non_level(hass: HomeAssistant, fritz: Mock) -> No
device.get_color_temps.return_value = [] device.get_color_temps.return_value = []
device.get_colors.return_value = {} device.get_colors.return_value = {}
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == STATE_ON
assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name"
assert ATTR_BRIGHTNESS not in state.attributes
assert state.attributes[ATTR_SUPPORTED_COLOR_MODES] == ["onoff"]
assert state.attributes[ATTR_COLOR_MODE] == ColorMode.ONOFF
assert state.attributes.get(ATTR_COLOR_TEMP_KELVIN) is None
assert state.attributes.get(ATTR_HS_COLOR) is None
async def test_setup_color(hass: HomeAssistant, fritz: Mock) -> None: async def test_setup_color(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None:
"""Test setup of platform in color mode.""" """Test setup of platform in color mode."""
device = FritzDeviceLightMock() device = FritzDeviceLightMock()
device.get_color_temps.return_value = [2700, 6500] device.get_color_temps.return_value = [2700, 6500]
@ -119,19 +120,13 @@ async def test_setup_color(hass: HomeAssistant, fritz: Mock) -> None:
device.hue = 100 device.hue = 100
device.saturation = 70 * 255.0 / 100.0 device.saturation = 70 * 255.0 / 100.0
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == STATE_ON
assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name"
assert state.attributes[ATTR_COLOR_MODE] == ColorMode.HS
assert state.attributes[ATTR_COLOR_TEMP_KELVIN] is None
assert state.attributes[ATTR_BRIGHTNESS] == 100
assert state.attributes[ATTR_HS_COLOR] == (100, 70)
assert state.attributes[ATTR_SUPPORTED_COLOR_MODES] == ["color_temp", "hs"]
async def test_turn_on(hass: HomeAssistant, fritz: Mock) -> None: async def test_turn_on(hass: HomeAssistant, fritz: Mock) -> None:
@ -258,9 +253,10 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
"Red": [("100", "70", "10"), ("100", "50", "10"), ("100", "30", "10")] "Red": [("100", "70", "10"), ("100", "50", "10"), ("100", "30", "10")]
} }
fritz().update_devices.side_effect = HTTPError("Boom") fritz().update_devices.side_effect = HTTPError("Boom")
assert not await setup_config_entry( entry = await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
assert entry.state is ConfigEntryState.SETUP_RETRY
assert fritz().update_devices.call_count == 2 assert fritz().update_devices.call_count == 2
assert fritz().login.call_count == 2 assert fritz().login.call_count == 2

View File

@ -1,97 +1,69 @@
"""Tests for AVM Fritz!Box sensor component.""" """Tests for AVM Fritz!Box sensor component."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import Mock from unittest.mock import Mock, patch
import pytest import pytest
from requests.exceptions import HTTPError from requests.exceptions import HTTPError
from syrupy import SnapshotAssertion
from homeassistant.components.climate import PRESET_COMFORT, PRESET_ECO from homeassistant.components.climate import PRESET_COMFORT, PRESET_ECO
from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
from homeassistant.components.sensor import ( from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
ATTR_STATE_CLASS, from homeassistant.config_entries import ConfigEntryState
DOMAIN as SENSOR_DOMAIN, from homeassistant.const import CONF_DEVICES, STATE_UNKNOWN, Platform
SensorStateClass,
)
from homeassistant.const import (
ATTR_FRIENDLY_NAME,
ATTR_UNIT_OF_MEASUREMENT,
CONF_DEVICES,
PERCENTAGE,
STATE_UNKNOWN,
EntityCategory,
UnitOfTemperature,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from . import ( from . import (
FritzDeviceBinarySensorMock,
FritzDeviceClimateMock, FritzDeviceClimateMock,
FritzDeviceSensorMock, FritzDeviceSensorMock,
FritzDeviceSwitchMock,
FritzEntityBaseMock,
set_devices, set_devices,
setup_config_entry, setup_config_entry,
) )
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}"
@pytest.mark.parametrize(
"device",
[
FritzDeviceBinarySensorMock,
FritzDeviceClimateMock,
FritzDeviceSensorMock,
FritzDeviceSwitchMock,
],
)
async def test_setup( async def test_setup(
hass: HomeAssistant, entity_registry: er.EntityRegistry, fritz: Mock hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
device: FritzEntityBaseMock,
) -> None: ) -> None:
"""Test setup of platform.""" """Test setup of sensor platform for different device types."""
device = FritzDeviceSensorMock() device = device()
assert await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
await hass.async_block_till_done()
sensors = ( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.SENSOR]):
[ entry = await setup_config_entry(
f"{ENTITY_ID}_temperature", hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
"1.23", )
f"{CONF_FAKE_NAME} Temperature", assert entry.state is ConfigEntryState.LOADED
UnitOfTemperature.CELSIUS,
SensorStateClass.MEASUREMENT,
None,
],
[
f"{ENTITY_ID}_humidity",
"42",
f"{CONF_FAKE_NAME} Humidity",
PERCENTAGE,
SensorStateClass.MEASUREMENT,
None,
],
[
f"{ENTITY_ID}_battery",
"23",
f"{CONF_FAKE_NAME} Battery",
PERCENTAGE,
SensorStateClass.MEASUREMENT,
EntityCategory.DIAGNOSTIC,
],
)
for sensor in sensors: await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
state = hass.states.get(sensor[0])
assert state
assert state.state == sensor[1]
assert state.attributes[ATTR_FRIENDLY_NAME] == sensor[2]
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == sensor[3]
assert state.attributes.get(ATTR_STATE_CLASS) == sensor[4]
entry = entity_registry.async_get(sensor[0])
assert entry
assert entry.entity_category is sensor[5]
async def test_update(hass: HomeAssistant, fritz: Mock) -> None: async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update without error.""" """Test update without error."""
device = FritzDeviceSensorMock() device = FritzDeviceSensorMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
assert fritz().update_devices.call_count == 1 assert fritz().update_devices.call_count == 1
@ -109,9 +81,10 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update with error.""" """Test update with error."""
device = FritzDeviceSensorMock() device = FritzDeviceSensorMock()
fritz().update_devices.side_effect = HTTPError("Boom") fritz().update_devices.side_effect = HTTPError("Boom")
assert not await setup_config_entry( entry = await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
assert entry.state is ConfigEntryState.SETUP_RETRY
assert fritz().update_devices.call_count == 2 assert fritz().update_devices.call_count == 2
assert fritz().login.call_count == 2 assert fritz().login.call_count == 2
@ -126,7 +99,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None: async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
"""Test adding new discovered devices during runtime.""" """Test adding new discovered devices during runtime."""
device = FritzDeviceSensorMock() device = FritzDeviceSensorMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -175,7 +148,7 @@ async def test_next_change_sensors(
device.nextchange_endperiod = next_changes[0] device.nextchange_endperiod = next_changes[0]
device.nextchange_temperature = next_changes[1] device.nextchange_temperature = next_changes[1]
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )

View File

@ -1,33 +1,22 @@
"""Tests for AVM Fritz!Box switch component.""" """Tests for AVM Fritz!Box switch component."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import Mock from unittest.mock import Mock, patch
import pytest import pytest
from requests.exceptions import HTTPError from requests.exceptions import HTTPError
from syrupy import SnapshotAssertion
from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
from homeassistant.components.sensor import (
ATTR_STATE_CLASS,
DOMAIN as SENSOR_DOMAIN,
SensorStateClass,
)
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
ATTR_UNIT_OF_MEASUREMENT,
CONF_DEVICES, CONF_DEVICES,
SERVICE_TURN_OFF, SERVICE_TURN_OFF,
SERVICE_TURN_ON, SERVICE_TURN_ON,
STATE_ON,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
EntityCategory, Platform,
UnitOfElectricCurrent,
UnitOfElectricPotential,
UnitOfEnergy,
UnitOfPower,
UnitOfTemperature,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
@ -37,89 +26,32 @@ from homeassistant.util import dt as dt_util
from . import FritzDeviceSwitchMock, set_devices, setup_config_entry from . import FritzDeviceSwitchMock, set_devices, setup_config_entry
from .const import CONF_FAKE_NAME, MOCK_CONFIG from .const import CONF_FAKE_NAME, MOCK_CONFIG
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed, snapshot_platform
ENTITY_ID = f"{SWITCH_DOMAIN}.{CONF_FAKE_NAME}" ENTITY_ID = f"{SWITCH_DOMAIN}.{CONF_FAKE_NAME}"
async def test_setup( async def test_setup(
hass: HomeAssistant, entity_registry: er.EntityRegistry, fritz: Mock hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
fritz: Mock,
) -> None: ) -> None:
"""Test setup of platform.""" """Test setup of platform."""
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
assert await setup_config_entry( with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.SWITCH]):
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz entry = await setup_config_entry(
) hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
)
assert entry.state is ConfigEntryState.LOADED
state = hass.states.get(ENTITY_ID) await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert state
assert state.state == STATE_ON
assert state.attributes[ATTR_FRIENDLY_NAME] == CONF_FAKE_NAME
assert ATTR_STATE_CLASS not in state.attributes
state = hass.states.get(f"{ENTITY_ID}_humidity")
assert state is None
sensors = (
[
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_temperature",
"1.23",
f"{CONF_FAKE_NAME} Temperature",
UnitOfTemperature.CELSIUS,
SensorStateClass.MEASUREMENT,
EntityCategory.DIAGNOSTIC,
],
[
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_power",
"5.678",
f"{CONF_FAKE_NAME} Power",
UnitOfPower.WATT,
SensorStateClass.MEASUREMENT,
None,
],
[
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_energy",
"1.234",
f"{CONF_FAKE_NAME} Energy",
UnitOfEnergy.KILO_WATT_HOUR,
SensorStateClass.TOTAL_INCREASING,
None,
],
[
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_voltage",
"230.0",
f"{CONF_FAKE_NAME} Voltage",
UnitOfElectricPotential.VOLT,
SensorStateClass.MEASUREMENT,
None,
],
[
f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}_current",
"0.025",
f"{CONF_FAKE_NAME} Current",
UnitOfElectricCurrent.AMPERE,
SensorStateClass.MEASUREMENT,
None,
],
)
for sensor in sensors:
state = hass.states.get(sensor[0])
assert state
assert state.state == sensor[1]
assert state.attributes[ATTR_FRIENDLY_NAME] == sensor[2]
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == sensor[3]
assert state.attributes[ATTR_STATE_CLASS] == sensor[4]
assert state.attributes[ATTR_STATE_CLASS] == sensor[4]
entry = entity_registry.async_get(sensor[0])
assert entry
assert entry.entity_category is sensor[5]
async def test_turn_on(hass: HomeAssistant, fritz: Mock) -> None: async def test_turn_on(hass: HomeAssistant, fritz: Mock) -> None:
"""Test turn device on.""" """Test turn device on."""
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -133,7 +65,7 @@ async def test_turn_off(hass: HomeAssistant, fritz: Mock) -> None:
"""Test turn device off.""" """Test turn device off."""
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -149,7 +81,7 @@ async def test_toggle_while_locked(hass: HomeAssistant, fritz: Mock) -> None:
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
device.lock = True device.lock = True
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -173,7 +105,7 @@ async def test_toggle_while_locked(hass: HomeAssistant, fritz: Mock) -> None:
async def test_update(hass: HomeAssistant, fritz: Mock) -> None: async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update without error.""" """Test update without error."""
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
assert fritz().update_devices.call_count == 1 assert fritz().update_devices.call_count == 1
@ -191,9 +123,10 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
"""Test update with error.""" """Test update with error."""
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
fritz().update_devices.side_effect = HTTPError("Boom") fritz().update_devices.side_effect = HTTPError("Boom")
assert not await setup_config_entry( entry = await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
assert entry.state is ConfigEntryState.SETUP_RETRY
assert fritz().update_devices.call_count == 2 assert fritz().update_devices.call_count == 2
assert fritz().login.call_count == 2 assert fritz().login.call_count == 2
@ -211,7 +144,7 @@ async def test_assume_device_unavailable(hass: HomeAssistant, fritz: Mock) -> No
device.voltage = 0 device.voltage = 0
device.energy = 0 device.energy = 0
device.power = 0 device.power = 0
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )
@ -223,7 +156,7 @@ async def test_assume_device_unavailable(hass: HomeAssistant, fritz: Mock) -> No
async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None: async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
"""Test adding new discovered devices during runtime.""" """Test adding new discovered devices during runtime."""
device = FritzDeviceSwitchMock() device = FritzDeviceSwitchMock()
assert await setup_config_entry( await setup_config_entry(
hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
) )