evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Snapshot more platforms for Matter (#127541)

Browse source 
* Snapshot more platforms for Matter

* Fix

* Fix

* Fix

* Fix tests
This commit is contained in:
Joost Lekkerkerker 2024-10-08 16:17:21 +02:00 • committed by GitHub
parent d8b51b4f2c
commit 00a037c786
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 8479 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2812
tests/components/matter/snapshots/test_button.ambr Normal file
View file

File diff suppressed because it is too large Load diff

263
tests/components/matter/snapshots/test_climate.ambr Normal file
View file

@ -0,0 +1,263 @@
# serializer version: 1
# name: test_climates[air_purifier][climate.air_purifier_thermostat-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
]),
'max_temp': 30.0,
'min_temp': 5.0,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.air_purifier_thermostat',
'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': 'Thermostat',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': 'thermostat',
'unique_id': '00000000000004D2-000000000000008F-MatterNodeDevice-5-MatterThermostat-513-0',
'unit_of_measurement': None,
})
# ---
# name: test_climates[air_purifier][climate.air_purifier_thermostat-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_temperature': 20.0,
'friendly_name': 'Air Purifier Thermostat',
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
]),
'max_temp': 30.0,
'min_temp': 5.0,
'supported_features': <ClimateEntityFeature: 385>,
'temperature': 20.0,
}),
'context': <ANY>,
'entity_id': 'climate.air_purifier_thermostat',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_climates[eve_thermo][climate.eve_thermo_thermostat-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
]),
'max_temp': 30.0,
'min_temp': 10.0,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.eve_thermo_thermostat',
'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': 'Thermostat',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': 'thermostat',
'unique_id': '00000000000004D2-0000000000000021-MatterNodeDevice-1-MatterThermostat-513-0',
'unit_of_measurement': None,
})
# ---
# name: test_climates[eve_thermo][climate.eve_thermo_thermostat-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_temperature': 21.0,
'friendly_name': 'Eve Thermo Thermostat',
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
]),
'max_temp': 30.0,
'min_temp': 10.0,
'supported_features': <ClimateEntityFeature: 385>,
'temperature': 17.0,
}),
'context': <ANY>,
'entity_id': 'climate.eve_thermo_thermostat',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'heat',
})
# ---
# name: test_climates[room_airconditioner][climate.room_airconditioner_thermostat-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.DRY: 'dry'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
'max_temp': 32.0,
'min_temp': 16.0,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.room_airconditioner_thermostat',
'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': 'Thermostat',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': 'thermostat',
'unique_id': '00000000000004D2-0000000000000024-MatterNodeDevice-1-MatterThermostat-513-0',
'unit_of_measurement': None,
})
# ---
# name: test_climates[room_airconditioner][climate.room_airconditioner_thermostat-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_temperature': 20.0,
'friendly_name': 'Room AirConditioner Thermostat',
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.DRY: 'dry'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
'max_temp': 32.0,
'min_temp': 16.0,
'supported_features': <ClimateEntityFeature: 385>,
'temperature': 20.0,
}),
'context': <ANY>,
'entity_id': 'climate.room_airconditioner_thermostat',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_climates[thermostat][climate.longan_link_hvac_thermostat-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
'max_temp': 35,
'min_temp': 7,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.longan_link_hvac_thermostat',
'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': 'Thermostat',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <ClimateEntityFeature: 387>,
'translation_key': 'thermostat',
'unique_id': '00000000000004D2-0000000000000004-MatterNodeDevice-1-MatterThermostat-513-0',
'unit_of_measurement': None,
})
# ---
# name: test_climates[thermostat][climate.longan_link_hvac_thermostat-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_temperature': 28.3,
'friendly_name': 'Longan link HVAC Thermostat',
'hvac_modes': list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
'max_temp': 35,
'min_temp': 7,
'supported_features': <ClimateEntityFeature: 387>,
'target_temp_high': None,
'target_temp_low': None,
'temperature': None,
}),
'context': <ANY>,
'entity_id': 'climate.longan_link_hvac_thermostat',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'cool',
})
# ---

245
tests/components/matter/snapshots/test_cover.ambr Normal file
View file

@ -0,0 +1,245 @@
# serializer version: 1
# name: test_covers[window_covering_full][cover.mock_full_window_covering_cover-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'cover',
'entity_category': None,
'entity_id': 'cover.mock_full_window_covering_cover',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <CoverDeviceClass.AWNING: 'awning'>,
'original_icon': None,
'original_name': 'Cover',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <CoverEntityFeature: 143>,
'translation_key': 'cover',
'unique_id': '00000000000004D2-0000000000000032-MatterNodeDevice-1-MatterCoverPositionAwareLiftAndTilt-258-10',
'unit_of_measurement': None,
})
# ---
# name: test_covers[window_covering_full][cover.mock_full_window_covering_cover-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_position': 100,
'current_tilt_position': 100,
'device_class': 'awning',
'friendly_name': 'Mock Full Window Covering Cover',
'supported_features': <CoverEntityFeature: 143>,
}),
'context': <ANY>,
'entity_id': 'cover.mock_full_window_covering_cover',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'open',
})
# ---
# name: test_covers[window_covering_lift][cover.mock_lift_window_covering_cover-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'cover',
'entity_category': None,
'entity_id': 'cover.mock_lift_window_covering_cover',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <CoverDeviceClass.AWNING: 'awning'>,
'original_icon': None,
'original_name': 'Cover',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <CoverEntityFeature: 15>,
'translation_key': 'cover',
'unique_id': '00000000000004D2-0000000000000032-MatterNodeDevice-1-MatterCover-258-10',
'unit_of_measurement': None,
})
# ---
# name: test_covers[window_covering_lift][cover.mock_lift_window_covering_cover-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'awning',
'friendly_name': 'Mock Lift Window Covering Cover',
'supported_features': <CoverEntityFeature: 15>,
}),
'context': <ANY>,
'entity_id': 'cover.mock_lift_window_covering_cover',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_covers[window_covering_pa_lift][cover.longan_link_wncv_da01_cover-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'cover',
'entity_category': None,
'entity_id': 'cover.longan_link_wncv_da01_cover',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <CoverDeviceClass.AWNING: 'awning'>,
'original_icon': None,
'original_name': 'Cover',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <CoverEntityFeature: 15>,
'translation_key': 'cover',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterCoverPositionAwareLift-258-10',
'unit_of_measurement': None,
})
# ---
# name: test_covers[window_covering_pa_lift][cover.longan_link_wncv_da01_cover-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_position': 51,
'device_class': 'awning',
'friendly_name': 'Longan link WNCV DA01 Cover',
'supported_features': <CoverEntityFeature: 15>,
}),
'context': <ANY>,
'entity_id': 'cover.longan_link_wncv_da01_cover',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'open',
})
# ---
# name: test_covers[window_covering_pa_tilt][cover.mock_pa_tilt_window_covering_cover-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'cover',
'entity_category': None,
'entity_id': 'cover.mock_pa_tilt_window_covering_cover',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <CoverDeviceClass.AWNING: 'awning'>,
'original_icon': None,
'original_name': 'Cover',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <CoverEntityFeature: 139>,
'translation_key': 'cover',
'unique_id': '00000000000004D2-0000000000000032-MatterNodeDevice-1-MatterCoverPositionAwareTilt-258-10',
'unit_of_measurement': None,
})
# ---
# name: test_covers[window_covering_pa_tilt][cover.mock_pa_tilt_window_covering_cover-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'current_tilt_position': 100,
'device_class': 'awning',
'friendly_name': 'Mock PA Tilt Window Covering Cover',
'supported_features': <CoverEntityFeature: 139>,
}),
'context': <ANY>,
'entity_id': 'cover.mock_pa_tilt_window_covering_cover',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_covers[window_covering_tilt][cover.mock_tilt_window_covering_cover-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'cover',
'entity_category': None,
'entity_id': 'cover.mock_tilt_window_covering_cover',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <CoverDeviceClass.AWNING: 'awning'>,
'original_icon': None,
'original_name': 'Cover',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <CoverEntityFeature: 139>,
'translation_key': 'cover',
'unique_id': '00000000000004D2-0000000000000032-MatterNodeDevice-1-MatterCover-258-10',
'unit_of_measurement': None,
})
# ---
# name: test_covers[window_covering_tilt][cover.mock_tilt_window_covering_cover-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'awning',
'friendly_name': 'Mock Tilt Window Covering Cover',
'supported_features': <CoverEntityFeature: 139>,
}),
'context': <ANY>,
'entity_id': 'cover.mock_tilt_window_covering_cover',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---

385
tests/components/matter/snapshots/test_event.ambr Normal file
View file

@ -0,0 +1,385 @@
# serializer version: 1
# name: test_events[generic_switch][event.mock_generic_switch_button-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'event_types': list([
'initial_press',
'short_release',
'long_press',
'long_release',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'event',
'entity_category': None,
'entity_id': 'event.mock_generic_switch_button',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <EventDeviceClass.BUTTON: 'button'>,
'original_icon': None,
'original_name': 'Button',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'button',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-GenericSwitch-59-1',
'unit_of_measurement': None,
})
# ---
# name: test_events[generic_switch][event.mock_generic_switch_button-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'button',
'event_type': None,
'event_types': list([
'initial_press',
'short_release',
'long_press',
'long_release',
]),
'friendly_name': 'Mock Generic Switch Button',
}),
'context': <ANY>,
'entity_id': 'event.mock_generic_switch_button',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_events[generic_switch_multi][event.mock_generic_switch_button_1-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'event_types': list([
'multi_press_1',
'multi_press_2',
'long_press',
'long_release',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'event',
'entity_category': None,
'entity_id': 'event.mock_generic_switch_button_1',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <EventDeviceClass.BUTTON: 'button'>,
'original_icon': None,
'original_name': 'Button (1)',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'button',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-GenericSwitch-59-1',
'unit_of_measurement': None,
})
# ---
# name: test_events[generic_switch_multi][event.mock_generic_switch_button_1-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'button',
'event_type': None,
'event_types': list([
'multi_press_1',
'multi_press_2',
'long_press',
'long_release',
]),
'friendly_name': 'Mock Generic Switch Button (1)',
}),
'context': <ANY>,
'entity_id': 'event.mock_generic_switch_button_1',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_events[generic_switch_multi][event.mock_generic_switch_fancy_button-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'event_types': list([
'multi_press_1',
'multi_press_2',
'long_press',
'long_release',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'event',
'entity_category': None,
'entity_id': 'event.mock_generic_switch_fancy_button',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <EventDeviceClass.BUTTON: 'button'>,
'original_icon': None,
'original_name': 'Fancy Button',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'button',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-2-GenericSwitch-59-1',
'unit_of_measurement': None,
})
# ---
# name: test_events[generic_switch_multi][event.mock_generic_switch_fancy_button-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'button',
'event_type': None,
'event_types': list([
'multi_press_1',
'multi_press_2',
'long_press',
'long_release',
]),
'friendly_name': 'Mock Generic Switch Fancy Button',
}),
'context': <ANY>,
'entity_id': 'event.mock_generic_switch_fancy_button',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_events[multi_endpoint_light][event.inovelli_config-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'event_types': list([
'multi_press_1',
'multi_press_2',
'multi_press_3',
'multi_press_4',
'multi_press_5',
'long_press',
'long_release',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'event',
'entity_category': None,
'entity_id': 'event.inovelli_config',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <EventDeviceClass.BUTTON: 'button'>,
'original_icon': None,
'original_name': 'Config',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'button',
'unique_id': '00000000000004D2-00000000000000C5-MatterNodeDevice-5-GenericSwitch-59-1',
'unit_of_measurement': None,
})
# ---
# name: test_events[multi_endpoint_light][event.inovelli_config-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'button',
'event_type': None,
'event_types': list([
'multi_press_1',
'multi_press_2',
'multi_press_3',
'multi_press_4',
'multi_press_5',
'long_press',
'long_release',
]),
'friendly_name': 'Inovelli Config',
}),
'context': <ANY>,
'entity_id': 'event.inovelli_config',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_events[multi_endpoint_light][event.inovelli_down-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'event_types': list([
'multi_press_1',
'multi_press_2',
'multi_press_3',
'multi_press_4',
'multi_press_5',
'long_press',
'long_release',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'event',
'entity_category': None,
'entity_id': 'event.inovelli_down',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <EventDeviceClass.BUTTON: 'button'>,
'original_icon': None,
'original_name': 'Down',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'button',
'unique_id': '00000000000004D2-00000000000000C5-MatterNodeDevice-4-GenericSwitch-59-1',
'unit_of_measurement': None,
})
# ---
# name: test_events[multi_endpoint_light][event.inovelli_down-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'button',
'event_type': None,
'event_types': list([
'multi_press_1',
'multi_press_2',
'multi_press_3',
'multi_press_4',
'multi_press_5',
'long_press',
'long_release',
]),
'friendly_name': 'Inovelli Down',
}),
'context': <ANY>,
'entity_id': 'event.inovelli_down',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---
# name: test_events[multi_endpoint_light][event.inovelli_up-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'event_types': list([
'multi_press_1',
'multi_press_2',
'multi_press_3',
'multi_press_4',
'multi_press_5',
'long_press',
'long_release',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'event',
'entity_category': None,
'entity_id': 'event.inovelli_up',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <EventDeviceClass.BUTTON: 'button'>,
'original_icon': None,
'original_name': 'Up',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'button',
'unique_id': '00000000000004D2-00000000000000C5-MatterNodeDevice-3-GenericSwitch-59-1',
'unit_of_measurement': None,
})
# ---
# name: test_events[multi_endpoint_light][event.inovelli_up-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'button',
'event_type': None,
'event_types': list([
'multi_press_1',
'multi_press_2',
'multi_press_3',
'multi_press_4',
'multi_press_5',
'long_press',
'long_release',
]),
'friendly_name': 'Inovelli Up',
}),
'context': <ANY>,
'entity_id': 'event.inovelli_up',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unknown',
})
# ---

263
tests/components/matter/snapshots/test_fan.ambr Normal file
View file

@ -0,0 +1,263 @@
# serializer version: 1
# name: test_fans[air_purifier][fan.air_purifier_fan-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'low',
'medium',
'high',
'auto',
'natural_wind',
'sleep_wind',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.air_purifier_fan',
'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': 'Fan',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <FanEntityFeature: 63>,
'translation_key': 'fan',
'unique_id': '00000000000004D2-000000000000008F-MatterNodeDevice-1-MatterFan-514-0',
'unit_of_measurement': None,
})
# ---
# name: test_fans[air_purifier][fan.air_purifier_fan-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'direction': 'forward',
'friendly_name': 'Air Purifier Fan',
'oscillating': False,
'percentage': None,
'percentage_step': 10.0,
'preset_mode': 'auto',
'preset_modes': list([
'low',
'medium',
'high',
'auto',
'natural_wind',
'sleep_wind',
]),
'supported_features': <FanEntityFeature: 63>,
}),
'context': <ANY>,
'entity_id': 'fan.air_purifier_fan',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_fans[fan][fan.mocked_fan_switch_fan-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'low',
'medium',
'high',
'auto',
'natural_wind',
'sleep_wind',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.mocked_fan_switch_fan',
'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': 'Fan',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <FanEntityFeature: 57>,
'translation_key': 'fan',
'unique_id': '00000000000004D2-000000000000001D-MatterNodeDevice-1-MatterFan-514-0',
'unit_of_measurement': None,
})
# ---
# name: test_fans[fan][fan.mocked_fan_switch_fan-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mocked Fan Switch Fan',
'percentage': 0,
'percentage_step': 33.333333333333336,
'preset_mode': None,
'preset_modes': list([
'low',
'medium',
'high',
'auto',
'natural_wind',
'sleep_wind',
]),
'supported_features': <FanEntityFeature: 57>,
}),
'context': <ANY>,
'entity_id': 'fan.mocked_fan_switch_fan',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_fans[room_airconditioner][fan.room_airconditioner_fan-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'low',
'medium',
'high',
'auto',
'sleep_wind',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.room_airconditioner_fan',
'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': 'Fan',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <FanEntityFeature: 57>,
'translation_key': 'fan',
'unique_id': '00000000000004D2-0000000000000024-MatterNodeDevice-1-MatterFan-514-0',
'unit_of_measurement': None,
})
# ---
# name: test_fans[room_airconditioner][fan.room_airconditioner_fan-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Room AirConditioner Fan',
'percentage': 0,
'percentage_step': 33.333333333333336,
'preset_mode': None,
'preset_modes': list([
'low',
'medium',
'high',
'auto',
'sleep_wind',
]),
'supported_features': <FanEntityFeature: 57>,
}),
'context': <ANY>,
'entity_id': 'fan.room_airconditioner_fan',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_fans[thermostat][fan.longan_link_hvac_fan-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'low',
'medium',
'high',
'auto',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.longan_link_hvac_fan',
'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': 'Fan',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <FanEntityFeature: 56>,
'translation_key': 'fan',
'unique_id': '00000000000004D2-0000000000000004-MatterNodeDevice-1-MatterFan-514-0',
'unit_of_measurement': None,
})
# ---
# name: test_fans[thermostat][fan.longan_link_hvac_fan-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Longan link HVAC Fan',
'preset_mode': None,
'preset_modes': list([
'low',
'medium',
'high',
'auto',
]),
'supported_features': <FanEntityFeature: 56>,
}),
'context': <ANY>,
'entity_id': 'fan.longan_link_hvac_fan',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---

660
tests/components/matter/snapshots/test_light.ambr Normal file
View file

@ -0,0 +1,660 @@
# serializer version: 1
# name: test_lights[color_temperature_light][light.mock_color_temperature_light_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.mock_color_temperature_light_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[color_temperature_light][light.mock_color_temperature_light_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 128,
'color_mode': <ColorMode.COLOR_TEMP: 'color_temp'>,
'color_temp': 284,
'color_temp_kelvin': 3521,
'friendly_name': 'Mock Color Temperature Light Light',
'hs_color': tuple(
27.152,
44.32,
),
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'rgb_color': tuple(
255,
193,
141,
),
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
]),
'supported_features': <LightEntityFeature: 32>,
'xy_color': tuple(
0.453,
0.374,
),
}),
'context': <ANY>,
'entity_id': 'light.mock_color_temperature_light_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[dimmable_light][light.mock_dimmable_light_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.mock_dimmable_light_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[dimmable_light][light.mock_dimmable_light_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 51,
'color_mode': <ColorMode.BRIGHTNESS: 'brightness'>,
'friendly_name': 'Mock Dimmable Light Light',
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
'supported_features': <LightEntityFeature: 32>,
}),
'context': <ANY>,
'entity_id': 'light.mock_dimmable_light_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[dimmable_plugin_unit][light.dimmable_plugin_unit_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.dimmable_plugin_unit_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000024-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[dimmable_plugin_unit][light.dimmable_plugin_unit_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 255,
'color_mode': <ColorMode.BRIGHTNESS: 'brightness'>,
'friendly_name': 'Dimmable Plugin Unit Light',
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
'supported_features': <LightEntityFeature: 32>,
}),
'context': <ANY>,
'entity_id': 'light.dimmable_plugin_unit_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[extended_color_light][light.mock_extended_color_light_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.mock_extended_color_light_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[extended_color_light][light.mock_extended_color_light_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 128,
'color_mode': <ColorMode.HS: 'hs'>,
'color_temp': None,
'color_temp_kelvin': None,
'friendly_name': 'Mock Extended Color Light Light',
'hs_color': tuple(
51.024,
20.079,
),
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'rgb_color': tuple(
255,
247,
203,
),
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
'supported_features': <LightEntityFeature: 32>,
'xy_color': tuple(
0.363,
0.374,
),
}),
'context': <ANY>,
'entity_id': 'light.mock_extended_color_light_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[multi_endpoint_light][light.inovelli_light_1-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.inovelli_light_1',
'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': 'Light (1)',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-00000000000000C5-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[multi_endpoint_light][light.inovelli_light_1-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': None,
'color_mode': None,
'friendly_name': 'Inovelli Light (1)',
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
'supported_features': <LightEntityFeature: 32>,
}),
'context': <ANY>,
'entity_id': 'light.inovelli_light_1',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_lights[multi_endpoint_light][light.inovelli_light_6-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.inovelli_light_6',
'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': 'Light (6)',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-00000000000000C5-MatterNodeDevice-6-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[multi_endpoint_light][light.inovelli_light_6-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': None,
'color_mode': None,
'color_temp': None,
'color_temp_kelvin': None,
'friendly_name': 'Inovelli Light (6)',
'hs_color': None,
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'rgb_color': None,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
'supported_features': <LightEntityFeature: 32>,
'xy_color': None,
}),
'context': <ANY>,
'entity_id': 'light.inovelli_light_6',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_lights[onoff_light][light.mock_onoff_light_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.ONOFF: 'onoff'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.mock_onoff_light_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[onoff_light][light.mock_onoff_light_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'color_mode': <ColorMode.ONOFF: 'onoff'>,
'friendly_name': 'Mock OnOff Light Light',
'supported_color_modes': list([
<ColorMode.ONOFF: 'onoff'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.mock_onoff_light_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[onoff_light_alt_name][light.mock_onoff_light_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.mock_onoff_light_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[onoff_light_alt_name][light.mock_onoff_light_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': None,
'color_mode': <ColorMode.COLOR_TEMP: 'color_temp'>,
'color_temp': None,
'color_temp_kelvin': None,
'friendly_name': 'Mock OnOff Light Light',
'hs_color': None,
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'rgb_color': None,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
'supported_features': <LightEntityFeature: 32>,
'xy_color': None,
}),
'context': <ANY>,
'entity_id': 'light.mock_onoff_light_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[onoff_light_no_name][light.mock_light_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.mock_light_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LightEntityFeature: 32>,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[onoff_light_no_name][light.mock_light_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': None,
'color_mode': <ColorMode.COLOR_TEMP: 'color_temp'>,
'color_temp': None,
'color_temp_kelvin': None,
'friendly_name': 'Mock Light Light',
'hs_color': None,
'max_color_temp_kelvin': 6535,
'max_mireds': 500,
'min_color_temp_kelvin': 2000,
'min_mireds': 153,
'rgb_color': None,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
<ColorMode.HS: 'hs'>,
<ColorMode.XY: 'xy'>,
]),
'supported_features': <LightEntityFeature: 32>,
'xy_color': None,
}),
'context': <ANY>,
'entity_id': 'light.mock_light_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_lights[onoff_light_with_levelcontrol_present][light.d215s_light-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'supported_color_modes': list([
<ColorMode.ONOFF: 'onoff'>,
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'light',
'entity_category': None,
'entity_id': 'light.d215s_light',
'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': 'Light',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'light',
'unique_id': '00000000000004D2-0000000000000008-MatterNodeDevice-1-MatterLight-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_lights[onoff_light_with_levelcontrol_present][light.d215s_light-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'color_mode': None,
'friendly_name': 'D215S Light',
'supported_color_modes': list([
<ColorMode.ONOFF: 'onoff'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.d215s_light',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---

95
tests/components/matter/snapshots/test_lock.ambr Normal file
View file

@ -0,0 +1,95 @@
# serializer version: 1
# name: test_locks[door_lock][lock.mock_door_lock_lock-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'lock',
'entity_category': None,
'entity_id': 'lock.mock_door_lock_lock',
'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': 'Lock',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'lock',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLock-257-0',
'unit_of_measurement': None,
})
# ---
# name: test_locks[door_lock][lock.mock_door_lock_lock-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Door Lock Lock',
'supported_features': <LockEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'lock.mock_door_lock_lock',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'unlocked',
})
# ---
# name: test_locks[door_lock_with_unbolt][lock.mock_door_lock_lock-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'lock',
'entity_category': None,
'entity_id': 'lock.mock_door_lock_lock',
'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': 'Lock',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <LockEntityFeature: 1>,
'translation_key': 'lock',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterLock-257-0',
'unit_of_measurement': None,
})
# ---
# name: test_locks[door_lock_with_unbolt][lock.mock_door_lock_lock-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Mock Door Lock Lock',
'supported_features': <LockEntityFeature: 1>,
}),
'context': <ANY>,
'entity_id': 'lock.mock_door_lock_lock',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'locked',
})
# ---

1560
tests/components/matter/snapshots/test_number.ambr Normal file
View file

File diff suppressed because it is too large Load diff

1575
tests/components/matter/snapshots/test_select.ambr Normal file
View file

File diff suppressed because it is too large Load diff

377
tests/components/matter/snapshots/test_switch.ambr Normal file
View file

@ -0,0 +1,377 @@
# serializer version: 1
# name: test_switches[door_lock][switch.mock_door_lock_switch-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': None,
'entity_id': 'switch.mock_door_lock_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterSwitch-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[door_lock][switch.mock_door_lock_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Mock Door Lock Switch',
}),
'context': <ANY>,
'entity_id': 'switch.mock_door_lock_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[door_lock_with_unbolt][switch.mock_door_lock_switch-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': None,
'entity_id': 'switch.mock_door_lock_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterSwitch-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[door_lock_with_unbolt][switch.mock_door_lock_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Mock Door Lock Switch',
}),
'context': <ANY>,
'entity_id': 'switch.mock_door_lock_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[eve_energy_plug][switch.eve_energy_plug_switch-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': None,
'entity_id': 'switch.eve_energy_plug_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-0000000000000053-MatterNodeDevice-1-MatterPlug-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[eve_energy_plug][switch.eve_energy_plug_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Eve Energy Plug Switch',
}),
'context': <ANY>,
'entity_id': 'switch.eve_energy_plug_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[eve_energy_plug_patched][switch.eve_energy_plug_patched_switch-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': None,
'entity_id': 'switch.eve_energy_plug_patched_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-00000000000000B7-MatterNodeDevice-1-MatterPlug-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[eve_energy_plug_patched][switch.eve_energy_plug_patched_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Eve Energy Plug Patched Switch',
}),
'context': <ANY>,
'entity_id': 'switch.eve_energy_plug_patched_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[on_off_plugin_unit][switch.mock_onoffpluginunit_switch-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': None,
'entity_id': 'switch.mock_onoffpluginunit_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterPlug-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[on_off_plugin_unit][switch.mock_onoffpluginunit_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Mock OnOffPluginUnit Switch',
}),
'context': <ANY>,
'entity_id': 'switch.mock_onoffpluginunit_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[room_airconditioner][switch.room_airconditioner_power-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': None,
'entity_id': 'switch.room_airconditioner_power',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.SWITCH: 'switch'>,
'original_icon': None,
'original_name': 'Power',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'power',
'unique_id': '00000000000004D2-0000000000000024-MatterNodeDevice-1-MatterPowerToggle-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[room_airconditioner][switch.room_airconditioner_power-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'switch',
'friendly_name': 'Room AirConditioner Power',
}),
'context': <ANY>,
'entity_id': 'switch.room_airconditioner_power',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[switch_unit][switch.mock_switchunit_switch-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': None,
'entity_id': 'switch.mock_switchunit_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-0000000000000001-MatterNodeDevice-1-MatterSwitch-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[switch_unit][switch.mock_switchunit_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Mock SwitchUnit Switch',
}),
'context': <ANY>,
'entity_id': 'switch.mock_switchunit_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_switches[thermostat][switch.longan_link_hvac_switch-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': None,
'entity_id': 'switch.longan_link_hvac_switch',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SwitchDeviceClass.OUTLET: 'outlet'>,
'original_icon': None,
'original_name': 'Switch',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'switch',
'unique_id': '00000000000004D2-0000000000000004-MatterNodeDevice-1-MatterSwitch-6-0',
'unit_of_measurement': None,
})
# ---
# name: test_switches[thermostat][switch.longan_link_hvac_switch-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'outlet',
'friendly_name': 'Longan link HVAC Switch',
}),
'context': <ANY>,
'entity_id': 'switch.longan_link_hvac_switch',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

49
tests/components/matter/snapshots/test_valve.ambr Normal file
View file

@ -0,0 +1,49 @@
# serializer version: 1
# name: test_valves[valve][valve.valve_valve-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'valve',
'entity_category': None,
'entity_id': 'valve.valve_valve',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <ValveDeviceClass.WATER: 'water'>,
'original_icon': None,
'original_name': 'Valve',
'platform': 'matter',
'previous_unique_id': None,
'supported_features': <ValveEntityFeature: 3>,
'translation_key': 'valve',
'unique_id': '00000000000004D2-000000000000004B-MatterNodeDevice-1-MatterValve-129-4',
'unit_of_measurement': None,
})
# ---
# name: test_valves[valve][valve.valve_valve-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'water',
'friendly_name': 'Valve Valve',
'supported_features': <ValveEntityFeature: 3>,
}),
'context': <ANY>,
'entity_id': 'valve.valve_valve',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'closed',
})
# ---

15
tests/components/matter/test_button.py
View file

@ -5,8 +5,23 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
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 .common import snapshot_matter_entities
@pytest.mark.usefixtures("matter_devices")
async def test_buttons(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test buttons."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.BUTTON)
@pytest.mark.parametrize("node_fixture", ["eve_energy_plug"])

19
tests/components/matter/test_climate.py
View file

@ -6,11 +6,28 @@ from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
from matter_server.common.helpers.util import create_attribute_path_from_attribute
import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.climate import ClimateEntityFeature, HVACAction, HVACMode
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_climates(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test climates."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.CLIMATE)
@pytest.mark.parametrize("node_fixture", ["thermostat"])

19
tests/components/matter/test_cover.py
View file

@ -6,6 +6,7 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.cover import (
STATE_CLOSED,
@ -14,9 +15,25 @@ from homeassistant.components.cover import (
STATE_OPENING,
CoverEntityFeature,
)
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_covers(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test covers."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.COVER)
@pytest.mark.parametrize(

15
tests/components/matter/test_event.py
View file

@ -5,11 +5,24 @@ from unittest.mock import MagicMock
from matter_server.client.models.node import MatterNode
from matter_server.common.models import EventType, MatterNodeEvent
import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.event import ATTR_EVENT_TYPE, ATTR_EVENT_TYPES
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .common import trigger_subscription_callback
from .common import snapshot_matter_entities, trigger_subscription_callback
@pytest.mark.usefixtures("matter_devices")
async def test_events(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test events."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.EVENT)
@pytest.mark.parametrize("node_fixture", ["generic_switch"])

25
tests/components/matter/test_fan.py
View file

@ -4,6 +4,7 @@ from unittest.mock import MagicMock, call
from matter_server.client.models.node import MatterNode
import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.fan import (
ATTR_DIRECTION,
@ -17,10 +18,30 @@ from homeassistant.components.fan import (
SERVICE_SET_DIRECTION,
FanEntityFeature,
)
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
Platform,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_fans(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test fans."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.FAN)
@pytest.mark.parametrize("node_fixture", ["air_purifier"])

19
tests/components/matter/test_light.py
View file

@ -5,11 +5,28 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.light import ColorMode
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_lights(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test lights."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.LIGHT)
@pytest.mark.parametrize(

19
tests/components/matter/test_lock.py
View file

@ -5,14 +5,29 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
import pytest
from syrupy import SnapshotAssertion
from homeassistant.components.lock import LockEntityFeature, LockState
from homeassistant.const import ATTR_CODE, STATE_UNKNOWN
from homeassistant.const import ATTR_CODE, STATE_UNKNOWN, Platform
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError
import homeassistant.helpers.entity_registry as er
from .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_locks(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test locks."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.LOCK)
@pytest.mark.parametrize("node_fixture", ["door_lock"])

19
tests/components/matter/test_number.py
View file

@ -6,10 +6,27 @@ from matter_server.client.models.node import MatterNode
from matter_server.common import custom_clusters
from matter_server.common.helpers.util import create_attribute_path_from_attribute
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 .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_numbers(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test numbers."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.NUMBER)
@pytest.mark.parametrize("node_fixture", ["dimmable_light"])

19
tests/components/matter/test_select.py
View file

@ -5,10 +5,27 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
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 .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_selects(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test selects."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.SELECT)
@pytest.mark.parametrize("node_fixture", ["dimmable_light"])

19
tests/components/matter/test_switch.py
View file

@ -5,10 +5,27 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
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 .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_switches(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test switches."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.SWITCH)
@pytest.mark.parametrize("node_fixture", ["on_off_plugin_unit"])

19
tests/components/matter/test_valve.py
View file

@ -5,10 +5,27 @@ from unittest.mock import MagicMock, call
from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode
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 .common import set_node_attribute, trigger_subscription_callback
from .common import (
set_node_attribute,
snapshot_matter_entities,
trigger_subscription_callback,
)
@pytest.mark.usefixtures("matter_devices")
async def test_valves(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test valves."""
snapshot_matter_entities(hass, entity_registry, snapshot, Platform.VALVE)
@pytest.mark.parametrize("node_fixture", ["valve"])