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

Add platform state tests for vesync integration (#90466)

Browse source 
* Test coverage for init and common

* Update snapshot

* break setup state snapshot test across platforms

* Fix state snapshot test methods

* Remove the test_init snapshot

* Remove test_common and test_init changes

* refactor the request_mock fixture
This commit is contained in:
Chuck Deal 2023-04-12 08:15:22 -04:00 • committed by GitHub
parent e8fb7b8cf1
commit a4a8f6ebc8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 2809 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.coveragerc
View file

@ -1383,7 +1383,6 @@ omit =
homeassistant/components/verisure/sensor.py
homeassistant/components/verisure/switch.py
homeassistant/components/versasense/*
homeassistant/components/vesync/common.py
homeassistant/components/vesync/fan.py
homeassistant/components/vesync/light.py
homeassistant/components/vesync/sensor.py

67
tests/components/vesync/common.py
View file

@ -1,7 +1,72 @@
"""Common methods used across tests for VeSync."""
import json
from tests.common import load_fixture
import requests_mock
from homeassistant.components.vesync.const import DOMAIN
from tests.common import load_fixture, load_json_object_fixture
ALL_DEVICES = load_json_object_fixture("vesync-devices.json", DOMAIN)
ALL_DEVICE_NAMES: list[str] = [
dev["deviceName"] for dev in ALL_DEVICES["result"]["list"]
]
DEVICE_FIXTURES: dict[str, list[tuple[str, str, str]]] = {
"Humidifier 200s": [
("post", "/cloud/v2/deviceManaged/bypassV2", "device-detail.json")
],
"Humidifier 600S": [
("post", "/cloud/v2/deviceManaged/bypassV2", "device-detail.json")
],
"Air Purifier 131s": [
("post", "/131airPurifier/v1/device/deviceDetail", "purifier-detail.json")
],
"Air Purifier 200s": [
("post", "/cloud/v2/deviceManaged/bypassV2", "device-detail.json")
],
"Air Purifier 400s": [
("post", "/cloud/v2/deviceManaged/bypassV2", "device-detail.json")
],
"Air Purifier 600s": [
("post", "/cloud/v2/deviceManaged/bypassV2", "device-detail.json")
],
"Dimmable Light": [
("post", "/SmartBulb/v1/device/devicedetail", "device-detail.json")
],
"Temperature Light": [
("post", "/cloud/v1/deviceManaged/bypass", "device-detail.json")
],
"Outlet": [("get", "/v1/device/outlet/detail", "outlet-detail.json")],
"Wall Switch": [
("post", "/inwallswitch/v1/device/devicedetail", "device-detail.json")
],
"Dimmer Switch": [("post", "/dimmer/v1/device/devicedetail", "dimmer-detail.json")],
}
def mock_devices_response(
requests_mock: requests_mock.Mocker, device_name: str
) -> None:
"""Build a response for the Helpers.call_api method."""
device_list = []
for device in ALL_DEVICES["result"]["list"]:
if device["deviceName"] == device_name:
device_list.append(device)
requests_mock.post(
"https://smartapi.vesync.com/cloud/v1/deviceManaged/devices",
json={"code": 0, "result": {"list": device_list}},
)
requests_mock.post(
"https://smartapi.vesync.com/cloud/v1/user/login",
json=load_json_object_fixture("vesync-login.json", DOMAIN),
)
for fixture in DEVICE_FIXTURES[device_name]:
requests_mock.request(
fixture[0],
f"https://smartapi.vesync.com{fixture[1]}",
json=load_json_object_fixture(fixture[2], DOMAIN),
)
def call_api_side_effect__no_devices(*args, **kwargs):

42
tests/components/vesync/fixtures/device-detail.json Normal file
View file

@ -0,0 +1,42 @@
{
"code": 0,
"brightNess": "50",
"result": {
"light": {
"brightness": 50,
"colorTempe": 5400
},
"result": {
"brightness": 50,
"red": 178.5,
"green": 255,
"blue": 25.5,
"colorMode": "rgb",
"humidity": 35,
"mist_virtual_level": 6,
"mode": "manual",
"water_lacks": true,
"water_tank_lifted": true,
"automatic_stop_reach_target": true,
"night_light_brightness": 10,
"enabled": true,
"filter_life": 99,
"level": 1,
"display": true,
"display_forever": false,
"child_lock": false,
"night_light": "off",
"air_quality": 5,
"air_quality_value": 1,
"configuration": {
"auto_target_humidity": 40,
"display": true,
"automatic_stop": true
}
},
"code": 0
}
}

8
tests/components/vesync/fixtures/dimmer-detail.json Normal file
View file

@ -0,0 +1,8 @@
{
"code": 0,
"deviceStatus": "on",
"activeTime": 100,
"brightness": 50,
"rgbStatus": "on",
"indicatorlightStatus": "on"
}

7
tests/components/vesync/fixtures/outlet-detail.json Normal file
View file

@ -0,0 +1,7 @@
{
"deviceStatus": "on",
"activeTime": 10,
"energy": 100,
"power": 25,
"voltage": 120
}

10
tests/components/vesync/fixtures/purifier-detail.json Normal file
View file

@ -0,0 +1,10 @@
{
"code": 0,
"deviceStatus": "on",
"activeTime": 50,
"filterLife": 90,
"screenStatus": "on",
"mode": "auto",
"level": 2,
"airQuality": 95
}

104
tests/components/vesync/fixtures/vesync-devices.json Normal file
View file

@ -0,0 +1,104 @@
{
"code": 0,
"result": {
"list": [
{
"cid": "200s-humidifier",
"deviceType": "Classic200S",
"deviceName": "Humidifier 200s",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online",
"uuid": "00000000-1111-2222-3333-444444444444"
},
{
"cid": "600s-humidifier",
"deviceType": "LUH-A602S-WUS",
"deviceName": "Humidifier 600S",
"subDeviceNo": null,
"deviceStatus": "off",
"connectionStatus": "online",
"uuid": "00000000-1111-2222-3333-555555555555",
"deviceImg": "https://image.vesync.com/defaultImages/LV_600S_Series/icon_lv600s_humidifier_160.png",
"configModule": "WFON_AHM_LUH-A602S-WUS_US",
"currentFirmVersion": null,
"subDeviceType": null
},
{
"cid": "air-purifier",
"deviceType": "LV-PUR131S",
"deviceName": "Air Purifier 131s",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online"
},
{
"cid": "asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55",
"deviceType": "Core200S",
"deviceName": "Air Purifier 200s",
"subDeviceNo": null,
"deviceStatus": "on",
"type": "wifi-air",
"connectionStatus": "online"
},
{
"cid": "400s-purifier",
"deviceType": "LAP-C401S-WJP",
"deviceName": "Air Purifier 400s",
"subDeviceNo": null,
"deviceStatus": "on",
"type": "wifi-air",
"connectionStatus": "online"
},
{
"cid": "600s-purifier",
"deviceType": "LAP-C601S-WUS",
"deviceName": "Air Purifier 600s",
"subDeviceNo": null,
"type": "wifi-air",
"deviceStatus": "on",
"connectionStatus": "online"
},
{
"cid": "dimmable-bulb",
"deviceType": "ESL100",
"deviceName": "Dimmable Light",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online"
},
{
"cid": "tunable-bulb",
"deviceType": "ESL100CW",
"deviceName": "Temperature Light",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online"
},
{
"cid": "outlet",
"deviceType": "wifi-switch-1.3",
"deviceName": "Outlet",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online"
},
{
"cid": "switch",
"deviceType": "ESWL01",
"deviceName": "Wall Switch",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online"
},
{
"cid": "dimmable-switch",
"deviceType": "ESWD16",
"deviceName": "Dimmer Switch",
"subDeviceNo": null,
"deviceStatus": "on",
"connectionStatus": "online"
}
]
}
}

7
tests/components/vesync/fixtures/vesync-login.json Normal file
View file

@ -0,0 +1,7 @@
{
"code": 0,
"result": {
"token": "test-token",
"accountID": "1234"
}
}

533
tests/components/vesync/snapshots/test_fan.ambr Normal file
View file

@ -0,0 +1,533 @@
# serializer version: 1
# name: test_fan_state[Air Purifier 131s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'air-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LV-PUR131S',
'name': 'Air Purifier 131s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 131s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'auto',
'sleep',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.air_purifier_131s',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 131s',
'platform': 'vesync',
'supported_features': <FanEntityFeature: 1>,
'translation_key': None,
'unique_id': 'air-purifier',
'unit_of_measurement': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 131s][fan.air_purifier_131s]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 131s',
'preset_modes': list([
'auto',
'sleep',
]),
'supported_features': <FanEntityFeature: 1>,
}),
'context': <ANY>,
'entity_id': 'fan.air_purifier_131s',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'unavailable',
})
# ---
# name: test_fan_state[Air Purifier 200s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'Core200S',
'name': 'Air Purifier 200s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 200s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'sleep',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.air_purifier_200s',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 200s',
'platform': 'vesync',
'supported_features': <FanEntityFeature: 1>,
'translation_key': None,
'unique_id': 'asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55',
'unit_of_measurement': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 200s][fan.air_purifier_200s]
StateSnapshot({
'attributes': ReadOnlyDict({
'child_lock': False,
'friendly_name': 'Air Purifier 200s',
'mode': 'manual',
'night_light': 'off',
'percentage': 33,
'percentage_step': 33.333333333333336,
'preset_mode': None,
'preset_modes': list([
'sleep',
]),
'screen_status': True,
'supported_features': <FanEntityFeature: 1>,
}),
'context': <ANY>,
'entity_id': 'fan.air_purifier_200s',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_fan_state[Air Purifier 400s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'400s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C401S-WJP',
'name': 'Air Purifier 400s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 400s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'auto',
'sleep',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.air_purifier_400s',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 400s',
'platform': 'vesync',
'supported_features': <FanEntityFeature: 1>,
'translation_key': None,
'unique_id': '400s-purifier',
'unit_of_measurement': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 400s][fan.air_purifier_400s]
StateSnapshot({
'attributes': ReadOnlyDict({
'child_lock': False,
'friendly_name': 'Air Purifier 400s',
'mode': 'manual',
'night_light': 'off',
'percentage': 25,
'percentage_step': 25.0,
'preset_mode': None,
'preset_modes': list([
'auto',
'sleep',
]),
'screen_status': True,
'supported_features': <FanEntityFeature: 1>,
}),
'context': <ANY>,
'entity_id': 'fan.air_purifier_400s',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_fan_state[Air Purifier 600s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'600s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C601S-WUS',
'name': 'Air Purifier 600s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 600s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'preset_modes': list([
'auto',
'sleep',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'fan',
'entity_category': None,
'entity_id': 'fan.air_purifier_600s',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 600s',
'platform': 'vesync',
'supported_features': <FanEntityFeature: 1>,
'translation_key': None,
'unique_id': '600s-purifier',
'unit_of_measurement': None,
}),
])
# ---
# name: test_fan_state[Air Purifier 600s][fan.air_purifier_600s]
StateSnapshot({
'attributes': ReadOnlyDict({
'child_lock': False,
'friendly_name': 'Air Purifier 600s',
'mode': 'manual',
'night_light': 'off',
'percentage': 25,
'percentage_step': 25.0,
'preset_mode': None,
'preset_modes': list([
'auto',
'sleep',
]),
'screen_status': True,
'supported_features': <FanEntityFeature: 1>,
}),
'context': <ANY>,
'entity_id': 'fan.air_purifier_600s',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_fan_state[Dimmable Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100',
'name': 'Dimmable Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Dimmable Light][entities]
list([
])
# ---
# name: test_fan_state[Dimmer Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWD16',
'name': 'Dimmer Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Dimmer Switch][entities]
list([
])
# ---
# name: test_fan_state[Humidifier 200s][devices]
list([
])
# ---
# name: test_fan_state[Humidifier 200s][entities]
list([
])
# ---
# name: test_fan_state[Humidifier 600S][devices]
list([
])
# ---
# name: test_fan_state[Humidifier 600S][entities]
list([
])
# ---
# name: test_fan_state[Outlet][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'outlet',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'wifi-switch-1.3',
'name': 'Outlet',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Outlet][entities]
list([
])
# ---
# name: test_fan_state[Temperature Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'tunable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100CW',
'name': 'Temperature Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Temperature Light][entities]
list([
])
# ---
# name: test_fan_state[Wall Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWL01',
'name': 'Wall Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_fan_state[Wall Switch][entities]
list([
])
# ---

468
tests/components/vesync/snapshots/test_light.ambr Normal file
View file

@ -0,0 +1,468 @@
# serializer version: 1
# name: test_light_state[Air Purifier 131s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'air-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LV-PUR131S',
'name': 'Air Purifier 131s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Air Purifier 131s][entities]
list([
])
# ---
# name: test_light_state[Air Purifier 200s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'Core200S',
'name': 'Air Purifier 200s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Air Purifier 200s][entities]
list([
])
# ---
# name: test_light_state[Air Purifier 400s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'400s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C401S-WJP',
'name': 'Air Purifier 400s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Air Purifier 400s][entities]
list([
])
# ---
# name: test_light_state[Air Purifier 600s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'600s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C601S-WUS',
'name': 'Air Purifier 600s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Air Purifier 600s][entities]
list([
])
# ---
# name: test_light_state[Dimmable Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100',
'name': 'Dimmable Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Dimmable Light][entities]
list([
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_light',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Dimmable Light',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'dimmable-bulb',
'unit_of_measurement': None,
}),
])
# ---
# name: test_light_state[Dimmable Light][light.dimmable_light]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Dimmable Light',
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.dimmable_light',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'unavailable',
})
# ---
# name: test_light_state[Dimmer Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWD16',
'name': 'Dimmer Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Dimmer Switch][entities]
list([
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.dimmer_switch',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Dimmer Switch',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'dimmable-switch',
'unit_of_measurement': None,
}),
])
# ---
# name: test_light_state[Dimmer Switch][light.dimmer_switch]
StateSnapshot({
'attributes': ReadOnlyDict({
'brightness': 128,
'color_mode': <ColorMode.BRIGHTNESS: 'brightness'>,
'friendly_name': 'Dimmer Switch',
'supported_color_modes': list([
<ColorMode.BRIGHTNESS: 'brightness'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.dimmer_switch',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_light_state[Humidifier 200s][devices]
list([
])
# ---
# name: test_light_state[Humidifier 200s][entities]
list([
])
# ---
# name: test_light_state[Humidifier 600S][devices]
list([
])
# ---
# name: test_light_state[Humidifier 600S][entities]
list([
])
# ---
# name: test_light_state[Outlet][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'outlet',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'wifi-switch-1.3',
'name': 'Outlet',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Outlet][entities]
list([
])
# ---
# name: test_light_state[Temperature Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'tunable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100CW',
'name': 'Temperature Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Temperature Light][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'max_color_temp_kelvin': 6493,
'max_mireds': 370,
'min_color_temp_kelvin': 2702,
'min_mireds': 154,
'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.temperature_light',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Temperature Light',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'tunable-bulb',
'unit_of_measurement': None,
}),
])
# ---
# name: test_light_state[Temperature Light][light.temperature_light]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Temperature Light',
'max_color_temp_kelvin': 6493,
'max_mireds': 370,
'min_color_temp_kelvin': 2702,
'min_mireds': 154,
'supported_color_modes': list([
<ColorMode.COLOR_TEMP: 'color_temp'>,
]),
'supported_features': <LightEntityFeature: 0>,
}),
'context': <ANY>,
'entity_id': 'light.temperature_light',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_light_state[Wall Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWL01',
'name': 'Wall Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_light_state[Wall Switch][entities]
list([
])
# ---

970
tests/components/vesync/snapshots/test_sensor.ambr Normal file
View file

@ -0,0 +1,970 @@
# serializer version: 1
# name: test_sensor_state[Air Purifier 131s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'air-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LV-PUR131S',
'name': 'Air Purifier 131s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Air Purifier 131s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.air_purifier_131s_filter_life',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 131s Filter Life',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'air-purifier-filter-life',
'unit_of_measurement': '%',
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.air_purifier_131s_air_quality',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 131s Air Quality',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'air-purifier-air-quality',
'unit_of_measurement': None,
}),
])
# ---
# name: test_sensor_state[Air Purifier 131s][sensor.air_purifier_131s_air_quality]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 131s Air Quality',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_131s_air_quality',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'unavailable',
})
# ---
# name: test_sensor_state[Air Purifier 131s][sensor.air_purifier_131s_filter_life]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 131s Filter Life',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_131s_filter_life',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'unavailable',
})
# ---
# name: test_sensor_state[Air Purifier 200s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'Core200S',
'name': 'Air Purifier 200s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Air Purifier 200s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.air_purifier_200s_filter_life',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 200s Filter Life',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55-filter-life',
'unit_of_measurement': '%',
}),
])
# ---
# name: test_sensor_state[Air Purifier 200s][sensor.air_purifier_200s_filter_life]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 200s Filter Life',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_200s_filter_life',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '99',
})
# ---
# name: test_sensor_state[Air Purifier 400s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'400s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C401S-WJP',
'name': 'Air Purifier 400s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Air Purifier 400s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.air_purifier_400s_filter_life',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 400s Filter Life',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': '400s-purifier-filter-life',
'unit_of_measurement': '%',
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.air_purifier_400s_air_quality',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 400s Air Quality',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': '400s-purifier-air-quality',
'unit_of_measurement': None,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.air_purifier_400s_pm2_5',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.PM25: 'pm25'>,
'original_icon': None,
'original_name': 'Air Purifier 400s PM2.5',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': '400s-purifier-pm25',
'unit_of_measurement': 'µg/m³',
}),
])
# ---
# name: test_sensor_state[Air Purifier 400s][sensor.air_purifier_400s_air_quality]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 400s Air Quality',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_400s_air_quality',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '5',
})
# ---
# name: test_sensor_state[Air Purifier 400s][sensor.air_purifier_400s_filter_life]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 400s Filter Life',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_400s_filter_life',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '99',
})
# ---
# name: test_sensor_state[Air Purifier 400s][sensor.air_purifier_400s_pm2_5]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'pm25',
'friendly_name': 'Air Purifier 400s PM2.5',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_400s_pm2_5',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '1',
})
# ---
# name: test_sensor_state[Air Purifier 600s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'600s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C601S-WUS',
'name': 'Air Purifier 600s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Air Purifier 600s][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
'entity_id': 'sensor.air_purifier_600s_filter_life',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 600s Filter Life',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': '600s-purifier-filter-life',
'unit_of_measurement': '%',
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.air_purifier_600s_air_quality',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Air Purifier 600s Air Quality',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': '600s-purifier-air-quality',
'unit_of_measurement': None,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.air_purifier_600s_pm2_5',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.PM25: 'pm25'>,
'original_icon': None,
'original_name': 'Air Purifier 600s PM2.5',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': '600s-purifier-pm25',
'unit_of_measurement': 'µg/m³',
}),
])
# ---
# name: test_sensor_state[Air Purifier 600s][sensor.air_purifier_600s_air_quality]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 600s Air Quality',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_600s_air_quality',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '5',
})
# ---
# name: test_sensor_state[Air Purifier 600s][sensor.air_purifier_600s_filter_life]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Air Purifier 600s Filter Life',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': '%',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_600s_filter_life',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '99',
})
# ---
# name: test_sensor_state[Air Purifier 600s][sensor.air_purifier_600s_pm2_5]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'pm25',
'friendly_name': 'Air Purifier 600s PM2.5',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.air_purifier_600s_pm2_5',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '1',
})
# ---
# name: test_sensor_state[Dimmable Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100',
'name': 'Dimmable Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Dimmable Light][entities]
list([
])
# ---
# name: test_sensor_state[Dimmer Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWD16',
'name': 'Dimmer Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Dimmer Switch][entities]
list([
])
# ---
# name: test_sensor_state[Humidifier 200s][devices]
list([
])
# ---
# name: test_sensor_state[Humidifier 200s][entities]
list([
])
# ---
# name: test_sensor_state[Humidifier 600S][devices]
list([
])
# ---
# name: test_sensor_state[Humidifier 600S][entities]
list([
])
# ---
# name: test_sensor_state[Outlet][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'outlet',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'wifi-switch-1.3',
'name': 'Outlet',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Outlet][entities]
list([
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.outlet_current_power',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
'original_name': 'Outlet current power',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet-power',
'unit_of_measurement': <UnitOfPower.WATT: 'W'>,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.outlet_energy_use_today',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
'original_name': 'Outlet energy use today',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet-energy',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.outlet_energy_use_weekly',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
'original_name': 'Outlet energy use weekly',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet-energy-weekly',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.outlet_energy_use_monthly',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
'original_name': 'Outlet energy use monthly',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet-energy-monthly',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.outlet_energy_use_yearly',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
'original_name': 'Outlet energy use yearly',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet-energy-yearly',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.outlet_current_voltage',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
'original_name': 'Outlet current voltage',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet-voltage',
'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
])
# ---
# name: test_sensor_state[Outlet][sensor.outlet_current_power]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'power',
'friendly_name': 'Outlet current power',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfPower.WATT: 'W'>,
}),
'context': <ANY>,
'entity_id': 'sensor.outlet_current_power',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '25.0',
})
# ---
# name: test_sensor_state[Outlet][sensor.outlet_current_voltage]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'voltage',
'friendly_name': 'Outlet current voltage',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
'context': <ANY>,
'entity_id': 'sensor.outlet_current_voltage',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '120.0',
})
# ---
# name: test_sensor_state[Outlet][sensor.outlet_energy_use_monthly]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'energy',
'friendly_name': 'Outlet energy use monthly',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
'context': <ANY>,
'entity_id': 'sensor.outlet_energy_use_monthly',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '0',
})
# ---
# name: test_sensor_state[Outlet][sensor.outlet_energy_use_today]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'energy',
'friendly_name': 'Outlet energy use today',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
'context': <ANY>,
'entity_id': 'sensor.outlet_energy_use_today',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '100',
})
# ---
# name: test_sensor_state[Outlet][sensor.outlet_energy_use_weekly]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'energy',
'friendly_name': 'Outlet energy use weekly',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
'context': <ANY>,
'entity_id': 'sensor.outlet_energy_use_weekly',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '0',
})
# ---
# name: test_sensor_state[Outlet][sensor.outlet_energy_use_yearly]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'energy',
'friendly_name': 'Outlet energy use yearly',
'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
'context': <ANY>,
'entity_id': 'sensor.outlet_energy_use_yearly',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': '0',
})
# ---
# name: test_sensor_state[Temperature Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'tunable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100CW',
'name': 'Temperature Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Temperature Light][entities]
list([
])
# ---
# name: test_sensor_state[Wall Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWL01',
'name': 'Wall Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_sensor_state[Wall Switch][entities]
list([
])
# ---

394
tests/components/vesync/snapshots/test_switch.ambr Normal file
View file

@ -0,0 +1,394 @@
# serializer version: 1
# name: test_switch_state[Air Purifier 131s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'air-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LV-PUR131S',
'name': 'Air Purifier 131s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Air Purifier 131s][entities]
list([
])
# ---
# name: test_switch_state[Air Purifier 200s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'asd_sdfKIHG7IJHGwJGJ7GJ_ag5h3G55',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'Core200S',
'name': 'Air Purifier 200s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Air Purifier 200s][entities]
list([
])
# ---
# name: test_switch_state[Air Purifier 400s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'400s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C401S-WJP',
'name': 'Air Purifier 400s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Air Purifier 400s][entities]
list([
])
# ---
# name: test_switch_state[Air Purifier 600s][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'600s-purifier',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'LAP-C601S-WUS',
'name': 'Air Purifier 600s',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Air Purifier 600s][entities]
list([
])
# ---
# name: test_switch_state[Dimmable Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100',
'name': 'Dimmable Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Dimmable Light][entities]
list([
])
# ---
# name: test_switch_state[Dimmer Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'dimmable-switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWD16',
'name': 'Dimmer Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Dimmer Switch][entities]
list([
])
# ---
# name: test_switch_state[Humidifier 200s][devices]
list([
])
# ---
# name: test_switch_state[Humidifier 200s][entities]
list([
])
# ---
# name: test_switch_state[Humidifier 600S][devices]
list([
])
# ---
# name: test_switch_state[Humidifier 600S][entities]
list([
])
# ---
# name: test_switch_state[Outlet][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'outlet',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'wifi-switch-1.3',
'name': 'Outlet',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Outlet][entities]
list([
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.outlet',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Outlet',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'outlet',
'unit_of_measurement': None,
}),
])
# ---
# name: test_switch_state[Outlet][switch.outlet]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Outlet',
}),
'context': <ANY>,
'entity_id': 'switch.outlet',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_switch_state[Temperature Light][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'tunable-bulb',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESL100CW',
'name': 'Temperature Light',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Temperature Light][entities]
list([
])
# ---
# name: test_switch_state[Wall Switch][devices]
list([
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'configuration_url': None,
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'vesync',
'switch',
),
}),
'is_new': False,
'manufacturer': 'VeSync',
'model': 'ESWL01',
'name': 'Wall Switch',
'name_by_user': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
}),
])
# ---
# name: test_switch_state[Wall Switch][entities]
list([
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.wall_switch',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Wall Switch',
'platform': 'vesync',
'supported_features': 0,
'translation_key': None,
'unique_id': 'switch',
'unit_of_measurement': None,
}),
])
# ---
# name: test_switch_state[Wall Switch][switch.wall_switch]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Wall Switch',
}),
'context': <ANY>,
'entity_id': 'switch.wall_switch',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

50
tests/components/vesync/test_fan.py Normal file
View file

@ -0,0 +1,50 @@
"""Tests for the fan module."""
import pytest
import requests_mock
from syrupy import SnapshotAssertion
from homeassistant.components.fan import DOMAIN as FAN_DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er
from .common import ALL_DEVICE_NAMES, mock_devices_response
from tests.common import MockConfigEntry
@pytest.mark.parametrize("device_name", ALL_DEVICE_NAMES)
async def test_fan_state(
hass: HomeAssistant,
snapshot: SnapshotAssertion,
config_entry: MockConfigEntry,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
requests_mock: requests_mock.Mocker,
device_name: str,
) -> None:
"""Test the resulting setup state is as expected for the platform."""
# Configure the API devices call for device_name
mock_devices_response(requests_mock, device_name)
# setup platform - only including the named device
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Check device registry
devices = dr.async_entries_for_config_entry(device_registry, config_entry.entry_id)
assert devices == snapshot(name="devices")
# Check entity registry
entities = [
entity
for entity in er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
if entity.domain == FAN_DOMAIN
]
assert entities == snapshot(name="entities")
# Check states
for entity in entities:
assert hass.states.get(entity.entity_id) == snapshot(name=entity.entity_id)

50
tests/components/vesync/test_light.py Normal file
View file

@ -0,0 +1,50 @@
"""Tests for the light module."""
import pytest
import requests_mock
from syrupy import SnapshotAssertion
from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er
from .common import ALL_DEVICE_NAMES, mock_devices_response
from tests.common import MockConfigEntry
@pytest.mark.parametrize("device_name", ALL_DEVICE_NAMES)
async def test_light_state(
hass: HomeAssistant,
snapshot: SnapshotAssertion,
config_entry: MockConfigEntry,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
requests_mock: requests_mock.Mocker,
device_name: str,
) -> None:
"""Test the resulting setup state is as expected for the platform."""
# Configure the API devices call for device_name
mock_devices_response(requests_mock, device_name)
# setup platform - only including the named device
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Check device registry
devices = dr.async_entries_for_config_entry(device_registry, config_entry.entry_id)
assert devices == snapshot(name="devices")
# Check entity registry
entities = [
entity
for entity in er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
if entity.domain == LIGHT_DOMAIN
]
assert entities == snapshot(name="entities")
# Check states
for entity in entities:
assert hass.states.get(entity.entity_id) == snapshot(name=entity.entity_id)

50
tests/components/vesync/test_sensor.py Normal file
View file

@ -0,0 +1,50 @@
"""Tests for the sensor module."""
import pytest
import requests_mock
from syrupy import SnapshotAssertion
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er
from .common import ALL_DEVICE_NAMES, mock_devices_response
from tests.common import MockConfigEntry
@pytest.mark.parametrize("device_name", ALL_DEVICE_NAMES)
async def test_sensor_state(
hass: HomeAssistant,
snapshot: SnapshotAssertion,
config_entry: MockConfigEntry,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
requests_mock: requests_mock.Mocker,
device_name: str,
) -> None:
"""Test the resulting setup state is as expected for the platform."""
# Configure the API devices call for device_name
mock_devices_response(requests_mock, device_name)
# setup platform - only including the named device
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Check device registry
devices = dr.async_entries_for_config_entry(device_registry, config_entry.entry_id)
assert devices == snapshot(name="devices")
# Check entity registry
entities = [
entity
for entity in er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
if entity.domain == SENSOR_DOMAIN
]
assert entities == snapshot(name="entities")
# Check states
for entity in entities:
assert hass.states.get(entity.entity_id) == snapshot(name=entity.entity_id)

50
tests/components/vesync/test_switch.py Normal file
View file

@ -0,0 +1,50 @@
"""Tests for the switch module."""
import pytest
import requests_mock
from syrupy import SnapshotAssertion
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er
from .common import ALL_DEVICE_NAMES, mock_devices_response
from tests.common import MockConfigEntry
@pytest.mark.parametrize("device_name", ALL_DEVICE_NAMES)
async def test_switch_state(
hass: HomeAssistant,
snapshot: SnapshotAssertion,
config_entry: MockConfigEntry,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
requests_mock: requests_mock.Mocker,
device_name: str,
) -> None:
"""Test the resulting setup state is as expected for the platform."""
# Configure the API devices call for device_name
mock_devices_response(requests_mock, device_name)
# setup platform - only including the named device
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Check device registry
devices = dr.async_entries_for_config_entry(device_registry, config_entry.entry_id)
assert devices == snapshot(name="devices")
# Check entity registry
entities = [
entity
for entity in er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
if entity.domain == SWITCH_DOMAIN
]
assert entities == snapshot(name="entities")
# Check states
for entity in entities:
assert hass.states.get(entity.entity_id) == snapshot(name=entity.entity_id)