From 11644d48ee930426c82c4f8d6977b43e87448d67 Mon Sep 17 00:00:00 2001 From: Yuxin Wang Date: Wed, 14 May 2025 10:04:07 -0400 Subject: [PATCH] Use snapshot testing for APCUPSD integration (#130770) * First try to use snapshot testing for sensors * Use snapshot testing * Add ambr files * Update comment * Address review comments * Remove duplicate async init integration call * Add device test for cases w/o SERIALNO * Use friendlier snapshot names * Use * to mandate keyed argument for async_init_integration * Always pass mock config entry ID * Fix incorrect ID --- tests/components/apcupsd/__init__.py | 7 +- .../apcupsd/snapshots/test_binary_sensor.ambr | 48 + .../apcupsd/snapshots/test_init.ambr | 133 ++ .../apcupsd/snapshots/test_sensor.ambr | 1992 +++++++++++++++++ .../components/apcupsd/test_binary_sensor.py | 26 +- tests/components/apcupsd/test_init.py | 98 +- tests/components/apcupsd/test_sensor.py | 136 +- 7 files changed, 2244 insertions(+), 196 deletions(-) create mode 100644 tests/components/apcupsd/snapshots/test_binary_sensor.ambr create mode 100644 tests/components/apcupsd/snapshots/test_init.ambr create mode 100644 tests/components/apcupsd/snapshots/test_sensor.ambr diff --git a/tests/components/apcupsd/__init__.py b/tests/components/apcupsd/__init__.py index 5994a7f4c17..2a786925e70 100644 --- a/tests/components/apcupsd/__init__.py +++ b/tests/components/apcupsd/__init__.py @@ -82,13 +82,18 @@ MOCK_MINIMAL_STATUS: Final = OrderedDict( async def async_init_integration( - hass: HomeAssistant, host: str = "test", status: dict[str, str] | None = None + hass: HomeAssistant, + *, + host: str = "test", + status: dict[str, str] | None = None, + entry_id: str = "mocked-config-entry-id", ) -> MockConfigEntry: """Set up the APC UPS Daemon integration in HomeAssistant.""" if status is None: status = MOCK_STATUS entry = MockConfigEntry( + entry_id=entry_id, version=1, domain=DOMAIN, title="APCUPSd", diff --git a/tests/components/apcupsd/snapshots/test_binary_sensor.ambr b/tests/components/apcupsd/snapshots/test_binary_sensor.ambr new file mode 100644 index 00000000000..0ab9dfb047e --- /dev/null +++ b/tests/components/apcupsd/snapshots/test_binary_sensor.ambr @@ -0,0 +1,48 @@ +# serializer version: 1 +# name: test_binary_sensor[binary_sensor.myups_online_status-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'binary_sensor', + 'entity_category': None, + 'entity_id': 'binary_sensor.myups_online_status', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Online status', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'online_status', + 'unique_id': 'XXXXXXXXXXXX_statflag', + 'unit_of_measurement': None, + }) +# --- +# name: test_binary_sensor[binary_sensor.myups_online_status-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Online status', + }), + 'context': , + 'entity_id': 'binary_sensor.myups_online_status', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'on', + }) +# --- diff --git a/tests/components/apcupsd/snapshots/test_init.ambr b/tests/components/apcupsd/snapshots/test_init.ambr new file mode 100644 index 00000000000..39f28b528fc --- /dev/null +++ b/tests/components/apcupsd/snapshots/test_init.ambr @@ -0,0 +1,133 @@ +# serializer version: 1 +# name: test_async_setup_entry[status0][device_MyUPS_XXXXXXXXXXXX] + DeviceRegistryEntrySnapshot({ + 'area_id': None, + 'config_entries': , + 'config_entries_subentries': , + 'configuration_url': None, + 'connections': set({ + }), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': '928.a8 .D USB FW:a8', + 'id': , + 'identifiers': set({ + tuple( + 'apcupsd', + 'XXXXXXXXXXXX', + ), + }), + 'is_new': False, + 'labels': set({ + }), + 'manufacturer': 'APC', + 'model': 'Back-UPS ES 600', + 'model_id': None, + 'name': 'MyUPS', + 'name_by_user': None, + 'primary_config_entry': , + 'serial_number': None, + 'suggested_area': None, + 'sw_version': '3.14.14 (31 May 2016) unknown', + 'via_device_id': None, + }) +# --- +# name: test_async_setup_entry[status1][device_APC UPS_XXXX] + DeviceRegistryEntrySnapshot({ + 'area_id': None, + 'config_entries': , + 'config_entries_subentries': , + 'configuration_url': None, + 'connections': set({ + }), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': None, + 'id': , + 'identifiers': set({ + tuple( + 'apcupsd', + 'XXXX', + ), + }), + 'is_new': False, + 'labels': set({ + }), + 'manufacturer': 'APC', + 'model': None, + 'model_id': None, + 'name': 'APC UPS', + 'name_by_user': None, + 'primary_config_entry': , + 'serial_number': None, + 'suggested_area': None, + 'sw_version': None, + 'via_device_id': None, + }) +# --- +# name: test_async_setup_entry[status2][device_APC UPS_] + DeviceRegistryEntrySnapshot({ + 'area_id': None, + 'config_entries': , + 'config_entries_subentries': , + 'configuration_url': None, + 'connections': set({ + }), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': None, + 'id': , + 'identifiers': set({ + tuple( + 'apcupsd', + 'mocked-config-entry-id', + ), + }), + 'is_new': False, + 'labels': set({ + }), + 'manufacturer': 'APC', + 'model': None, + 'model_id': None, + 'name': 'APC UPS', + 'name_by_user': None, + 'primary_config_entry': , + 'serial_number': None, + 'suggested_area': None, + 'sw_version': None, + 'via_device_id': None, + }) +# --- +# name: test_async_setup_entry[status3][device_APC UPS_Blank] + DeviceRegistryEntrySnapshot({ + 'area_id': None, + 'config_entries': , + 'config_entries_subentries': , + 'configuration_url': None, + 'connections': set({ + }), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': None, + 'id': , + 'identifiers': set({ + tuple( + 'apcupsd', + 'mocked-config-entry-id', + ), + }), + 'is_new': False, + 'labels': set({ + }), + 'manufacturer': 'APC', + 'model': None, + 'model_id': None, + 'name': 'APC UPS', + 'name_by_user': None, + 'primary_config_entry': , + 'serial_number': None, + 'suggested_area': None, + 'sw_version': None, + 'via_device_id': None, + }) +# --- diff --git a/tests/components/apcupsd/snapshots/test_sensor.ambr b/tests/components/apcupsd/snapshots/test_sensor.ambr new file mode 100644 index 00000000000..6409f205d4f --- /dev/null +++ b/tests/components/apcupsd/snapshots/test_sensor.ambr @@ -0,0 +1,1992 @@ +# serializer version: 1 +# name: test_sensor[sensor.myups_alarm_delay-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_alarm_delay', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Alarm delay', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'alarm_delay', + 'unique_id': 'XXXXXXXXXXXX_alarmdel', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_alarm_delay-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Alarm delay', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_alarm_delay', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '30', + }) +# --- +# name: test_sensor[sensor.myups_battery-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_battery', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Battery', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': 'XXXXXXXXXXXX_bcharge', + 'unit_of_measurement': '%', + }) +# --- +# name: test_sensor[sensor.myups_battery-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'battery', + 'friendly_name': 'MyUPS Battery', + 'state_class': , + 'unit_of_measurement': '%', + }), + 'context': , + 'entity_id': 'sensor.myups_battery', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '100.0', + }) +# --- +# name: test_sensor[sensor.myups_battery_nominal_voltage-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_battery_nominal_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Battery nominal voltage', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'battery_nominal_voltage', + 'unique_id': 'XXXXXXXXXXXX_nombattv', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_battery_nominal_voltage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'MyUPS Battery nominal voltage', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_battery_nominal_voltage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '12.0', + }) +# --- +# name: test_sensor[sensor.myups_battery_replaced-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_battery_replaced', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Battery replaced', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'battery_replacement_date', + 'unique_id': 'XXXXXXXXXXXX_battdate', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_battery_replaced-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Battery replaced', + }), + 'context': , + 'entity_id': 'sensor.myups_battery_replaced', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1970-01-01', + }) +# --- +# name: test_sensor[sensor.myups_battery_shutdown-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_battery_shutdown', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Battery shutdown', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'max_battery_charge', + 'unique_id': 'XXXXXXXXXXXX_mbattchg', + 'unit_of_measurement': '%', + }) +# --- +# name: test_sensor[sensor.myups_battery_shutdown-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Battery shutdown', + 'unit_of_measurement': '%', + }), + 'context': , + 'entity_id': 'sensor.myups_battery_shutdown', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '5', + }) +# --- +# name: test_sensor[sensor.myups_battery_timeout-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_battery_timeout', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Battery timeout', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'max_time', + 'unique_id': 'XXXXXXXXXXXX_maxtime', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_battery_timeout-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Battery timeout', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_battery_timeout', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[sensor.myups_battery_voltage-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_battery_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Battery voltage', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'battery_voltage', + 'unique_id': 'XXXXXXXXXXXX_battv', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_battery_voltage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'MyUPS Battery voltage', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_battery_voltage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '13.7', + }) +# --- +# name: test_sensor[sensor.myups_cable_type-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_cable_type', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Cable type', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'cable_type', + 'unique_id': 'XXXXXXXXXXXX_cable', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_cable_type-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Cable type', + }), + 'context': , + 'entity_id': 'sensor.myups_cable_type', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'USB Cable', + }) +# --- +# name: test_sensor[sensor.myups_daemon_version-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_daemon_version', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Daemon version', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'version', + 'unique_id': 'XXXXXXXXXXXX_version', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_daemon_version-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Daemon version', + }), + 'context': , + 'entity_id': 'sensor.myups_daemon_version', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '3.14.14 (31 May 2016) unknown', + }) +# --- +# name: test_sensor[sensor.myups_date_and_time-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_date_and_time', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Date and time', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'date_and_time', + 'unique_id': 'XXXXXXXXXXXX_end apc', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_date_and_time-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Date and time', + }), + 'context': , + 'entity_id': 'sensor.myups_date_and_time', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1970-01-01 00:00:00 0000', + }) +# --- +# name: test_sensor[sensor.myups_driver-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_driver', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Driver', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'driver', + 'unique_id': 'XXXXXXXXXXXX_driver', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_driver-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Driver', + }), + 'context': , + 'entity_id': 'sensor.myups_driver', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'USB UPS Driver', + }) +# --- +# name: test_sensor[sensor.myups_firmware_version-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_firmware_version', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Firmware version', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'firmware_version', + 'unique_id': 'XXXXXXXXXXXX_firmware', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_firmware_version-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Firmware version', + }), + 'context': , + 'entity_id': 'sensor.myups_firmware_version', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '928.a8 .D USB FW:a8', + }) +# --- +# name: test_sensor[sensor.myups_input_voltage-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_input_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Input voltage', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'line_voltage', + 'unique_id': 'XXXXXXXXXXXX_linev', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_input_voltage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'MyUPS Input voltage', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_input_voltage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '124.0', + }) +# --- +# name: test_sensor[sensor.myups_internal_temperature-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_internal_temperature', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Internal temperature', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'internal_temperature', + 'unique_id': 'XXXXXXXXXXXX_itemp', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_internal_temperature-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'temperature', + 'friendly_name': 'MyUPS Internal temperature', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_internal_temperature', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '34.6', + }) +# --- +# name: test_sensor[sensor.myups_last_self_test-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_last_self_test', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Last self test', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'last_self_test', + 'unique_id': 'XXXXXXXXXXXX_laststest', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_last_self_test-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Last self test', + }), + 'context': , + 'entity_id': 'sensor.myups_last_self_test', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1970-01-01 00:00:00 0000', + }) +# --- +# name: test_sensor[sensor.myups_last_transfer-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_last_transfer', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Last transfer', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'last_transfer', + 'unique_id': 'XXXXXXXXXXXX_lastxfer', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_last_transfer-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Last transfer', + }), + 'context': , + 'entity_id': 'sensor.myups_last_transfer', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'Automatic or explicit self test', + }) +# --- +# name: test_sensor[sensor.myups_load-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_load', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Load', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'load_capacity', + 'unique_id': 'XXXXXXXXXXXX_loadpct', + 'unit_of_measurement': '%', + }) +# --- +# name: test_sensor[sensor.myups_load-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Load', + 'state_class': , + 'unit_of_measurement': '%', + }), + 'context': , + 'entity_id': 'sensor.myups_load', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '14.0', + }) +# --- +# name: test_sensor[sensor.myups_mode-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_mode', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Mode', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'ups_mode', + 'unique_id': 'XXXXXXXXXXXX_upsmode', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_mode-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Mode', + }), + 'context': , + 'entity_id': 'sensor.myups_mode', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'Stand Alone', + }) +# --- +# name: test_sensor[sensor.myups_model-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_model', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Model', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'model', + 'unique_id': 'XXXXXXXXXXXX_model', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_model-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Model', + }), + 'context': , + 'entity_id': 'sensor.myups_model', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'Back-UPS ES 600', + }) +# --- +# name: test_sensor[sensor.myups_name-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_name', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Name', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'ups_name', + 'unique_id': 'XXXXXXXXXXXX_upsname', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_name-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Name', + }), + 'context': , + 'entity_id': 'sensor.myups_name', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'MyUPS', + }) +# --- +# name: test_sensor[sensor.myups_nominal_apparent_power-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_nominal_apparent_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Nominal apparent power', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'nominal_apparent_power', + 'unique_id': 'XXXXXXXXXXXX_nomapnt', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_nominal_apparent_power-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'apparent_power', + 'friendly_name': 'MyUPS Nominal apparent power', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_nominal_apparent_power', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '60.0', + }) +# --- +# name: test_sensor[sensor.myups_nominal_input_voltage-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_nominal_input_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Nominal input voltage', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'nominal_input_voltage', + 'unique_id': 'XXXXXXXXXXXX_nominv', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_nominal_input_voltage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'MyUPS Nominal input voltage', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_nominal_input_voltage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '120', + }) +# --- +# name: test_sensor[sensor.myups_nominal_output_power-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_nominal_output_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Nominal output power', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'nominal_output_power', + 'unique_id': 'XXXXXXXXXXXX_nompower', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_nominal_output_power-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power', + 'friendly_name': 'MyUPS Nominal output power', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_nominal_output_power', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '330', + }) +# --- +# name: test_sensor[sensor.myups_output_current-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_output_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Output current', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'output_current', + 'unique_id': 'XXXXXXXXXXXX_outcurnt', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_output_current-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'MyUPS Output current', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_output_current', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.88', + }) +# --- +# name: test_sensor[sensor.myups_self_test_interval-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_self_test_interval', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Self test interval', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'self_test_interval', + 'unique_id': 'XXXXXXXXXXXX_stesti', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_self_test_interval-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Self test interval', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_self_test_interval', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '7', + }) +# --- +# name: test_sensor[sensor.myups_self_test_result-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_self_test_result', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Self test result', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'self_test_result', + 'unique_id': 'XXXXXXXXXXXX_selftest', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_self_test_result-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Self test result', + }), + 'context': , + 'entity_id': 'sensor.myups_self_test_result', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'NO', + }) +# --- +# name: test_sensor[sensor.myups_sensitivity-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_sensitivity', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Sensitivity', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'sensitivity', + 'unique_id': 'XXXXXXXXXXXX_sense', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_sensitivity-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Sensitivity', + }), + 'context': , + 'entity_id': 'sensor.myups_sensitivity', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'Medium', + }) +# --- +# name: test_sensor[sensor.myups_serial_number-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_serial_number', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Serial number', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'serial_number', + 'unique_id': 'XXXXXXXXXXXX_serialno', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_serial_number-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Serial number', + }), + 'context': , + 'entity_id': 'sensor.myups_serial_number', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'XXXXXXXXXXXX', + }) +# --- +# name: test_sensor[sensor.myups_shutdown_time-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_shutdown_time', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Shutdown time', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'min_time', + 'unique_id': 'XXXXXXXXXXXX_mintimel', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_shutdown_time-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Shutdown time', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_shutdown_time', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '3', + }) +# --- +# name: test_sensor[sensor.myups_status-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_status', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Status', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'status', + 'unique_id': 'XXXXXXXXXXXX_status', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_status-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Status', + }), + 'context': , + 'entity_id': 'sensor.myups_status', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'ONLINE', + }) +# --- +# name: test_sensor[sensor.myups_status_data-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_status_data', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Status data', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'apc_status', + 'unique_id': 'XXXXXXXXXXXX_apc', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_status_data-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Status data', + }), + 'context': , + 'entity_id': 'sensor.myups_status_data', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '001,038,0985', + }) +# --- +# name: test_sensor[sensor.myups_status_date-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_status_date', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Status date', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'date', + 'unique_id': 'XXXXXXXXXXXX_date', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_status_date-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Status date', + }), + 'context': , + 'entity_id': 'sensor.myups_status_date', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1970-01-01 00:00:00 0000', + }) +# --- +# name: test_sensor[sensor.myups_status_flag-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_status_flag', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Status flag', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'online_status', + 'unique_id': 'XXXXXXXXXXXX_statflag', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_status_flag-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Status flag', + }), + 'context': , + 'entity_id': 'sensor.myups_status_flag', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0x05000008', + }) +# --- +# name: test_sensor[sensor.myups_time_left-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_time_left', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Time left', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'time_left', + 'unique_id': 'XXXXXXXXXXXX_timeleft', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_time_left-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'duration', + 'friendly_name': 'MyUPS Time left', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_time_left', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '51.0', + }) +# --- +# name: test_sensor[sensor.myups_time_on_battery-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_time_on_battery', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Time on battery', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'time_on_battery', + 'unique_id': 'XXXXXXXXXXXX_tonbatt', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_time_on_battery-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'duration', + 'friendly_name': 'MyUPS Time on battery', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_time_on_battery', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[sensor.myups_total_time_on_battery-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_total_time_on_battery', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Total time on battery', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'total_time_on_battery', + 'unique_id': 'XXXXXXXXXXXX_cumonbatt', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_total_time_on_battery-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'duration', + 'friendly_name': 'MyUPS Total time on battery', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_total_time_on_battery', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '8', + }) +# --- +# name: test_sensor[sensor.myups_transfer_count-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_transfer_count', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Transfer count', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'transfer_count', + 'unique_id': 'XXXXXXXXXXXX_numxfers', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_transfer_count-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Transfer count', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.myups_transfer_count', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1', + }) +# --- +# name: test_sensor[sensor.myups_transfer_from_battery-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_transfer_from_battery', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Transfer from battery', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'transfer_from_battery', + 'unique_id': 'XXXXXXXXXXXX_xoffbatt', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_transfer_from_battery-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Transfer from battery', + }), + 'context': , + 'entity_id': 'sensor.myups_transfer_from_battery', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1970-01-01 00:00:00 0000', + }) +# --- +# name: test_sensor[sensor.myups_transfer_high-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_transfer_high', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Transfer high', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'transfer_high', + 'unique_id': 'XXXXXXXXXXXX_hitrans', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_transfer_high-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'MyUPS Transfer high', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_transfer_high', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '139.0', + }) +# --- +# name: test_sensor[sensor.myups_transfer_low-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_transfer_low', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Transfer low', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'transfer_low', + 'unique_id': 'XXXXXXXXXXXX_lotrans', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[sensor.myups_transfer_low-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'MyUPS Transfer low', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.myups_transfer_low', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '92.0', + }) +# --- +# name: test_sensor[sensor.myups_transfer_to_battery-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.myups_transfer_to_battery', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Transfer to battery', + 'platform': 'apcupsd', + 'previous_unique_id': None, + 'supported_features': 0, + 'translation_key': 'transfer_to_battery', + 'unique_id': 'XXXXXXXXXXXX_xonbatt', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[sensor.myups_transfer_to_battery-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'MyUPS Transfer to battery', + }), + 'context': , + 'entity_id': 'sensor.myups_transfer_to_battery', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1970-01-01 00:00:00 0000', + }) +# --- diff --git a/tests/components/apcupsd/test_binary_sensor.py b/tests/components/apcupsd/test_binary_sensor.py index 02351109603..d9d45830024 100644 --- a/tests/components/apcupsd/test_binary_sensor.py +++ b/tests/components/apcupsd/test_binary_sensor.py @@ -1,27 +1,29 @@ """Test binary sensors of APCUPSd integration.""" -import pytest +from unittest.mock import patch +import pytest +from syrupy import SnapshotAssertion + +from homeassistant.const import Platform from homeassistant.core import HomeAssistant from homeassistant.helpers import entity_registry as er from homeassistant.util import slugify from . import MOCK_STATUS, async_init_integration +from tests.common import snapshot_platform + async def test_binary_sensor( - hass: HomeAssistant, entity_registry: er.EntityRegistry + hass: HomeAssistant, + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, ) -> None: - """Test states of binary sensor.""" - await async_init_integration(hass, status=MOCK_STATUS) - - device_slug, serialno = slugify(MOCK_STATUS["UPSNAME"]), MOCK_STATUS["SERIALNO"] - state = hass.states.get(f"binary_sensor.{device_slug}_online_status") - assert state - assert state.state == "on" - entry = entity_registry.async_get(f"binary_sensor.{device_slug}_online_status") - assert entry - assert entry.unique_id == f"{serialno}_statflag" + """Test states of binary sensors.""" + with patch("homeassistant.components.apcupsd.PLATFORMS", [Platform.BINARY_SENSOR]): + config_entry = await async_init_integration(hass, status=MOCK_STATUS) + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) async def test_no_binary_sensor(hass: HomeAssistant) -> None: diff --git a/tests/components/apcupsd/test_init.py b/tests/components/apcupsd/test_init.py index 9edf4d8282f..e5c295ae1bf 100644 --- a/tests/components/apcupsd/test_init.py +++ b/tests/components/apcupsd/test_init.py @@ -5,6 +5,7 @@ from collections import OrderedDict from unittest.mock import patch import pytest +from syrupy import SnapshotAssertion from homeassistant.components.apcupsd.const import DOMAIN from homeassistant.components.apcupsd.coordinator import UPDATE_INTERVAL @@ -12,6 +13,7 @@ from homeassistant.config_entries import SOURCE_USER, ConfigEntryState from homeassistant.const import STATE_UNAVAILABLE from homeassistant.core import HomeAssistant from homeassistant.helpers import device_registry as dr +from homeassistant.helpers.entity_platform import async_get_platforms from homeassistant.util import slugify, utcnow from . import CONF_DATA, MOCK_MINIMAL_STATUS, MOCK_STATUS, async_init_integration @@ -28,71 +30,31 @@ from tests.common import MockConfigEntry, async_fire_time_changed # Contains "SERIALNO" but no "UPSNAME" field. # We should create devices for the entities and prefix their IDs with default "APC UPS". MOCK_MINIMAL_STATUS | {"SERIALNO": "XXXX"}, - # Does not contain either "SERIALNO" field or "UPSNAME" field. Our integration should work - # fine without it by falling back to config entry ID as unique ID and "APC UPS" as default name. + # Does not contain either "SERIALNO" field or "UPSNAME" field. + # Our integration should work fine without it by falling back to config entry ID as unique + # ID and "APC UPS" as default name. MOCK_MINIMAL_STATUS, # Some models report "Blank" as SERIALNO, but we should treat it as not reported. MOCK_MINIMAL_STATUS | {"SERIALNO": "Blank"}, ], ) -async def test_async_setup_entry(hass: HomeAssistant, status: OrderedDict) -> None: - """Test a successful setup entry.""" - await async_init_integration(hass, status=status) - - prefix = slugify(status.get("UPSNAME", "APC UPS")) + "_" - - # Verify successful setup by querying the status sensor. - state = hass.states.get(f"binary_sensor.{prefix}online_status") - assert state - assert state.state != STATE_UNAVAILABLE - assert state.state == "on" - - -@pytest.mark.parametrize( - "status", - [ - # We should not create device entries if SERIALNO is not reported. - MOCK_MINIMAL_STATUS, - # Some models report "Blank" as SERIALNO, but we should treat it as not reported. - MOCK_MINIMAL_STATUS | {"SERIALNO": "Blank"}, - # We should set the device name to be the friendly UPSNAME field if available. - MOCK_MINIMAL_STATUS | {"SERIALNO": "XXXX", "UPSNAME": "MyUPS"}, - # Otherwise, we should fall back to default device name --- "APC UPS". - MOCK_MINIMAL_STATUS | {"SERIALNO": "XXXX"}, - # We should create all fields of the device entry if they are available. - MOCK_STATUS, - ], -) -async def test_device_entry( - hass: HomeAssistant, status: OrderedDict, device_registry: dr.DeviceRegistry +async def test_async_setup_entry( + hass: HomeAssistant, + status: OrderedDict, + device_registry: dr.DeviceRegistry, + snapshot: SnapshotAssertion, ) -> None: - """Test successful setup of device entries.""" + """Test a successful setup entry.""" config_entry = await async_init_integration(hass, status=status) - - # Verify device info is properly set up. - assert len(device_registry.devices) == 1 - entry = device_registry.async_get_device( - {(DOMAIN, config_entry.unique_id or config_entry.entry_id)} + device_entry = device_registry.async_get_device( + identifiers={(DOMAIN, config_entry.unique_id or config_entry.entry_id)} ) - assert entry is not None - # Specify the mapping between field name and the expected fields in device entry. - fields = { - "UPSNAME": entry.name, - "MODEL": entry.model, - "VERSION": entry.sw_version, - "FIRMWARE": entry.hw_version, - } + name = f"device_{device_entry.name}_{status.get('SERIALNO', '')}" + assert device_entry == snapshot(name=name) - for field, entry_value in fields.items(): - if field in status: - assert entry_value == status[field] - # Even if UPSNAME is not available, we must fall back to default "APC UPS". - elif field == "UPSNAME": - assert entry_value == "APC UPS" - else: - assert not entry_value - - assert entry.manufacturer == "APC" + platforms = async_get_platforms(hass, DOMAIN) + assert len(platforms) > 0 + assert all(len(p.entities) > 0 for p in platforms) async def test_multiple_integrations(hass: HomeAssistant) -> None: @@ -101,8 +63,12 @@ async def test_multiple_integrations(hass: HomeAssistant) -> None: status1 = MOCK_STATUS | {"LOADPCT": "15.0 Percent", "SERIALNO": "XXXXX1"} status2 = MOCK_STATUS | {"LOADPCT": "16.0 Percent", "SERIALNO": "XXXXX2"} entries = ( - await async_init_integration(hass, host="test1", status=status1), - await async_init_integration(hass, host="test2", status=status2), + await async_init_integration( + hass, host="test1", status=status1, entry_id="entry-id-1" + ), + await async_init_integration( + hass, host="test2", status=status2, entry_id="entry-id-2" + ), ) assert len(hass.config_entries.async_entries(DOMAIN)) == 2 @@ -121,8 +87,12 @@ async def test_multiple_integrations_different_devices(hass: HomeAssistant) -> N status1 = MOCK_STATUS | {"SERIALNO": "XXXXX1", "UPSNAME": "MyUPS1"} status2 = MOCK_STATUS | {"SERIALNO": "XXXXX2", "UPSNAME": "MyUPS2"} entries = ( - await async_init_integration(hass, host="test1", status=status1), - await async_init_integration(hass, host="test2", status=status2), + await async_init_integration( + hass, host="test1", status=status1, entry_id="entry-id-1" + ), + await async_init_integration( + hass, host="test2", status=status2, entry_id="entry-id-2" + ), ) assert len(hass.config_entries.async_entries(DOMAIN)) == 2 @@ -159,8 +129,12 @@ async def test_unload_remove_entry(hass: HomeAssistant) -> None: """Test successful unload and removal of an entry.""" # Load two integrations from two mock hosts. entries = ( - await async_init_integration(hass, host="test1", status=MOCK_STATUS), - await async_init_integration(hass, host="test2", status=MOCK_MINIMAL_STATUS), + await async_init_integration( + hass, host="test1", status=MOCK_STATUS, entry_id="entry-id-1" + ), + await async_init_integration( + hass, host="test2", status=MOCK_MINIMAL_STATUS, entry_id="entry-id-2" + ), ) # Assert they are loaded. diff --git a/tests/components/apcupsd/test_sensor.py b/tests/components/apcupsd/test_sensor.py index f36421c4183..b14db49970b 100644 --- a/tests/components/apcupsd/test_sensor.py +++ b/tests/components/apcupsd/test_sensor.py @@ -3,22 +3,15 @@ from datetime import timedelta from unittest.mock import patch +import pytest +from syrupy import SnapshotAssertion + from homeassistant.components.apcupsd.coordinator import REQUEST_REFRESH_COOLDOWN -from homeassistant.components.sensor import ( - ATTR_STATE_CLASS, - SensorDeviceClass, - SensorStateClass, -) from homeassistant.const import ( - ATTR_DEVICE_CLASS, ATTR_ENTITY_ID, - ATTR_UNIT_OF_MEASUREMENT, - PERCENTAGE, STATE_UNAVAILABLE, STATE_UNKNOWN, - UnitOfElectricPotential, - UnitOfPower, - UnitOfTime, + Platform, ) from homeassistant.core import HomeAssistant from homeassistant.helpers import entity_registry as er @@ -28,118 +21,19 @@ from homeassistant.util.dt import utcnow from . import MOCK_MINIMAL_STATUS, MOCK_STATUS, async_init_integration -from tests.common import async_fire_time_changed +from tests.common import async_fire_time_changed, snapshot_platform -async def test_sensor(hass: HomeAssistant, entity_registry: er.EntityRegistry) -> None: - """Test states of sensor.""" - await async_init_integration(hass, status=MOCK_STATUS) - device_slug, serialno = slugify(MOCK_STATUS["UPSNAME"]), MOCK_STATUS["SERIALNO"] - - # Test a representative string sensor. - state = hass.states.get(f"sensor.{device_slug}_mode") - assert state - assert state.state == "Stand Alone" - entry = entity_registry.async_get(f"sensor.{device_slug}_mode") - assert entry - assert entry.unique_id == f"{serialno}_upsmode" - - # Test two representative voltage sensors. - state = hass.states.get(f"sensor.{device_slug}_input_voltage") - assert state - assert state.state == "124.0" - assert ( - state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfElectricPotential.VOLT - ) - assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT - assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.VOLTAGE - entry = entity_registry.async_get(f"sensor.{device_slug}_input_voltage") - assert entry - assert entry.unique_id == f"{serialno}_linev" - - state = hass.states.get(f"sensor.{device_slug}_battery_voltage") - assert state - assert state.state == "13.7" - assert ( - state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfElectricPotential.VOLT - ) - assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT - assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.VOLTAGE - entry = entity_registry.async_get(f"sensor.{device_slug}_battery_voltage") - assert entry - assert entry.unique_id == f"{serialno}_battv" - - # Test a representative time sensor. - state = hass.states.get(f"sensor.{device_slug}_self_test_interval") - assert state - assert state.state == "7" - assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTime.DAYS - entry = entity_registry.async_get(f"sensor.{device_slug}_self_test_interval") - assert entry - assert entry.unique_id == f"{serialno}_stesti" - - # Test a representative percentage sensor. - state = hass.states.get(f"sensor.{device_slug}_load") - assert state - assert state.state == "14.0" - assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == PERCENTAGE - assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT - entry = entity_registry.async_get(f"sensor.{device_slug}_load") - assert entry - assert entry.unique_id == f"{serialno}_loadpct" - - # Test a representative wattage sensor. - state = hass.states.get(f"sensor.{device_slug}_nominal_output_power") - assert state - assert state.state == "330" - assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfPower.WATT - assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.POWER - entry = entity_registry.async_get(f"sensor.{device_slug}_nominal_output_power") - assert entry - assert entry.unique_id == f"{serialno}_nompower" - - -async def test_sensor_name(hass: HomeAssistant) -> None: - """Test if sensor name follows the recommended entity naming scheme. - - See https://developers.home-assistant.io/docs/core/entity/#entity-naming for more details. - """ - await async_init_integration(hass, status=MOCK_STATUS) - - all_states = hass.states.async_all() - assert len(all_states) != 0 - - device_name = MOCK_STATUS["UPSNAME"] - for state in all_states: - # Friendly name must start with the device name. - friendly_name = state.name - assert friendly_name.startswith(device_name) - - # Entity names should start with a capital letter, the rest of the words are lower case. - entity_name = friendly_name.removeprefix(device_name).strip() - assert entity_name == entity_name.capitalize() - - -async def test_sensor_disabled( - hass: HomeAssistant, entity_registry: er.EntityRegistry +@pytest.mark.usefixtures("entity_registry_enabled_by_default") +async def test_sensor( + hass: HomeAssistant, + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, ) -> None: - """Test sensor disabled by default.""" - await async_init_integration(hass) - - device_slug, serialno = slugify(MOCK_STATUS["UPSNAME"]), MOCK_STATUS["SERIALNO"] - # Test a representative integration-disabled sensor. - entry = entity_registry.async_get(f"sensor.{device_slug}_model") - assert entry.disabled - assert entry.unique_id == f"{serialno}_model" - assert entry.disabled_by is er.RegistryEntryDisabler.INTEGRATION - - # Test enabling entity. - updated_entry = entity_registry.async_update_entity( - entry.entity_id, disabled_by=None - ) - - assert updated_entry != entry - assert updated_entry.disabled is False + """Test states of sensor.""" + with patch("homeassistant.components.apcupsd.PLATFORMS", [Platform.SENSOR]): + config_entry = await async_init_integration(hass, status=MOCK_STATUS) + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) async def test_state_update(hass: HomeAssistant) -> None: @@ -241,7 +135,7 @@ async def test_multiple_manual_update_entity(hass: HomeAssistant) -> None: async def test_sensor_unknown(hass: HomeAssistant) -> None: - """Test if our integration can properly certain sensors as unknown when it becomes so.""" + """Test if our integration can properly mark certain sensors as unknown when it becomes so.""" await async_init_integration(hass, status=MOCK_MINIMAL_STATUS) ups_mode_id = "sensor.apc_ups_mode"