jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-26 06:37:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use SnapshotAssertion in more AVM Fritz!Box Tools tests (#125037)

Browse Source 
use SnapshotAssertion in more tests
This commit is contained in:
Michael 2024-09-03 16:39:06 +02:00 committed by GitHub
parent 2fa3b9070c
commit 96be3e2505
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 1771 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

235
tests/components/fritz/snapshots/test_button.ambr Normal file
View File

@ -0,0 +1,235 @@
# serializer version: 1
# name: test_button_setup[button.mock_title_cleanup-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.mock_title_cleanup',
'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': 'Cleanup',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'cleanup',
'unique_id': '1C:ED:6F:12:34:11-cleanup',
'unit_of_measurement': None,
})
# ---
# name: test_button_setup[button.mock_title_cleanup-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Cleanup',
}),
'context': <ANY>,
'entity_id': 'button.mock_title_cleanup',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_button_setup[button.mock_title_firmware_update-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.mock_title_firmware_update',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <ButtonDeviceClass.UPDATE: 'update'>,
'original_icon': None,
'original_name': 'Firmware update',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'firmware_update',
'unique_id': '1C:ED:6F:12:34:11-firmware_update',
'unit_of_measurement': None,
})
# ---
# name: test_button_setup[button.mock_title_firmware_update-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'update',
'friendly_name': 'Mock Title Firmware update',
}),
'context': <ANY>,
'entity_id': 'button.mock_title_firmware_update',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_button_setup[button.mock_title_reconnect-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.mock_title_reconnect',
'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': 'Reconnect',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'reconnect',
'unique_id': '1C:ED:6F:12:34:11-reconnect',
'unit_of_measurement': None,
})
# ---
# name: test_button_setup[button.mock_title_reconnect-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'restart',
'friendly_name': 'Mock Title Reconnect',
}),
'context': <ANY>,
'entity_id': 'button.mock_title_reconnect',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_button_setup[button.mock_title_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.mock_title_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': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-reboot',
'unit_of_measurement': None,
})
# ---
# name: test_button_setup[button.mock_title_restart-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'restart',
'friendly_name': 'Mock Title Restart',
}),
'context': <ANY>,
'entity_id': 'button.mock_title_restart',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_button_setup[button.printer_wake_on_lan-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': None,
'entity_id': 'button.printer_wake_on_lan',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:lan-pending',
'original_name': 'printer Wake on LAN',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': 'AA:BB:CC:00:11:22_wake_on_lan',
'unit_of_measurement': None,
})
# ---
# name: test_button_setup[button.printer_wake_on_lan-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'printer Wake on LAN',
'icon': 'mdi:lan-pending',
}),
'context': <ANY>,
'entity_id': 'button.printer_wake_on_lan',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---

67
tests/components/fritz/snapshots/test_diagnostics.ambr Normal file
View File

@ -0,0 +1,67 @@
# serializer version: 1
# name: test_entry_diagnostics
dict({
'device_info': dict({
'client_devices': list([
dict({
'connected_to': 'fritz.box',
'connection_type': 'LAN',
'hostname': 'printer',
'is_connected': True,
'wan_access': True,
}),
]),
'connection_type': 'WANPPPConnection',
'current_firmware': '7.29',
'discovered_services': list([
'DeviceInfo1',
'Hosts1',
'LANEthernetInterfaceConfig1',
'Layer3Forwarding1',
'UserInterface1',
'WANCommonIFC1',
'WANCommonInterfaceConfig1',
'WANDSLInterfaceConfig1',
'WANIPConn1',
'WANPPPConnection1',
'WLANConfiguration1',
'X_AVM-DE_Homeauto1',
'X_AVM-DE_HostFilter1',
]),
'is_router': True,
'last_exception': None,
'last_update success': True,
'latest_firmware': None,
'mesh_role': 'master',
'model': 'FRITZ!Box 7530 AX',
'unique_id': '1C:ED:XX:XX:34:11',
'update_available': False,
'wan_link_properties': dict({
'NewLayer1DownstreamMaxBitRate': 318557000,
'NewLayer1UpstreamMaxBitRate': 51805000,
'NewPhysicalLinkStatus': 'Up',
'NewWANAccessType': 'DSL',
}),
}),
'entry': dict({
'data': dict({
'host': 'fake_host',
'password': '**REDACTED**',
'port': '1234',
'ssl': False,
'username': '**REDACTED**',
}),
'disabled_by': None,
'domain': 'fritz',
'minor_version': 1,
'options': dict({
}),
'pref_disable_new_entities': False,
'pref_disable_polling': False,
'source': 'user',
'title': 'Mock Title',
'unique_id': None,
'version': 1,
}),
})
# ---

771
tests/components/fritz/snapshots/test_sensor.ambr Normal file
View File

@ -0,0 +1,771 @@
# serializer version: 1
# name: test_sensor_setup[sensor.mock_title_connection_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.mock_title_connection_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': 'Connection uptime',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'connection_uptime',
'unique_id': '1C:ED:6F:12:34:11-connection_uptime',
'unit_of_measurement': None,
})
# ---
# name: test_sensor_setup[sensor.mock_title_connection_uptime-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'timestamp',
'friendly_name': 'Mock Title Connection uptime',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_connection_uptime',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '2024-09-01T10:11:33+00:00',
})
# ---
# name: test_sensor_setup[sensor.mock_title_download_throughput-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.mock_title_download_throughput',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
'original_name': 'Download throughput',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'kb_s_received',
'unique_id': '1C:ED:6F:12:34:11-kb_s_received',
'unit_of_measurement': <UnitOfDataRate.KILOBYTES_PER_SECOND: 'kB/s'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_download_throughput-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_rate',
'friendly_name': 'Mock Title Download throughput',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfDataRate.KILOBYTES_PER_SECOND: 'kB/s'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_download_throughput',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '67.6',
})
# ---
# name: test_sensor_setup[sensor.mock_title_external_ip-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': None,
'entity_id': 'sensor.mock_title_external_ip',
'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': 'External IP',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'external_ip',
'unique_id': '1C:ED:6F:12:34:11-external_ip',
'unit_of_measurement': None,
})
# ---
# name: test_sensor_setup[sensor.mock_title_external_ip-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title External IP',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_external_ip',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1.2.3.4',
})
# ---
# name: test_sensor_setup[sensor.mock_title_external_ipv6-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': None,
'entity_id': 'sensor.mock_title_external_ipv6',
'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': 'External IPv6',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'external_ipv6',
'unique_id': '1C:ED:6F:12:34:11-external_ipv6',
'unit_of_measurement': None,
})
# ---
# name: test_sensor_setup[sensor.mock_title_external_ipv6-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title External IPv6',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_external_ipv6',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'fec0::1',
})
# ---
# name: test_sensor_setup[sensor.mock_title_gb_received-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.mock_title_gb_received',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
'original_name': 'GB received',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'gb_received',
'unique_id': '1C:ED:6F:12:34:11-gb_received',
'unit_of_measurement': <UnitOfInformation.GIGABYTES: 'GB'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_gb_received-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_size',
'friendly_name': 'Mock Title GB received',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfInformation.GIGABYTES: 'GB'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_gb_received',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '5.2',
})
# ---
# name: test_sensor_setup[sensor.mock_title_gb_sent-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.mock_title_gb_sent',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
'original_name': 'GB sent',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'gb_sent',
'unique_id': '1C:ED:6F:12:34:11-gb_sent',
'unit_of_measurement': <UnitOfInformation.GIGABYTES: 'GB'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_gb_sent-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_size',
'friendly_name': 'Mock Title GB sent',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfInformation.GIGABYTES: 'GB'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_gb_sent',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1.7',
})
# ---
# name: test_sensor_setup[sensor.mock_title_last_restart-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.mock_title_last_restart',
'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': 'Last restart',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'device_uptime',
'unique_id': '1C:ED:6F:12:34:11-device_uptime',
'unit_of_measurement': None,
})
# ---
# name: test_sensor_setup[sensor.mock_title_last_restart-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'timestamp',
'friendly_name': 'Mock Title Last restart',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_last_restart',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '2024-08-03T16:30:21+00:00',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_download_noise_margin-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': None,
'entity_id': 'sensor.mock_title_link_download_noise_margin',
'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': 'Link download noise margin',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'link_noise_margin_received',
'unique_id': '1C:ED:6F:12:34:11-link_noise_margin_received',
'unit_of_measurement': 'dB',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_download_noise_margin-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Link download noise margin',
'unit_of_measurement': 'dB',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_link_download_noise_margin',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '8.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_download_power_attenuation-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': None,
'entity_id': 'sensor.mock_title_link_download_power_attenuation',
'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': 'Link download power attenuation',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'link_attenuation_received',
'unique_id': '1C:ED:6F:12:34:11-link_attenuation_received',
'unit_of_measurement': 'dB',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_download_power_attenuation-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Link download power attenuation',
'unit_of_measurement': 'dB',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_link_download_power_attenuation',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '12.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_download_throughput-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': None,
'entity_id': 'sensor.mock_title_link_download_throughput',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
'original_name': 'Link download throughput',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'link_kb_s_received',
'unique_id': '1C:ED:6F:12:34:11-link_kb_s_received',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_download_throughput-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_rate',
'friendly_name': 'Mock Title Link download throughput',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_link_download_throughput',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '318557.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_upload_noise_margin-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': None,
'entity_id': 'sensor.mock_title_link_upload_noise_margin',
'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': 'Link upload noise margin',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'link_noise_margin_sent',
'unique_id': '1C:ED:6F:12:34:11-link_noise_margin_sent',
'unit_of_measurement': 'dB',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_upload_noise_margin-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Link upload noise margin',
'unit_of_measurement': 'dB',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_link_upload_noise_margin',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '9.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_upload_power_attenuation-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': None,
'entity_id': 'sensor.mock_title_link_upload_power_attenuation',
'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': 'Link upload power attenuation',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'link_attenuation_sent',
'unique_id': '1C:ED:6F:12:34:11-link_attenuation_sent',
'unit_of_measurement': 'dB',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_upload_power_attenuation-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Link upload power attenuation',
'unit_of_measurement': 'dB',
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_link_upload_power_attenuation',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '7.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_upload_throughput-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': None,
'entity_id': 'sensor.mock_title_link_upload_throughput',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
'original_name': 'Link upload throughput',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'link_kb_s_sent',
'unique_id': '1C:ED:6F:12:34:11-link_kb_s_sent',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_link_upload_throughput-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_rate',
'friendly_name': 'Mock Title Link upload throughput',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_link_upload_throughput',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '51805.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_max_connection_download_throughput-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.mock_title_max_connection_download_throughput',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
'original_name': 'Max connection download throughput',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'max_kb_s_received',
'unique_id': '1C:ED:6F:12:34:11-max_kb_s_received',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_max_connection_download_throughput-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_rate',
'friendly_name': 'Mock Title Max connection download throughput',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_max_connection_download_throughput',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '10087.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_max_connection_upload_throughput-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.mock_title_max_connection_upload_throughput',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
'original_name': 'Max connection upload throughput',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'max_kb_s_sent',
'unique_id': '1C:ED:6F:12:34:11-max_kb_s_sent',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_max_connection_upload_throughput-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_rate',
'friendly_name': 'Mock Title Max connection upload throughput',
'unit_of_measurement': <UnitOfDataRate.KILOBITS_PER_SECOND: 'kbit/s'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_max_connection_upload_throughput',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '2105.0',
})
# ---
# name: test_sensor_setup[sensor.mock_title_upload_throughput-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.mock_title_upload_throughput',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
'original_name': 'Upload throughput',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'kb_s_sent',
'unique_id': '1C:ED:6F:12:34:11-kb_s_sent',
'unit_of_measurement': <UnitOfDataRate.KILOBYTES_PER_SECOND: 'kB/s'>,
})
# ---
# name: test_sensor_setup[sensor.mock_title_upload_throughput-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'data_rate',
'friendly_name': 'Mock Title Upload throughput',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfDataRate.KILOBYTES_PER_SECOND: 'kB/s'>,
}),
'context': <ANY>,
'entity_id': 'sensor.mock_title_upload_throughput',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '3.4',
})
# ---

424
tests/components/fritz/snapshots/test_switch.ambr Normal file
View File

@ -0,0 +1,424 @@
# serializer version: 1
# name: test_switch_setup[fc_data0-expected_wifi_names0][switch.mock_title_wi_fi_wifi_2_4ghz-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.mock_title_wi_fi_wifi_2_4ghz',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:wifi',
'original_name': 'Mock Title Wi-Fi WiFi (2.4Ghz)',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-wi_fi_wifi_2_4ghz',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data0-expected_wifi_names0][switch.mock_title_wi_fi_wifi_2_4ghz-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Wi-Fi WiFi (2.4Ghz)',
'icon': 'mdi:wifi',
}),
'context': <ANY>,
'entity_id': 'switch.mock_title_wi_fi_wifi_2_4ghz',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data0-expected_wifi_names0][switch.mock_title_wi_fi_wifi_5ghz-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.mock_title_wi_fi_wifi_5ghz',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:wifi',
'original_name': 'Mock Title Wi-Fi WiFi (5Ghz)',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-wi_fi_wifi_5ghz',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data0-expected_wifi_names0][switch.mock_title_wi_fi_wifi_5ghz-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Wi-Fi WiFi (5Ghz)',
'icon': 'mdi:wifi',
}),
'context': <ANY>,
'entity_id': 'switch.mock_title_wi_fi_wifi_5ghz',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data0-expected_wifi_names0][switch.printer_internet_access-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.printer_internet_access',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:router-wireless-settings',
'original_name': 'printer Internet Access',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': 'AA:BB:CC:00:11:22_internet_access',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data0-expected_wifi_names0][switch.printer_internet_access-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'printer Internet Access',
'icon': 'mdi:router-wireless-settings',
}),
'context': <ANY>,
'entity_id': 'switch.printer_internet_access',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data1-expected_wifi_names1][switch.mock_title_wi_fi_wifi-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.mock_title_wi_fi_wifi',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:wifi',
'original_name': 'Mock Title Wi-Fi WiFi',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-wi_fi_wifi',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data1-expected_wifi_names1][switch.mock_title_wi_fi_wifi-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Wi-Fi WiFi',
'icon': 'mdi:wifi',
}),
'context': <ANY>,
'entity_id': 'switch.mock_title_wi_fi_wifi',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data1-expected_wifi_names1][switch.mock_title_wi_fi_wifi2-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.mock_title_wi_fi_wifi2',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:wifi',
'original_name': 'Mock Title Wi-Fi WiFi2',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-wi_fi_wifi2',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data1-expected_wifi_names1][switch.mock_title_wi_fi_wifi2-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Wi-Fi WiFi2',
'icon': 'mdi:wifi',
}),
'context': <ANY>,
'entity_id': 'switch.mock_title_wi_fi_wifi2',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data1-expected_wifi_names1][switch.printer_internet_access-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.printer_internet_access',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:router-wireless-settings',
'original_name': 'printer Internet Access',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': 'AA:BB:CC:00:11:22_internet_access',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data1-expected_wifi_names1][switch.printer_internet_access-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'printer Internet Access',
'icon': 'mdi:router-wireless-settings',
}),
'context': <ANY>,
'entity_id': 'switch.printer_internet_access',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data2-expected_wifi_names2][switch.mock_title_wi_fi_wifi_2_4ghz-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.mock_title_wi_fi_wifi_2_4ghz',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:wifi',
'original_name': 'Mock Title Wi-Fi WiFi (2.4Ghz)',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-wi_fi_wifi_2_4ghz',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data2-expected_wifi_names2][switch.mock_title_wi_fi_wifi_2_4ghz-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Wi-Fi WiFi (2.4Ghz)',
'icon': 'mdi:wifi',
}),
'context': <ANY>,
'entity_id': 'switch.mock_title_wi_fi_wifi_2_4ghz',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data2-expected_wifi_names2][switch.mock_title_wi_fi_wifi_5ghz-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.mock_title_wi_fi_wifi_5ghz',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:wifi',
'original_name': 'Mock Title Wi-Fi WiFi+ (5Ghz)',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-wi_fi_wifi_5ghz',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data2-expected_wifi_names2][switch.mock_title_wi_fi_wifi_5ghz-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Title Wi-Fi WiFi+ (5Ghz)',
'icon': 'mdi:wifi',
}),
'context': <ANY>,
'entity_id': 'switch.mock_title_wi_fi_wifi_5ghz',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_setup[fc_data2-expected_wifi_names2][switch.printer_internet_access-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'switch',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'switch.printer_internet_access',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:router-wireless-settings',
'original_name': 'printer Internet Access',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': 'AA:BB:CC:00:11:22_internet_access',
'unit_of_measurement': None,
})
# ---
# name: test_switch_setup[fc_data2-expected_wifi_names2][switch.printer_internet_access-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'printer Internet Access',
'icon': 'mdi:router-wireless-settings',
}),
'context': <ANY>,
'entity_id': 'switch.printer_internet_access',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

169
tests/components/fritz/snapshots/test_update.ambr Normal file
View File

@ -0,0 +1,169 @@
# serializer version: 1
# name: test_available_update_can_be_installed[update.mock_title_fritz_os-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'update',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'update.mock_title_fritz_os',
'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': 'FRITZ!OS',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': <UpdateEntityFeature: 1>,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-update',
'unit_of_measurement': None,
})
# ---
# name: test_available_update_can_be_installed[update.mock_title_fritz_os-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'auto_update': False,
'entity_picture': 'https://brands.home-assistant.io/_/fritz/icon.png',
'friendly_name': 'Mock Title FRITZ!OS',
'in_progress': False,
'installed_version': '7.29',
'latest_version': '7.50',
'release_summary': None,
'release_url': 'http://download.avm.de/fritzbox/fritzbox-7530-ax/deutschland/fritz.os/info_de.txt',
'skipped_version': None,
'supported_features': <UpdateEntityFeature: 1>,
'title': 'FRITZ!OS',
}),
'context': <ANY>,
'entity_id': 'update.mock_title_fritz_os',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_update_available[update.mock_title_fritz_os-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'update',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'update.mock_title_fritz_os',
'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': 'FRITZ!OS',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': <UpdateEntityFeature: 1>,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-update',
'unit_of_measurement': None,
})
# ---
# name: test_update_available[update.mock_title_fritz_os-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'auto_update': False,
'entity_picture': 'https://brands.home-assistant.io/_/fritz/icon.png',
'friendly_name': 'Mock Title FRITZ!OS',
'in_progress': False,
'installed_version': '7.29',
'latest_version': '7.50',
'release_summary': None,
'release_url': 'http://download.avm.de/fritzbox/fritzbox-7530-ax/deutschland/fritz.os/info_de.txt',
'skipped_version': None,
'supported_features': <UpdateEntityFeature: 1>,
'title': 'FRITZ!OS',
}),
'context': <ANY>,
'entity_id': 'update.mock_title_fritz_os',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_update_entities_initialized[update.mock_title_fritz_os-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'update',
'entity_category': <EntityCategory.CONFIG: 'config'>,
'entity_id': 'update.mock_title_fritz_os',
'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': 'FRITZ!OS',
'platform': 'fritz',
'previous_unique_id': None,
'supported_features': <UpdateEntityFeature: 1>,
'translation_key': None,
'unique_id': '1C:ED:6F:12:34:11-update',
'unit_of_measurement': None,
})
# ---
# name: test_update_entities_initialized[update.mock_title_fritz_os-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'auto_update': False,
'entity_picture': 'https://brands.home-assistant.io/_/fritz/icon.png',
'friendly_name': 'Mock Title FRITZ!OS',
'in_progress': False,
'installed_version': '7.29',
'latest_version': '7.29',
'release_summary': None,
'release_url': None,
'skipped_version': None,
'supported_features': <UpdateEntityFeature: 1>,
'title': 'FRITZ!OS',
}),
'context': <ANY>,
'entity_id': 'update.mock_title_fritz_os',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---

27
tests/components/fritz/test_button.py
View File

@ -5,11 +5,12 @@ from datetime import timedelta
from unittest.mock import patch from unittest.mock import patch
import pytest import pytest
from syrupy.assertion 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.fritz.const import DOMAIN, MeshRoles from homeassistant.components.fritz.const import DOMAIN, MeshRoles
from homeassistant.config_entries import ConfigEntryState from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.util.dt import utcnow from homeassistant.util.dt import utcnow
@ -21,24 +22,30 @@ from .const import (
MOCK_USER_DATA, MOCK_USER_DATA,
) )
from tests.common import MockConfigEntry, async_fire_time_changed from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
async def test_button_setup(hass: HomeAssistant, fc_class_mock, fh_class_mock) -> None: @pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_button_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
fc_class_mock,
fh_class_mock,
snapshot: SnapshotAssertion,
) -> None:
"""Test setup of Fritz!Tools buttons.""" """Test setup of Fritz!Tools buttons."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) with patch("homeassistant.components.fritz.PLATFORMS", [Platform.BUTTON]):
await hass.async_block_till_done() assert await hass.config_entries.async_setup(entry.entry_id)
assert entry.state is ConfigEntryState.LOADED await hass.async_block_till_done()
buttons = hass.states.async_all(BUTTON_DOMAIN) states = hass.states.async_all()
assert len(buttons) == 4 assert len(states) == 5
for button in buttons: await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert button.state == STATE_UNKNOWN
@pytest.mark.parametrize( @pytest.mark.parametrize(

67
tests/components/fritz/test_diagnostics.py
View File

@ -2,14 +2,13 @@
from __future__ import annotations from __future__ import annotations
from homeassistant.components.diagnostics import REDACTED from syrupy import SnapshotAssertion
from syrupy.filters import props
from homeassistant.components.fritz.const import DOMAIN from homeassistant.components.fritz.const import DOMAIN
from homeassistant.components.fritz.coordinator import AvmWrapper
from homeassistant.components.fritz.diagnostics import TO_REDACT
from homeassistant.config_entries import ConfigEntryState
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from .const import MOCK_MESH_MASTER_MAC, MOCK_USER_DATA from .const import MOCK_USER_DATA
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
@ -21,64 +20,16 @@ async def test_entry_diagnostics(
hass_client: ClientSessionGenerator, hass_client: ClientSessionGenerator,
fc_class_mock, fc_class_mock,
fh_class_mock, fh_class_mock,
snapshot: SnapshotAssertion,
) -> None: ) -> None:
"""Test config entry diagnostics.""" """Test config entry diagnostics."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) assert await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done() await hass.async_block_till_done()
assert entry.state is ConfigEntryState.LOADED
entry_dict = entry.as_dict()
for key in TO_REDACT:
entry_dict["data"][key] = REDACTED
result = await get_diagnostics_for_config_entry(hass, hass_client, entry) result = await get_diagnostics_for_config_entry(hass, hass_client, entry)
avm_wrapper: AvmWrapper = hass.data[DOMAIN][entry.entry_id] assert result == snapshot(
assert result == { exclude=props("created_at", "modified_at", "entry_id", "last_activity")
"entry": entry_dict, )
"device_info": {
"client_devices": [
{
"connected_to": device.connected_to,
"connection_type": device.connection_type,
"hostname": device.hostname,
"is_connected": device.is_connected,
"last_activity": device.last_activity.isoformat(),
"wan_access": device.wan_access,
}
for _, device in avm_wrapper.devices.items()
],
"connection_type": "WANPPPConnection",
"current_firmware": "7.29",
"discovered_services": [
"DeviceInfo1",
"Hosts1",
"LANEthernetInterfaceConfig1",
"Layer3Forwarding1",
"UserInterface1",
"WANCommonIFC1",
"WANCommonInterfaceConfig1",
"WANDSLInterfaceConfig1",
"WANIPConn1",
"WANPPPConnection1",
"WLANConfiguration1",
"X_AVM-DE_Homeauto1",
"X_AVM-DE_HostFilter1",
],
"is_router": True,
"last_exception": None,
"last_update success": True,
"latest_firmware": None,
"mesh_role": "master",
"model": "FRITZ!Box 7530 AX",
"unique_id": MOCK_MESH_MASTER_MAC.replace("6F:12", "XX:XX"),
"update_available": False,
"wan_link_properties": {
"NewLayer1DownstreamMaxBitRate": 318557000,
"NewLayer1UpstreamMaxBitRate": 51805000,
"NewPhysicalLinkStatus": "Up",
"NewWANAccessType": "DSL",
},
},
}

122
tests/components/fritz/test_sensor.py
View File

@ -2,123 +2,47 @@
from __future__ import annotations from __future__ import annotations
from datetime import timedelta from datetime import UTC, datetime, timedelta
from typing import Any from unittest.mock import patch
from fritzconnection.core.exceptions import FritzConnectionException from fritzconnection.core.exceptions import FritzConnectionException
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.components.fritz.const import DOMAIN from homeassistant.components.fritz.const import DOMAIN
from homeassistant.components.fritz.sensor import SENSOR_TYPES from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.components.sensor import ( from homeassistant.const import STATE_UNAVAILABLE, Platform
ATTR_STATE_CLASS,
DOMAIN as SENSOR_DOMAIN,
SensorDeviceClass,
SensorStateClass,
)
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import (
ATTR_DEVICE_CLASS,
ATTR_STATE,
ATTR_UNIT_OF_MEASUREMENT,
STATE_UNAVAILABLE,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
import homeassistant.util.dt as dt_util import homeassistant.util.dt as dt_util
from .const import MOCK_USER_DATA from .const import MOCK_USER_DATA
from tests.common import MockConfigEntry, async_fire_time_changed from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
SENSOR_STATES: dict[str, dict[str, Any]] = {
"sensor.mock_title_external_ip": {
ATTR_STATE: "1.2.3.4",
},
"sensor.mock_title_external_ipv6": {
ATTR_STATE: "fec0::1",
},
"sensor.mock_title_last_restart": {
# ATTR_STATE: "2022-02-05T17:46:04+00:00",
ATTR_DEVICE_CLASS: SensorDeviceClass.TIMESTAMP,
},
"sensor.mock_title_connection_uptime": {
# ATTR_STATE: "2022-03-06T11:27:16+00:00",
ATTR_DEVICE_CLASS: SensorDeviceClass.TIMESTAMP,
},
"sensor.mock_title_upload_throughput": {
ATTR_STATE: "3.4",
ATTR_STATE_CLASS: SensorStateClass.MEASUREMENT,
ATTR_UNIT_OF_MEASUREMENT: "kB/s",
},
"sensor.mock_title_download_throughput": {
ATTR_STATE: "67.6",
ATTR_STATE_CLASS: SensorStateClass.MEASUREMENT,
ATTR_UNIT_OF_MEASUREMENT: "kB/s",
},
"sensor.mock_title_max_connection_upload_throughput": {
ATTR_STATE: "2105.0",
ATTR_UNIT_OF_MEASUREMENT: "kbit/s",
},
"sensor.mock_title_max_connection_download_throughput": {
ATTR_STATE: "10087.0",
ATTR_UNIT_OF_MEASUREMENT: "kbit/s",
},
"sensor.mock_title_gb_sent": {
ATTR_STATE: "1.7",
ATTR_STATE_CLASS: SensorStateClass.TOTAL_INCREASING,
ATTR_UNIT_OF_MEASUREMENT: "GB",
},
"sensor.mock_title_gb_received": {
ATTR_STATE: "5.2",
ATTR_STATE_CLASS: SensorStateClass.TOTAL_INCREASING,
ATTR_UNIT_OF_MEASUREMENT: "GB",
},
"sensor.mock_title_link_upload_throughput": {
ATTR_STATE: "51805.0",
ATTR_UNIT_OF_MEASUREMENT: "kbit/s",
},
"sensor.mock_title_link_download_throughput": {
ATTR_STATE: "318557.0",
ATTR_UNIT_OF_MEASUREMENT: "kbit/s",
},
"sensor.mock_title_link_upload_noise_margin": {
ATTR_STATE: "9.0",
ATTR_UNIT_OF_MEASUREMENT: "dB",
},
"sensor.mock_title_link_download_noise_margin": {
ATTR_STATE: "8.0",
ATTR_UNIT_OF_MEASUREMENT: "dB",
},
"sensor.mock_title_link_upload_power_attenuation": {
ATTR_STATE: "7.0",
ATTR_UNIT_OF_MEASUREMENT: "dB",
},
"sensor.mock_title_link_download_power_attenuation": {
ATTR_STATE: "12.0",
ATTR_UNIT_OF_MEASUREMENT: "dB",
},
}
async def test_sensor_setup(hass: HomeAssistant, fc_class_mock, fh_class_mock) -> None: @pytest.mark.freeze_time(datetime(2024, 9, 1, 20, tzinfo=UTC))
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_sensor_setup(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
fc_class_mock,
fh_class_mock,
snapshot: SnapshotAssertion,
) -> None:
"""Test setup of Fritz!Tools sensors.""" """Test setup of Fritz!Tools sensors."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) with patch("homeassistant.components.fritz.PLATFORMS", [Platform.SENSOR]):
await hass.async_block_till_done() assert await hass.config_entries.async_setup(entry.entry_id)
assert entry.state is ConfigEntryState.LOADED await hass.async_block_till_done()
sensors = hass.states.async_all(SENSOR_DOMAIN) states = hass.states.async_all()
assert len(sensors) == len(SENSOR_TYPES) assert len(states) == 16
for sensor in sensors: await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert SENSOR_STATES.get(sensor.entity_id) is not None
for key, val in SENSOR_STATES[sensor.entity_id].items():
if key == ATTR_STATE:
assert sensor.state == val
else:
assert sensor.attributes.get(key) == val
async def test_sensor_update_fail( async def test_sensor_update_fail(

26
tests/components/fritz/test_switch.py
View File

@ -2,16 +2,19 @@
from __future__ import annotations from __future__ import annotations
from unittest.mock import patch
import pytest import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.components.fritz.const import DOMAIN from homeassistant.components.fritz.const import DOMAIN
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import Platform from homeassistant.const import Platform
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .const import MOCK_FB_SERVICES, MOCK_USER_DATA from .const import MOCK_FB_SERVICES, MOCK_USER_DATA
from tests.common import MockConfigEntry from tests.common import MockConfigEntry, snapshot_platform
MOCK_WLANCONFIGS_SAME_SSID: dict[str, dict] = { MOCK_WLANCONFIGS_SAME_SSID: dict[str, dict] = {
"WLANConfiguration1": { "WLANConfiguration1": {
@ -179,23 +182,24 @@ MOCK_WLANCONFIGS_DIFF2_SSID: dict[str, dict] = {
), ),
], ],
) )
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_switch_setup( async def test_switch_setup(
hass: HomeAssistant, hass: HomeAssistant,
entity_registry: er.EntityRegistry,
expected_wifi_names: list[str], expected_wifi_names: list[str],
fc_class_mock, fc_class_mock,
fh_class_mock, fh_class_mock,
snapshot: SnapshotAssertion,
) -> None: ) -> None:
"""Test setup of Fritz!Tools switches.""" """Test setup of Fritz!Tools switches."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) with patch("homeassistant.components.fritz.PLATFORMS", [Platform.SWITCH]):
await hass.async_block_till_done(wait_background_tasks=True) assert await hass.config_entries.async_setup(entry.entry_id)
assert entry.state is ConfigEntryState.LOADED await hass.async_block_till_done(wait_background_tasks=True)
switches = hass.states.async_all(Platform.SWITCH) states = hass.states.async_all()
assert len(switches) == 3 assert len(states) == 3
assert switches[0].name == f"Mock Title Wi-Fi {expected_wifi_names[0]}"
assert switches[1].name == f"Mock Title Wi-Fi {expected_wifi_names[1]}" await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert switches[2].name == "printer Internet Access"

93
tests/components/fritz/test_update.py
View File

@ -2,10 +2,13 @@
from unittest.mock import patch from unittest.mock import patch
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.components.fritz.const import DOMAIN from homeassistant.components.fritz.const import DOMAIN
from homeassistant.components.update import DOMAIN as UPDATE_DOMAIN from homeassistant.const import Platform
from homeassistant.config_entries import ConfigEntryState
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .const import ( from .const import (
MOCK_FB_SERVICES, MOCK_FB_SERVICES,
@ -14,8 +17,7 @@ from .const import (
MOCK_USER_DATA, MOCK_USER_DATA,
) )
from tests.common import MockConfigEntry from tests.common import MockConfigEntry, snapshot_platform
from tests.typing import ClientSessionGenerator
AVAILABLE_UPDATE = { AVAILABLE_UPDATE = {
"UserInterface1": { "UserInterface1": {
@ -27,30 +29,36 @@ AVAILABLE_UPDATE = {
} }
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_update_entities_initialized( async def test_update_entities_initialized(
hass: HomeAssistant, hass: HomeAssistant,
hass_client: ClientSessionGenerator, entity_registry: er.EntityRegistry,
fc_class_mock, fc_class_mock,
fh_class_mock, fh_class_mock,
snapshot: SnapshotAssertion,
) -> None: ) -> None:
"""Test update entities.""" """Test update entities."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) with patch("homeassistant.components.fritz.PLATFORMS", [Platform.UPDATE]):
await hass.async_block_till_done() assert await hass.config_entries.async_setup(entry.entry_id)
assert entry.state is ConfigEntryState.LOADED await hass.async_block_till_done()
updates = hass.states.async_all(UPDATE_DOMAIN) states = hass.states.async_all()
assert len(updates) == 1 assert len(states) == 1
await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_update_available( async def test_update_available(
hass: HomeAssistant, hass: HomeAssistant,
hass_client: ClientSessionGenerator, entity_registry: er.EntityRegistry,
fc_class_mock, fc_class_mock,
fh_class_mock, fh_class_mock,
snapshot: SnapshotAssertion,
) -> None: ) -> None:
"""Test update entities.""" """Test update entities."""
@ -59,64 +67,45 @@ async def test_update_available(
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) with patch("homeassistant.components.fritz.PLATFORMS", [Platform.UPDATE]):
await hass.async_block_till_done() assert await hass.config_entries.async_setup(entry.entry_id)
assert entry.state is ConfigEntryState.LOADED await hass.async_block_till_done()
update = hass.states.get("update.mock_title_fritz_os") states = hass.states.async_all()
assert update is not None assert len(states) == 1
assert update.state == "on"
assert update.attributes.get("installed_version") == "7.29" await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
assert update.attributes.get("latest_version") == MOCK_FIRMWARE_AVAILABLE
assert update.attributes.get("release_url") == MOCK_FIRMWARE_RELEASE_URL
async def test_no_update_available(
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
fc_class_mock,
fh_class_mock,
) -> None:
"""Test update entities."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert entry.state is ConfigEntryState.LOADED
update = hass.states.get("update.mock_title_fritz_os")
assert update is not None
assert update.state == "off"
assert update.attributes.get("installed_version") == "7.29"
assert update.attributes.get("latest_version") == "7.29"
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
async def test_available_update_can_be_installed( async def test_available_update_can_be_installed(
hass: HomeAssistant, hass: HomeAssistant,
hass_client: ClientSessionGenerator, entity_registry: er.EntityRegistry,
fc_class_mock, fc_class_mock,
fh_class_mock, fh_class_mock,
snapshot: SnapshotAssertion,
) -> None: ) -> None:
"""Test update entities.""" """Test update entities."""
fc_class_mock().override_services({**MOCK_FB_SERVICES, **AVAILABLE_UPDATE}) fc_class_mock().override_services({**MOCK_FB_SERVICES, **AVAILABLE_UPDATE})
with patch( with (
"homeassistant.components.fritz.coordinator.FritzBoxTools.async_trigger_firmware_update", patch(
return_value=True, "homeassistant.components.fritz.coordinator.FritzBoxTools.async_trigger_firmware_update",
) as mocked_update_call: return_value=True,
) as mocked_update_call,
patch("homeassistant.components.fritz.PLATFORMS", [Platform.UPDATE]),
):
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA) entry = MockConfigEntry(domain=DOMAIN, data=MOCK_USER_DATA)
entry.add_to_hass(hass) entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) assert await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done() await hass.async_block_till_done()
assert entry.state is ConfigEntryState.LOADED
update = hass.states.get("update.mock_title_fritz_os") states = hass.states.async_all()
assert update is not None assert len(states) == 1
assert update.state == "on"
await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
await hass.services.async_call( await hass.services.async_call(
"update", "update",