github
/
ha-core
mirror of https://github.com/home-assistant/core
1
Fork 0
Code Releases Activity

Clean deCONZ tests to depend less on integration code (#41015)

This commit is contained in:
Robert Svensson 2020-10-02 11:20:33 +02:00 committed by GitHub
parent dfe3ee5387
commit 552856203b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 237 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
homeassistant/components/deconz/binary_sensor.py
View File

@ -55,7 +55,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
):
entities.append(DeconzBinarySensor(sensor, gateway))
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(

3
homeassistant/components/deconz/climate.py
View File

@ -44,7 +44,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
):
entities.append(DeconzThermostat(sensor, gateway))
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(

3
homeassistant/components/deconz/cover.py
View File

@ -37,7 +37,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
):
entities.append(DeconzCover(light, gateway))
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(

6
homeassistant/components/deconz/light.py
View File

@ -52,7 +52,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
):
entities.append(DeconzLight(light, gateway))
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(
@ -77,7 +78,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
if new_group.unique_id not in known_groups:
entities.append(new_group)
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(

3
homeassistant/components/deconz/scene.py
View File

@ -18,7 +18,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
"""Add scene from deCONZ."""
entities = [DeconzScene(scene, gateway) for scene in scenes]
async_add_entities(entities)
if entities:
async_add_entities(entities)
gateway.listeners.append(
async_dispatcher_connect(

3
homeassistant/components/deconz/sensor.py
View File

@ -108,7 +108,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
):
entities.append(DeconzSensor(sensor, gateway))
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(

3
homeassistant/components/deconz/switch.py
View File

@ -34,7 +34,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
):
entities.append(DeconzSiren(light, gateway))
async_add_entities(entities, True)
if entities:
async_add_entities(entities, True)
gateway.listeners.append(
async_dispatcher_connect(

62
tests/components/deconz/test_binary_sensor.py
View File

@ -66,8 +66,7 @@ async def test_platform_manually_configured(hass):
async def test_no_binary_sensors(hass):
"""Test that no sensors in deconz results in no sensor entities."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -76,22 +75,13 @@ async def test_binary_sensors(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["sensors"] = deepcopy(SENSORS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "binary_sensor.presence_sensor" in gateway.deconz_ids
assert "binary_sensor.temperature_sensor" not in gateway.deconz_ids
assert "binary_sensor.clip_presence_sensor" not in gateway.deconz_ids
assert "binary_sensor.vibration_sensor" in gateway.deconz_ids
assert len(hass.states.async_all()) == 3
assert len(hass.states.async_all()) == 3
presence_sensor = hass.states.get("binary_sensor.presence_sensor")
assert presence_sensor.state == "off"
assert presence_sensor.attributes["device_class"] == DEVICE_CLASS_MOTION
temperature_sensor = hass.states.get("binary_sensor.temperature_sensor")
assert temperature_sensor is None
clip_presence_sensor = hass.states.get("binary_sensor.clip_presence_sensor")
assert clip_presence_sensor is None
assert hass.states.get("binary_sensor.temperature_sensor") is None
assert hass.states.get("binary_sensor.clip_presence_sensor") is None
vibration_sensor = hass.states.get("binary_sensor.vibration_sensor")
assert vibration_sensor.state == "on"
assert vibration_sensor.attributes["device_class"] == DEVICE_CLASS_VIBRATION
@ -106,8 +96,7 @@ async def test_binary_sensors(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
presence_sensor = hass.states.get("binary_sensor.presence_sensor")
assert presence_sensor.state == "on"
assert hass.states.get("binary_sensor.presence_sensor").state == "on"
await gateway.async_reset()
@ -123,51 +112,38 @@ async def test_allow_clip_sensor(hass):
options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: True},
get_state_response=data,
)
assert "binary_sensor.presence_sensor" in gateway.deconz_ids
assert "binary_sensor.temperature_sensor" not in gateway.deconz_ids
assert "binary_sensor.clip_presence_sensor" in gateway.deconz_ids
assert "binary_sensor.vibration_sensor" in gateway.deconz_ids
assert len(hass.states.async_all()) == 4
assert hass.states.get("binary_sensor.presence_sensor").state == "off"
assert hass.states.get("binary_sensor.temperature_sensor") is None
assert hass.states.get("binary_sensor.clip_presence_sensor").state == "off"
assert hass.states.get("binary_sensor.vibration_sensor").state == "on"
presence_sensor = hass.states.get("binary_sensor.presence_sensor")
assert presence_sensor.state == "off"
temperature_sensor = hass.states.get("binary_sensor.temperature_sensor")
assert temperature_sensor is None
clip_presence_sensor = hass.states.get("binary_sensor.clip_presence_sensor")
assert clip_presence_sensor.state == "off"
vibration_sensor = hass.states.get("binary_sensor.vibration_sensor")
assert vibration_sensor.state == "on"
# Disallow clip sensors
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: False}
)
await hass.async_block_till_done()
assert "binary_sensor.presence_sensor" in gateway.deconz_ids
assert "binary_sensor.temperature_sensor" not in gateway.deconz_ids
assert "binary_sensor.clip_presence_sensor" not in gateway.deconz_ids
assert "binary_sensor.vibration_sensor" in gateway.deconz_ids
assert len(hass.states.async_all()) == 3
assert hass.states.get("binary_sensor.clip_presence_sensor") is None
# Allow clip sensors
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: True}
)
await hass.async_block_till_done()
assert "binary_sensor.presence_sensor" in gateway.deconz_ids
assert "binary_sensor.temperature_sensor" not in gateway.deconz_ids
assert "binary_sensor.clip_presence_sensor" in gateway.deconz_ids
assert "binary_sensor.vibration_sensor" in gateway.deconz_ids
assert len(hass.states.async_all()) == 4
assert hass.states.get("binary_sensor.clip_presence_sensor").state == "off"
async def test_add_new_binary_sensor(hass):
"""Test that adding a new binary sensor works."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
assert len(hass.states.async_all()) == 0
state_added_event = {
"t": "event",
@ -179,10 +155,8 @@ async def test_add_new_binary_sensor(hass):
gateway.api.event_handler(state_added_event)
await hass.async_block_till_done()
assert "binary_sensor.presence_sensor" in gateway.deconz_ids
presence_sensor = hass.states.get("binary_sensor.presence_sensor")
assert presence_sensor.state == "off"
assert len(hass.states.async_all()) == 1
assert hass.states.get("binary_sensor.presence_sensor").state == "off"
async def test_add_new_binary_sensor_ignored(hass):

117
tests/components/deconz/test_climate.py
View File

@ -25,14 +25,6 @@ SENSORS = {
"uniqueid": "00:00:00:00:00:00:00:00-00",
},
"2": {
"id": "Presence sensor id",
"name": "Presence sensor",
"type": "ZHAPresence",
"state": {"presence": False},
"config": {"reachable": True},
"uniqueid": "00:00:00:00:00:00:00:01-00",
},
"3": {
"id": "CLIP thermostat id",
"name": "CLIP thermostat",
"type": "CLIPThermostat",
@ -56,8 +48,7 @@ async def test_platform_manually_configured(hass):
async def test_no_sensors(hass):
"""Test that no sensors in deconz results in no climate entities."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -66,27 +57,15 @@ async def test_climate_devices(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["sensors"] = deepcopy(SENSORS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "climate.thermostat" in gateway.deconz_ids
assert "sensor.thermostat" not in gateway.deconz_ids
assert "sensor.thermostat_battery_level" in gateway.deconz_ids
assert "climate.presence_sensor" not in gateway.deconz_ids
assert "climate.clip_thermostat" not in gateway.deconz_ids
assert len(hass.states.async_all()) == 3
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "auto"
assert len(hass.states.async_all()) == 2
assert hass.states.get("climate.thermostat").state == "auto"
assert hass.states.get("sensor.thermostat") is None
assert hass.states.get("sensor.thermostat_battery_level").state == "100"
assert hass.states.get("climate.presence_sensor") is None
assert hass.states.get("climate.clip_thermostat") is None
thermostat = hass.states.get("sensor.thermostat")
assert thermostat is None
thermostat_battery_level = hass.states.get("sensor.thermostat_battery_level")
assert thermostat_battery_level.state == "100"
presence_sensor = hass.states.get("climate.presence_sensor")
assert presence_sensor is None
clip_thermostat = hass.states.get("climate.clip_thermostat")
assert clip_thermostat is None
# Event signals thermostat configured off
state_changed_event = {
"t": "event",
@ -98,8 +77,9 @@ async def test_climate_devices(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "off"
assert hass.states.get("climate.thermostat").state == "off"
# Event signals thermostat state on
state_changed_event = {
"t": "event",
@ -112,8 +92,9 @@ async def test_climate_devices(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "heat"
assert hass.states.get("climate.thermostat").state == "heat"
# Event signals thermostat state off
state_changed_event = {
"t": "event",
@ -125,13 +106,14 @@ async def test_climate_devices(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "off"
assert hass.states.get("climate.thermostat").state == "off"
# Verify service calls
thermostat_device = gateway.api.sensors["1"]
# Service set HVAC mode to auto
with patch.object(thermostat_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
climate.DOMAIN,
@ -144,6 +126,8 @@ async def test_climate_devices(hass):
"put", "/sensors/1/config", json={"mode": "auto"}
)
# Service set HVAC mode to heat
with patch.object(thermostat_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
climate.DOMAIN,
@ -156,6 +140,8 @@ async def test_climate_devices(hass):
"put", "/sensors/1/config", json={"mode": "heat"}
)
# Service set HVAC mode to off
with patch.object(thermostat_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
climate.DOMAIN,
@ -167,6 +153,8 @@ async def test_climate_devices(hass):
"put", "/sensors/1/config", json={"mode": "off"}
)
# Service set temperature to 20
with patch.object(thermostat_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
climate.DOMAIN,
@ -192,51 +180,32 @@ async def test_clip_climate_device(hass):
options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: True},
get_state_response=data,
)
assert "climate.thermostat" in gateway.deconz_ids
assert "sensor.thermostat" not in gateway.deconz_ids
assert "sensor.thermostat_battery_level" in gateway.deconz_ids
assert "climate.presence_sensor" not in gateway.deconz_ids
assert "climate.clip_thermostat" in gateway.deconz_ids
assert len(hass.states.async_all()) == 4
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "auto"
assert len(hass.states.async_all()) == 3
assert hass.states.get("climate.thermostat").state == "auto"
assert hass.states.get("sensor.thermostat") is None
assert hass.states.get("sensor.thermostat_battery_level").state == "100"
assert hass.states.get("climate.clip_thermostat").state == "heat"
thermostat = hass.states.get("sensor.thermostat")
assert thermostat is None
thermostat_battery_level = hass.states.get("sensor.thermostat_battery_level")
assert thermostat_battery_level.state == "100"
presence_sensor = hass.states.get("climate.presence_sensor")
assert presence_sensor is None
clip_thermostat = hass.states.get("climate.clip_thermostat")
assert clip_thermostat.state == "heat"
# Disallow clip sensors
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: False}
)
await hass.async_block_till_done()
assert "climate.thermostat" in gateway.deconz_ids
assert "sensor.thermostat" not in gateway.deconz_ids
assert "sensor.thermostat_battery_level" in gateway.deconz_ids
assert "climate.presence_sensor" not in gateway.deconz_ids
assert "climate.clip_thermostat" not in gateway.deconz_ids
assert len(hass.states.async_all()) == 3
assert len(hass.states.async_all()) == 2
assert hass.states.get("climate.clip_thermostat") is None
# Allow clip sensors
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: True}
)
await hass.async_block_till_done()
assert "climate.thermostat" in gateway.deconz_ids
assert "sensor.thermostat" not in gateway.deconz_ids
assert "sensor.thermostat_battery_level" in gateway.deconz_ids
assert "climate.presence_sensor" not in gateway.deconz_ids
assert "climate.clip_thermostat" in gateway.deconz_ids
assert len(hass.states.async_all()) == 4
assert len(hass.states.async_all()) == 3
assert hass.states.get("climate.clip_thermostat").state == "heat"
async def test_verify_state_update(hass):
@ -244,10 +213,8 @@ async def test_verify_state_update(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["sensors"] = deepcopy(SENSORS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "climate.thermostat" in gateway.deconz_ids
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "auto"
assert hass.states.get("climate.thermostat").state == "auto"
state_changed_event = {
"t": "event",
@ -259,15 +226,14 @@ async def test_verify_state_update(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "auto"
assert hass.states.get("climate.thermostat").state == "auto"
assert gateway.api.sensors["1"].changed_keys == {"state", "r", "t", "on", "e", "id"}
async def test_add_new_climate_device(hass):
"""Test that adding a new climate device works."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
assert len(hass.states.async_all()) == 0
state_added_event = {
"t": "event",
@ -279,7 +245,6 @@ async def test_add_new_climate_device(hass):
gateway.api.event_handler(state_added_event)
await hass.async_block_till_done()
assert "climate.thermostat" in gateway.deconz_ids
thermostat = hass.states.get("climate.thermostat")
assert thermostat.state == "auto"
assert len(hass.states.async_all()) == 2
assert hass.states.get("climate.thermostat").state == "auto"
assert hass.states.get("sensor.thermostat_battery_level").state == "100"

34
tests/components/deconz/test_cover.py
View File

@ -65,8 +65,7 @@ async def test_platform_manually_configured(hass):
async def test_no_covers(hass):
"""Test that no cover entities are created."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -75,15 +74,15 @@ async def test_cover(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["lights"] = deepcopy(COVERS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "cover.level_controllable_cover" in gateway.deconz_ids
assert "cover.window_covering_device" in gateway.deconz_ids
assert "cover.unsupported_cover" not in gateway.deconz_ids
assert "cover.deconz_old_brightness_cover" in gateway.deconz_ids
assert "cover.window_covering_controller" in gateway.deconz_ids
assert len(hass.states.async_all()) == 5
level_controllable_cover = hass.states.get("cover.level_controllable_cover")
assert level_controllable_cover.state == "open"
assert len(hass.states.async_all()) == 5
assert hass.states.get("cover.level_controllable_cover").state == "open"
assert hass.states.get("cover.window_covering_device").state == "closed"
assert hass.states.get("cover.unsupported_cover") is None
assert hass.states.get("cover.deconz_old_brightness_cover").state == "open"
assert hass.states.get("cover.window_covering_controller").state == "closed"
# Event signals cover is closed
state_changed_event = {
"t": "event",
@ -95,11 +94,14 @@ async def test_cover(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
level_controllable_cover = hass.states.get("cover.level_controllable_cover")
assert level_controllable_cover.state == "closed"
assert hass.states.get("cover.level_controllable_cover").state == "closed"
# Verify service calls
level_controllable_cover_device = gateway.api.lights["1"]
# Service open cover
with patch.object(
level_controllable_cover_device, "_request", return_value=True
) as set_callback:
@ -112,6 +114,8 @@ async def test_cover(hass):
await hass.async_block_till_done()
set_callback.assert_called_with("put", "/lights/1/state", json={"on": False})
# Service close cover
with patch.object(
level_controllable_cover_device, "_request", return_value=True
) as set_callback:
@ -126,6 +130,8 @@ async def test_cover(hass):
"put", "/lights/1/state", json={"on": True, "bri": 254}
)
# Service stop cover movement
with patch.object(
level_controllable_cover_device, "_request", return_value=True
) as set_callback:
@ -139,8 +145,7 @@ async def test_cover(hass):
set_callback.assert_called_with("put", "/lights/1/state", json={"bri_inc": 0})
# Test that a reported cover position of 255 (deconz-rest-api < 2.05.73) is interpreted correctly.
deconz_old_brightness_cover = hass.states.get("cover.deconz_old_brightness_cover")
assert deconz_old_brightness_cover.state == "open"
assert hass.states.get("cover.deconz_old_brightness_cover").state == "open"
state_changed_event = {
"t": "event",
@ -153,6 +158,7 @@ async def test_cover(hass):
await hass.async_block_till_done()
deconz_old_brightness_cover = hass.states.get("cover.deconz_old_brightness_cover")
assert deconz_old_brightness_cover.state == "closed"
assert deconz_old_brightness_cover.attributes["current_position"] == 0
await gateway.async_reset()

21
tests/components/deconz/test_deconz_event.py
View File

@ -56,24 +56,13 @@ async def test_deconz_events(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["sensors"] = deepcopy(SENSORS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "sensor.switch_1" not in gateway.deconz_ids
assert "sensor.switch_1_battery_level" not in gateway.deconz_ids
assert "sensor.switch_2" not in gateway.deconz_ids
assert "sensor.switch_2_battery_level" in gateway.deconz_ids
assert len(hass.states.async_all()) == 3
assert len(gateway.events) == 5
switch_1 = hass.states.get("sensor.switch_1")
assert switch_1 is None
switch_1_battery_level = hass.states.get("sensor.switch_1_battery_level")
assert switch_1_battery_level is None
switch_2 = hass.states.get("sensor.switch_2")
assert switch_2 is None
switch_2_battery_level = hass.states.get("sensor.switch_2_battery_level")
assert switch_2_battery_level.state == "100"
assert hass.states.get("sensor.switch_1") is None
assert hass.states.get("sensor.switch_1_battery_level") is None
assert hass.states.get("sensor.switch_2") is None
assert hass.states.get("sensor.switch_2_battery_level").state == "100"
events = async_capture_events(hass, CONF_DECONZ_EVENT)

60
tests/components/deconz/test_light.py
View File

@ -92,8 +92,7 @@ async def test_platform_manually_configured(hass):
async def test_no_lights_or_groups(hass):
"""Test that no lights or groups entities are created."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -103,12 +102,6 @@ async def test_lights_and_groups(hass):
data["groups"] = deepcopy(GROUPS)
data["lights"] = deepcopy(LIGHTS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "light.rgb_light" in gateway.deconz_ids
assert "light.tunable_white_light" in gateway.deconz_ids
assert "light.light_group" in gateway.deconz_ids
assert "light.empty_group" not in gateway.deconz_ids
assert "light.on_off_switch" not in gateway.deconz_ids
assert "light.on_off_light" in gateway.deconz_ids
assert len(hass.states.async_all()) == 6
@ -159,8 +152,12 @@ async def test_lights_and_groups(hass):
rgb_light = hass.states.get("light.rgb_light")
assert rgb_light.state == "off"
# Verify service calls
rgb_light_device = gateway.api.lights["1"]
# Service turn on light with short color loop
with patch.object(rgb_light_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
light.DOMAIN,
@ -188,6 +185,8 @@ async def test_lights_and_groups(hass):
},
)
# Service turn on light disabling color loop with long flashing
with patch.object(rgb_light_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
light.DOMAIN,
@ -207,6 +206,8 @@ async def test_lights_and_groups(hass):
json={"xy": (0.411, 0.351), "alert": "lselect", "effect": "none"},
)
# Service turn on light with short flashing
with patch.object(rgb_light_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
light.DOMAIN,
@ -227,6 +228,8 @@ async def test_lights_and_groups(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
# Service turn off light with short flashing
with patch.object(rgb_light_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
light.DOMAIN,
@ -241,6 +244,8 @@ async def test_lights_and_groups(hass):
json={"bri": 0, "transitiontime": 50, "alert": "select"},
)
# Service turn off light with long flashing
with patch.object(rgb_light_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
light.DOMAIN,
@ -259,7 +264,7 @@ async def test_lights_and_groups(hass):
async def test_disable_light_groups(hass):
"""Test successful creation of sensor entities."""
"""Test disallowing light groups work."""
data = deepcopy(DECONZ_WEB_REQUEST)
data["groups"] = deepcopy(GROUPS)
data["lights"] = deepcopy(LIGHTS)
@ -268,48 +273,25 @@ async def test_disable_light_groups(hass):
options={deconz.gateway.CONF_ALLOW_DECONZ_GROUPS: False},
get_state_response=data,
)
assert "light.rgb_light" in gateway.deconz_ids
assert "light.tunable_white_light" in gateway.deconz_ids
assert "light.light_group" not in gateway.deconz_ids
assert "light.empty_group" not in gateway.deconz_ids
assert "light.on_off_switch" not in gateway.deconz_ids
# 3 entities
assert len(hass.states.async_all()) == 5
rgb_light = hass.states.get("light.rgb_light")
assert rgb_light is not None
tunable_white_light = hass.states.get("light.tunable_white_light")
assert tunable_white_light is not None
light_group = hass.states.get("light.light_group")
assert light_group is None
empty_group = hass.states.get("light.empty_group")
assert empty_group is None
assert hass.states.get("light.rgb_light")
assert hass.states.get("light.tunable_white_light")
assert hass.states.get("light.light_group") is None
assert hass.states.get("light.empty_group") is None
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_DECONZ_GROUPS: True}
)
await hass.async_block_till_done()
assert "light.rgb_light" in gateway.deconz_ids
assert "light.tunable_white_light" in gateway.deconz_ids
assert "light.light_group" in gateway.deconz_ids
assert "light.empty_group" not in gateway.deconz_ids
assert "light.on_off_switch" not in gateway.deconz_ids
# 3 entities
assert len(hass.states.async_all()) == 6
assert hass.states.get("light.light_group")
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_DECONZ_GROUPS: False}
)
await hass.async_block_till_done()
assert "light.rgb_light" in gateway.deconz_ids
assert "light.tunable_white_light" in gateway.deconz_ids
assert "light.light_group" not in gateway.deconz_ids
assert "light.empty_group" not in gateway.deconz_ids
assert "light.on_off_switch" not in gateway.deconz_ids
# 3 entities
assert len(hass.states.async_all()) == 5
assert hass.states.get("light.light_group") is None

15
tests/components/deconz/test_lock.py
View File

@ -40,8 +40,7 @@ async def test_platform_manually_configured(hass):
async def test_no_locks(hass):
"""Test that no lock entities are created."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -50,8 +49,9 @@ async def test_locks(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["lights"] = deepcopy(LOCKS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "lock.door_lock" in gateway.deconz_ids
assert len(hass.states.async_all()) == 1
assert hass.states.get("lock.door_lock").state == STATE_UNLOCKED
door_lock = hass.states.get("lock.door_lock")
assert door_lock.state == STATE_UNLOCKED
@ -66,11 +66,14 @@ async def test_locks(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
door_lock = hass.states.get("lock.door_lock")
assert door_lock.state == STATE_LOCKED
assert hass.states.get("lock.door_lock").state == STATE_LOCKED
# Verify service calls
door_lock_device = gateway.api.lights["1"]
# Service lock door
with patch.object(door_lock_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
lock.DOMAIN,
@ -81,6 +84,8 @@ async def test_locks(hass):
await hass.async_block_till_done()
set_callback.assert_called_with("put", "/lights/1/state", json={"on": True})
# Service unlock door
with patch.object(door_lock_device, "_request", return_value=True) as set_callback:
await hass.services.async_call(
lock.DOMAIN,

10
tests/components/deconz/test_scene.py
View File

@ -35,8 +35,7 @@ async def test_platform_manually_configured(hass):
async def test_no_scenes(hass):
"""Test that scenes can be loaded without scenes being available."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -46,14 +45,15 @@ async def test_scenes(hass):
data["groups"] = deepcopy(GROUPS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "scene.light_group_scene" in gateway.deconz_ids
assert len(hass.states.async_all()) == 1
assert hass.states.get("scene.light_group_scene")
light_group_scene = hass.states.get("scene.light_group_scene")
assert light_group_scene
# Verify service calls
group_scene = gateway.api.groups["1"].scenes["1"]
# Service turn on scene
with patch.object(group_scene, "_request", return_value=True) as set_callback:
await hass.services.async_call(
"scene", "turn_on", {"entity_id": "scene.light_group_scene"}, blocking=True

132
tests/components/deconz/test_sensor.py
View File

@ -93,8 +93,7 @@ async def test_platform_manually_configured(hass):
async def test_no_sensors(hass):
"""Test that no sensors in deconz results in no sensor entities."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
@ -103,40 +102,23 @@ async def test_sensors(hass):
data = deepcopy(DECONZ_WEB_REQUEST)
data["sensors"] = deepcopy(SENSORS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "sensor.light_level_sensor" in gateway.deconz_ids
assert "sensor.presence_sensor" not in gateway.deconz_ids
assert "sensor.switch_1" not in gateway.deconz_ids
assert "sensor.switch_1_battery_level" not in gateway.deconz_ids
assert "sensor.switch_2" not in gateway.deconz_ids
assert "sensor.switch_2_battery_level" in gateway.deconz_ids
assert "sensor.daylight_sensor" not in gateway.deconz_ids
assert "sensor.power_sensor" in gateway.deconz_ids
assert "sensor.consumption_sensor" in gateway.deconz_ids
assert "sensor.clip_light_level_sensor" not in gateway.deconz_ids
assert len(hass.states.async_all()) == 5
light_level_sensor = hass.states.get("sensor.light_level_sensor")
assert light_level_sensor.state == "999.8"
assert light_level_sensor.attributes["device_class"] == DEVICE_CLASS_ILLUMINANCE
presence_sensor = hass.states.get("sensor.presence_sensor")
assert presence_sensor is None
switch_1 = hass.states.get("sensor.switch_1")
assert switch_1 is None
switch_1_battery_level = hass.states.get("sensor.switch_1_battery_level")
assert switch_1_battery_level is None
switch_2 = hass.states.get("sensor.switch_2")
assert switch_2 is None
assert hass.states.get("sensor.presence_sensor") is None
assert hass.states.get("sensor.switch_1") is None
assert hass.states.get("sensor.switch_1_battery_level") is None
assert hass.states.get("sensor.switch_2") is None
switch_2_battery_level = hass.states.get("sensor.switch_2_battery_level")
assert switch_2_battery_level.state == "100"
assert switch_2_battery_level.attributes["device_class"] == DEVICE_CLASS_BATTERY
daylight_sensor = hass.states.get("sensor.daylight_sensor")
assert daylight_sensor is None
assert hass.states.get("sensor.daylight_sensor") is None
power_sensor = hass.states.get("sensor.power_sensor")
assert power_sensor.state == "6"
@ -146,6 +128,10 @@ async def test_sensors(hass):
assert consumption_sensor.state == "0.002"
assert "device_class" not in consumption_sensor.attributes
assert hass.states.get("sensor.clip_light_level_sensor") is None
# Event signals new light level
state_changed_event = {
"t": "event",
"e": "changed",
@ -155,6 +141,10 @@ async def test_sensors(hass):
}
gateway.api.event_handler(state_changed_event)
assert hass.states.get("sensor.light_level_sensor").state == "1.6"
# Event signals new battery level
state_changed_event = {
"t": "event",
"e": "changed",
@ -165,11 +155,7 @@ async def test_sensors(hass):
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
light_level_sensor = hass.states.get("sensor.light_level_sensor")
assert light_level_sensor.state == "1.6"
switch_2_battery_level = hass.states.get("sensor.switch_2_battery_level")
assert switch_2_battery_level.state == "75"
assert hass.states.get("sensor.switch_2_battery_level").state == "75"
await gateway.async_reset()
@ -185,87 +171,35 @@ async def test_allow_clip_sensors(hass):
options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: True},
get_state_response=data,
)
assert "sensor.light_level_sensor" in gateway.deconz_ids
assert "sensor.presence_sensor" not in gateway.deconz_ids
assert "sensor.switch_1" not in gateway.deconz_ids
assert "sensor.switch_1_battery_level" not in gateway.deconz_ids
assert "sensor.switch_2" not in gateway.deconz_ids
assert "sensor.switch_2_battery_level" in gateway.deconz_ids
assert "sensor.daylight_sensor" not in gateway.deconz_ids
assert "sensor.power_sensor" in gateway.deconz_ids
assert "sensor.consumption_sensor" in gateway.deconz_ids
assert "sensor.clip_light_level_sensor" in gateway.deconz_ids
assert len(hass.states.async_all()) == 6
assert hass.states.get("sensor.clip_light_level_sensor").state == "999.8"
light_level_sensor = hass.states.get("sensor.light_level_sensor")
assert light_level_sensor.state == "999.8"
presence_sensor = hass.states.get("sensor.presence_sensor")
assert presence_sensor is None
switch_1 = hass.states.get("sensor.switch_1")
assert switch_1 is None
switch_1_battery_level = hass.states.get("sensor.switch_1_battery_level")
assert switch_1_battery_level is None
switch_2 = hass.states.get("sensor.switch_2")
assert switch_2 is None
switch_2_battery_level = hass.states.get("sensor.switch_2_battery_level")
assert switch_2_battery_level.state == "100"
daylight_sensor = hass.states.get("sensor.daylight_sensor")
assert daylight_sensor is None
power_sensor = hass.states.get("sensor.power_sensor")
assert power_sensor.state == "6"
consumption_sensor = hass.states.get("sensor.consumption_sensor")
assert consumption_sensor.state == "0.002"
clip_light_level_sensor = hass.states.get("sensor.clip_light_level_sensor")
assert clip_light_level_sensor.state == "999.8"
# Disallow clip sensors
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: False}
)
await hass.async_block_till_done()
assert "sensor.light_level_sensor" in gateway.deconz_ids
assert "sensor.presence_sensor" not in gateway.deconz_ids
assert "sensor.switch_1" not in gateway.deconz_ids
assert "sensor.switch_1_battery_level" not in gateway.deconz_ids
assert "sensor.switch_2" not in gateway.deconz_ids
assert "sensor.switch_2_battery_level" in gateway.deconz_ids
assert "sensor.daylight_sensor" not in gateway.deconz_ids
assert "sensor.power_sensor" in gateway.deconz_ids
assert "sensor.consumption_sensor" in gateway.deconz_ids
assert "sensor.clip_light_level_sensor" not in gateway.deconz_ids
assert len(hass.states.async_all()) == 5
assert hass.states.get("sensor.clip_light_level_sensor") is None
# Allow clip sensors
hass.config_entries.async_update_entry(
gateway.config_entry, options={deconz.gateway.CONF_ALLOW_CLIP_SENSOR: True}
)
await hass.async_block_till_done()
assert "sensor.light_level_sensor" in gateway.deconz_ids
assert "sensor.presence_sensor" not in gateway.deconz_ids
assert "sensor.switch_1" not in gateway.deconz_ids
assert "sensor.switch_1_battery_level" not in gateway.deconz_ids
assert "sensor.switch_2" not in gateway.deconz_ids
assert "sensor.switch_2_battery_level" in gateway.deconz_ids
assert "sensor.daylight_sensor" not in gateway.deconz_ids
assert "sensor.power_sensor" in gateway.deconz_ids
assert "sensor.consumption_sensor" in gateway.deconz_ids
assert "sensor.clip_light_level_sensor" in gateway.deconz_ids
assert len(hass.states.async_all()) == 6
assert hass.states.get("sensor.clip_light_level_sensor")
async def test_add_new_sensor(hass):
"""Test that adding a new sensor works."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
assert len(hass.states.async_all()) == 0
state_added_event = {
"t": "event",
@ -277,10 +211,8 @@ async def test_add_new_sensor(hass):
gateway.api.event_handler(state_added_event)
await hass.async_block_till_done()
assert "sensor.light_level_sensor" in gateway.deconz_ids
light_level_sensor = hass.states.get("sensor.light_level_sensor")
assert light_level_sensor.state == "999.8"
assert len(hass.states.async_all()) == 1
assert hass.states.get("sensor.light_level_sensor").state == "999.8"
async def test_add_battery_later(hass):
@ -289,16 +221,16 @@ async def test_add_battery_later(hass):
data["sensors"] = {"1": deepcopy(SENSORS["3"])}
gateway = await setup_deconz_integration(hass, get_state_response=data)
remote = gateway.api.sensors["1"]
assert len(gateway.deconz_ids) == 0
assert len(hass.states.async_all()) == 0
assert len(gateway.events) == 1
assert len(remote._callbacks) == 2
assert len(remote._callbacks) == 2 # Event and battery tracker
remote.update({"config": {"battery": 50}})
await hass.async_block_till_done()
assert len(gateway.deconz_ids) == 1
assert len(hass.states.async_all()) == 1
assert len(gateway.events) == 1
assert len(remote._callbacks) == 2
assert len(remote._callbacks) == 2 # Event and battery entity
battery_sensor = hass.states.get("sensor.switch_1_battery_level")
assert battery_sensor is not None
assert hass.states.get("sensor.switch_1_battery_level")

116
tests/components/deconz/test_switch.py
View File

@ -9,7 +9,7 @@ from .test_gateway import DECONZ_WEB_REQUEST, setup_deconz_integration
from tests.async_mock import patch
SWITCHES = {
POWER_PLUGS = {
"1": {
"id": "On off switch id",
"name": "On off switch",
@ -25,20 +25,13 @@ SWITCHES = {
"uniqueid": "00:00:00:00:00:00:00:01-00",
},
"3": {
"id": "Warning device id",
"name": "Warning device",
"type": "Warning device",
"state": {"alert": "lselect", "reachable": True},
"uniqueid": "00:00:00:00:00:00:00:02-00",
},
"4": {
"id": "Unsupported switch id",
"name": "Unsupported switch",
"type": "Not a smart plug",
"type": "Not a switch",
"state": {"reachable": True},
"uniqueid": "00:00:00:00:00:00:00:03-00",
},
"5": {
"4": {
"id": "On off relay id",
"name": "On off relay",
"state": {"on": True, "reachable": True},
@ -47,6 +40,23 @@ SWITCHES = {
},
}
SIRENS = {
"1": {
"id": "Warning device id",
"name": "Warning device",
"type": "Warning device",
"state": {"alert": "lselect", "reachable": True},
"uniqueid": "00:00:00:00:00:00:00:00-00",
},
"2": {
"id": "Unsupported switch id",
"name": "Unsupported switch",
"type": "Not a switch",
"state": {"reachable": True},
"uniqueid": "00:00:00:00:00:00:00:01-00",
},
}
async def test_platform_manually_configured(hass):
"""Test that we do not discover anything or try to set up a gateway."""
@ -61,34 +71,21 @@ async def test_platform_manually_configured(hass):
async def test_no_switches(hass):
"""Test that no switch entities are created."""
gateway = await setup_deconz_integration(hass)
assert len(gateway.deconz_ids) == 0
await setup_deconz_integration(hass)
assert len(hass.states.async_all()) == 0
async def test_switches(hass):
async def test_power_plugs(hass):
"""Test that all supported switch entities are created."""
data = deepcopy(DECONZ_WEB_REQUEST)
data["lights"] = deepcopy(SWITCHES)
data["lights"] = deepcopy(POWER_PLUGS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert "switch.on_off_switch" in gateway.deconz_ids
assert "switch.smart_plug" in gateway.deconz_ids
assert "switch.warning_device" in gateway.deconz_ids
assert "switch.unsupported_switch" not in gateway.deconz_ids
assert "switch.on_off_relay" in gateway.deconz_ids
assert len(hass.states.async_all()) == 5
on_off_switch = hass.states.get("switch.on_off_switch")
assert on_off_switch.state == "on"
smart_plug = hass.states.get("switch.smart_plug")
assert smart_plug.state == "off"
warning_device = hass.states.get("switch.warning_device")
assert warning_device.state == "on"
on_off_relay = hass.states.get("switch.on_off_relay")
assert on_off_relay.state == "on"
assert len(hass.states.async_all()) == 4
assert hass.states.get("switch.on_off_switch").state == "on"
assert hass.states.get("switch.smart_plug").state == "off"
assert hass.states.get("switch.on_off_relay").state == "on"
assert hass.states.get("switch.unsupported_switch") is None
state_changed_event = {
"t": "event",
@ -98,24 +95,15 @@ async def test_switches(hass):
"state": {"on": False},
}
gateway.api.event_handler(state_changed_event)
state_changed_event = {
"t": "event",
"e": "changed",
"r": "lights",
"id": "3",
"state": {"alert": None},
}
gateway.api.event_handler(state_changed_event)
await hass.async_block_till_done()
on_off_switch = hass.states.get("switch.on_off_switch")
assert on_off_switch.state == "off"
assert hass.states.get("switch.on_off_switch").state == "off"
warning_device = hass.states.get("switch.warning_device")
assert warning_device.state == "off"
# Verify service calls
on_off_switch_device = gateway.api.lights["1"]
# Service turn on power plug
with patch.object(
on_off_switch_device, "_request", return_value=True
) as set_callback:
@ -128,6 +116,8 @@ async def test_switches(hass):
await hass.async_block_till_done()
set_callback.assert_called_with("put", "/lights/1/state", json={"on": True})
# Service turn off power plug
with patch.object(
on_off_switch_device, "_request", return_value=True
) as set_callback:
@ -140,7 +130,37 @@ async def test_switches(hass):
await hass.async_block_till_done()
set_callback.assert_called_with("put", "/lights/1/state", json={"on": False})
warning_device_device = gateway.api.lights["3"]
await gateway.async_reset()
assert len(hass.states.async_all()) == 0
async def test_sirens(hass):
"""Test that siren entities are created."""
data = deepcopy(DECONZ_WEB_REQUEST)
data["lights"] = deepcopy(SIRENS)
gateway = await setup_deconz_integration(hass, get_state_response=data)
assert len(hass.states.async_all()) == 2
assert hass.states.get("switch.warning_device").state == "on"
assert hass.states.get("switch.unsupported_switch") is None
state_changed_event = {
"t": "event",
"e": "changed",
"r": "lights",
"id": "1",
"state": {"alert": None},
}
gateway.api.event_handler(state_changed_event)
assert hass.states.get("switch.warning_device").state == "off"
# Verify service calls
warning_device_device = gateway.api.lights["1"]
# Service turn on siren
with patch.object(
warning_device_device, "_request", return_value=True
@ -153,9 +173,11 @@ async def test_switches(hass):
)
await hass.async_block_till_done()
set_callback.assert_called_with(
"put", "/lights/3/state", json={"alert": "lselect"}
"put", "/lights/1/state", json={"alert": "lselect"}
)
# Service turn off siren
with patch.object(
warning_device_device, "_request", return_value=True
) as set_callback:
@ -167,7 +189,7 @@ async def test_switches(hass):
)
await hass.async_block_till_done()
set_callback.assert_called_with(
"put", "/lights/3/state", json={"alert": "none"}
"put", "/lights/1/state", json={"alert": "none"}
)
await gateway.async_reset()