mirror of
https://github.com/home-assistant/core.git
synced 2025-07-25 14:17:45 +00:00
Collection of random test improvements (#33742)
This commit is contained in:
parent
c2a90a4f0d
commit
476072927a
@ -234,15 +234,15 @@ class TestAlert(unittest.TestCase):
|
|||||||
self.hass.services.register(notify.DOMAIN, NOTIFIER, record_event)
|
self.hass.services.register(notify.DOMAIN, NOTIFIER, record_event)
|
||||||
|
|
||||||
assert setup_component(self.hass, alert.DOMAIN, config)
|
assert setup_component(self.hass, alert.DOMAIN, config)
|
||||||
assert 0 == len(events)
|
assert len(events) == 0
|
||||||
|
|
||||||
self.hass.states.set("sensor.test", STATE_ON)
|
self.hass.states.set("sensor.test", STATE_ON)
|
||||||
self.hass.block_till_done()
|
self.hass.block_till_done()
|
||||||
assert 1 == len(events)
|
assert len(events) == 1
|
||||||
|
|
||||||
self.hass.states.set("sensor.test", STATE_OFF)
|
self.hass.states.set("sensor.test", STATE_OFF)
|
||||||
self.hass.block_till_done()
|
self.hass.block_till_done()
|
||||||
assert 1 == len(events)
|
assert len(events) == 1
|
||||||
|
|
||||||
def test_notification(self):
|
def test_notification(self):
|
||||||
"""Test notifications."""
|
"""Test notifications."""
|
||||||
@ -256,15 +256,15 @@ class TestAlert(unittest.TestCase):
|
|||||||
self.hass.services.register(notify.DOMAIN, NOTIFIER, record_event)
|
self.hass.services.register(notify.DOMAIN, NOTIFIER, record_event)
|
||||||
|
|
||||||
assert setup_component(self.hass, alert.DOMAIN, TEST_CONFIG)
|
assert setup_component(self.hass, alert.DOMAIN, TEST_CONFIG)
|
||||||
assert 0 == len(events)
|
assert len(events) == 0
|
||||||
|
|
||||||
self.hass.states.set("sensor.test", STATE_ON)
|
self.hass.states.set("sensor.test", STATE_ON)
|
||||||
self.hass.block_till_done()
|
self.hass.block_till_done()
|
||||||
assert 1 == len(events)
|
assert len(events) == 1
|
||||||
|
|
||||||
self.hass.states.set("sensor.test", STATE_OFF)
|
self.hass.states.set("sensor.test", STATE_OFF)
|
||||||
self.hass.block_till_done()
|
self.hass.block_till_done()
|
||||||
assert 2 == len(events)
|
assert len(events) == 2
|
||||||
|
|
||||||
def test_sending_non_templated_notification(self):
|
def test_sending_non_templated_notification(self):
|
||||||
"""Test notifications."""
|
"""Test notifications."""
|
||||||
@ -350,11 +350,11 @@ class TestAlert(unittest.TestCase):
|
|||||||
self.hass.services.register(notify.DOMAIN, NOTIFIER, record_event)
|
self.hass.services.register(notify.DOMAIN, NOTIFIER, record_event)
|
||||||
|
|
||||||
assert setup_component(self.hass, alert.DOMAIN, config)
|
assert setup_component(self.hass, alert.DOMAIN, config)
|
||||||
assert 0 == len(events)
|
assert len(events) == 0
|
||||||
|
|
||||||
self.hass.states.set("sensor.test", STATE_ON)
|
self.hass.states.set("sensor.test", STATE_ON)
|
||||||
self.hass.block_till_done()
|
self.hass.block_till_done()
|
||||||
assert 0 == len(events)
|
assert len(events) == 0
|
||||||
|
|
||||||
def test_noack(self):
|
def test_noack(self):
|
||||||
"""Test no ack feature."""
|
"""Test no ack feature."""
|
||||||
|
@ -47,7 +47,6 @@ class MockConfig(config.AbstractConfig):
|
|||||||
|
|
||||||
async def async_accept_grant(self, code):
|
async def async_accept_grant(self, code):
|
||||||
"""Accept a grant."""
|
"""Accept a grant."""
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
DEFAULT_CONFIG = MockConfig(None)
|
DEFAULT_CONFIG = MockConfig(None)
|
||||||
|
@ -979,7 +979,7 @@ async def test_media_player(hass):
|
|||||||
hass,
|
hass,
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"ChangeChannel",
|
"ChangeChannel",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -988,7 +988,7 @@ async def test_media_player(hass):
|
|||||||
payload={"channel": {"number": "24"}, "channelMetadata": {"name": ""}},
|
payload={"channel": {"number": "24"}, "channelMetadata": {"name": ""}},
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"ChangeChannel",
|
"ChangeChannel",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -997,7 +997,7 @@ async def test_media_player(hass):
|
|||||||
payload={"channel": {"callSign": "ABC"}, "channelMetadata": {"name": ""}},
|
payload={"channel": {"callSign": "ABC"}, "channelMetadata": {"name": ""}},
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"ChangeChannel",
|
"ChangeChannel",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -1006,7 +1006,7 @@ async def test_media_player(hass):
|
|||||||
payload={"channel": {"number": ""}, "channelMetadata": {"name": "ABC"}},
|
payload={"channel": {"number": ""}, "channelMetadata": {"name": "ABC"}},
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"ChangeChannel",
|
"ChangeChannel",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -1018,7 +1018,7 @@ async def test_media_player(hass):
|
|||||||
},
|
},
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"ChangeChannel",
|
"ChangeChannel",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -1027,7 +1027,7 @@ async def test_media_player(hass):
|
|||||||
payload={"channel": {"uri": "ABC"}, "channelMetadata": {"name": ""}},
|
payload={"channel": {"uri": "ABC"}, "channelMetadata": {"name": ""}},
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"SkipChannels",
|
"SkipChannels",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -1036,7 +1036,7 @@ async def test_media_player(hass):
|
|||||||
payload={"channelCount": 1},
|
payload={"channelCount": 1},
|
||||||
)
|
)
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
await assert_request_calls_service(
|
||||||
"Alexa.ChannelController",
|
"Alexa.ChannelController",
|
||||||
"SkipChannels",
|
"SkipChannels",
|
||||||
"media_player#test",
|
"media_player#test",
|
||||||
@ -1467,7 +1467,7 @@ async def test_media_player_seek_error(hass):
|
|||||||
|
|
||||||
# Test for media_position error.
|
# Test for media_position error.
|
||||||
with pytest.raises(AssertionError):
|
with pytest.raises(AssertionError):
|
||||||
call, msg = await assert_request_calls_service(
|
_, msg = await assert_request_calls_service(
|
||||||
"Alexa.SeekController",
|
"Alexa.SeekController",
|
||||||
"AdjustSeekPosition",
|
"AdjustSeekPosition",
|
||||||
"media_player#test_seek",
|
"media_player#test_seek",
|
||||||
@ -1707,11 +1707,7 @@ async def assert_percentage_changes(
|
|||||||
AdjustPercentage, AdjustBrightness, etc. are examples of such requests.
|
AdjustPercentage, AdjustBrightness, etc. are examples of such requests.
|
||||||
"""
|
"""
|
||||||
for result_volume, adjustment in adjustments:
|
for result_volume, adjustment in adjustments:
|
||||||
if parameter:
|
payload = {parameter: adjustment} if parameter else {}
|
||||||
payload = {parameter: adjustment}
|
|
||||||
else:
|
|
||||||
payload = {}
|
|
||||||
|
|
||||||
call, _ = await assert_request_calls_service(
|
call, _ = await assert_request_calls_service(
|
||||||
namespace, name, endpoint, service, hass, payload=payload
|
namespace, name, endpoint, service, hass, payload=payload
|
||||||
)
|
)
|
||||||
@ -2475,7 +2471,7 @@ async def test_alarm_control_panel_disarmed(hass):
|
|||||||
properties = await reported_properties(hass, "alarm_control_panel#test_1")
|
properties = await reported_properties(hass, "alarm_control_panel#test_1")
|
||||||
properties.assert_equal("Alexa.SecurityPanelController", "armState", "DISARMED")
|
properties.assert_equal("Alexa.SecurityPanelController", "armState", "DISARMED")
|
||||||
|
|
||||||
call, msg = await assert_request_calls_service(
|
_, msg = await assert_request_calls_service(
|
||||||
"Alexa.SecurityPanelController",
|
"Alexa.SecurityPanelController",
|
||||||
"Arm",
|
"Arm",
|
||||||
"alarm_control_panel#test_1",
|
"alarm_control_panel#test_1",
|
||||||
@ -2487,7 +2483,7 @@ async def test_alarm_control_panel_disarmed(hass):
|
|||||||
properties = ReportedProperties(msg["context"]["properties"])
|
properties = ReportedProperties(msg["context"]["properties"])
|
||||||
properties.assert_equal("Alexa.SecurityPanelController", "armState", "ARMED_STAY")
|
properties.assert_equal("Alexa.SecurityPanelController", "armState", "ARMED_STAY")
|
||||||
|
|
||||||
call, msg = await assert_request_calls_service(
|
_, msg = await assert_request_calls_service(
|
||||||
"Alexa.SecurityPanelController",
|
"Alexa.SecurityPanelController",
|
||||||
"Arm",
|
"Arm",
|
||||||
"alarm_control_panel#test_1",
|
"alarm_control_panel#test_1",
|
||||||
|
@ -49,12 +49,12 @@ def test_setup_params(hass):
|
|||||||
"""Test the initial parameters."""
|
"""Test the initial parameters."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert state.state == HVAC_MODE_COOL
|
assert state.state == HVAC_MODE_COOL
|
||||||
assert 21 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 21
|
||||||
assert 22 == state.attributes.get(ATTR_CURRENT_TEMPERATURE)
|
assert state.attributes.get(ATTR_CURRENT_TEMPERATURE) == 22
|
||||||
assert "On High" == state.attributes.get(ATTR_FAN_MODE)
|
assert state.attributes.get(ATTR_FAN_MODE) == "On High"
|
||||||
assert 67 == state.attributes.get(ATTR_HUMIDITY)
|
assert state.attributes.get(ATTR_HUMIDITY) == 67
|
||||||
assert 54 == state.attributes.get(ATTR_CURRENT_HUMIDITY)
|
assert state.attributes.get(ATTR_CURRENT_HUMIDITY) == 54
|
||||||
assert "Off" == state.attributes.get(ATTR_SWING_MODE)
|
assert state.attributes.get(ATTR_SWING_MODE) == "Off"
|
||||||
assert STATE_OFF == state.attributes.get(ATTR_AUX_HEAT)
|
assert STATE_OFF == state.attributes.get(ATTR_AUX_HEAT)
|
||||||
assert state.attributes.get(ATTR_HVAC_MODES) == [
|
assert state.attributes.get(ATTR_HVAC_MODES) == [
|
||||||
"off",
|
"off",
|
||||||
@ -69,54 +69,54 @@ def test_setup_params(hass):
|
|||||||
def test_default_setup_params(hass):
|
def test_default_setup_params(hass):
|
||||||
"""Test the setup with default parameters."""
|
"""Test the setup with default parameters."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 7 == state.attributes.get(ATTR_MIN_TEMP)
|
assert state.attributes.get(ATTR_MIN_TEMP) == 7
|
||||||
assert 35 == state.attributes.get(ATTR_MAX_TEMP)
|
assert state.attributes.get(ATTR_MAX_TEMP) == 35
|
||||||
assert 30 == state.attributes.get(ATTR_MIN_HUMIDITY)
|
assert state.attributes.get(ATTR_MIN_HUMIDITY) == 30
|
||||||
assert 99 == state.attributes.get(ATTR_MAX_HUMIDITY)
|
assert state.attributes.get(ATTR_MAX_HUMIDITY) == 99
|
||||||
|
|
||||||
|
|
||||||
async def test_set_only_target_temp_bad_attr(hass):
|
async def test_set_only_target_temp_bad_attr(hass):
|
||||||
"""Test setting the target temperature without required attribute."""
|
"""Test setting the target temperature without required attribute."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 21 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 21
|
||||||
|
|
||||||
with pytest.raises(vol.Invalid):
|
with pytest.raises(vol.Invalid):
|
||||||
await common.async_set_temperature(hass, None, ENTITY_CLIMATE)
|
await common.async_set_temperature(hass, None, ENTITY_CLIMATE)
|
||||||
|
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
assert 21 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 21
|
||||||
|
|
||||||
|
|
||||||
async def test_set_only_target_temp(hass):
|
async def test_set_only_target_temp(hass):
|
||||||
"""Test the setting of the target temperature."""
|
"""Test the setting of the target temperature."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 21 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 21
|
||||||
|
|
||||||
await common.async_set_temperature(hass, 30, ENTITY_CLIMATE)
|
await common.async_set_temperature(hass, 30, ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 30.0 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 30.0
|
||||||
|
|
||||||
|
|
||||||
async def test_set_only_target_temp_with_convert(hass):
|
async def test_set_only_target_temp_with_convert(hass):
|
||||||
"""Test the setting of the target temperature."""
|
"""Test the setting of the target temperature."""
|
||||||
state = hass.states.get(ENTITY_HEATPUMP)
|
state = hass.states.get(ENTITY_HEATPUMP)
|
||||||
assert 20 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 20
|
||||||
|
|
||||||
await common.async_set_temperature(hass, 21, ENTITY_HEATPUMP)
|
await common.async_set_temperature(hass, 21, ENTITY_HEATPUMP)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_HEATPUMP)
|
state = hass.states.get(ENTITY_HEATPUMP)
|
||||||
assert 21.0 == state.attributes.get(ATTR_TEMPERATURE)
|
assert state.attributes.get(ATTR_TEMPERATURE) == 21.0
|
||||||
|
|
||||||
|
|
||||||
async def test_set_target_temp_range(hass):
|
async def test_set_target_temp_range(hass):
|
||||||
"""Test the setting of the target temperature with range."""
|
"""Test the setting of the target temperature with range."""
|
||||||
state = hass.states.get(ENTITY_ECOBEE)
|
state = hass.states.get(ENTITY_ECOBEE)
|
||||||
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
||||||
assert 21.0 == state.attributes.get(ATTR_TARGET_TEMP_LOW)
|
assert state.attributes.get(ATTR_TARGET_TEMP_LOW) == 21.0
|
||||||
assert 24.0 == state.attributes.get(ATTR_TARGET_TEMP_HIGH)
|
assert state.attributes.get(ATTR_TARGET_TEMP_HIGH) == 24.0
|
||||||
|
|
||||||
await common.async_set_temperature(
|
await common.async_set_temperature(
|
||||||
hass, target_temp_high=25, target_temp_low=20, entity_id=ENTITY_ECOBEE
|
hass, target_temp_high=25, target_temp_low=20, entity_id=ENTITY_ECOBEE
|
||||||
@ -125,16 +125,16 @@ async def test_set_target_temp_range(hass):
|
|||||||
|
|
||||||
state = hass.states.get(ENTITY_ECOBEE)
|
state = hass.states.get(ENTITY_ECOBEE)
|
||||||
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
||||||
assert 20.0 == state.attributes.get(ATTR_TARGET_TEMP_LOW)
|
assert state.attributes.get(ATTR_TARGET_TEMP_LOW) == 20.0
|
||||||
assert 25.0 == state.attributes.get(ATTR_TARGET_TEMP_HIGH)
|
assert state.attributes.get(ATTR_TARGET_TEMP_HIGH) == 25.0
|
||||||
|
|
||||||
|
|
||||||
async def test_set_target_temp_range_bad_attr(hass):
|
async def test_set_target_temp_range_bad_attr(hass):
|
||||||
"""Test setting the target temperature range without attribute."""
|
"""Test setting the target temperature range without attribute."""
|
||||||
state = hass.states.get(ENTITY_ECOBEE)
|
state = hass.states.get(ENTITY_ECOBEE)
|
||||||
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
||||||
assert 21.0 == state.attributes.get(ATTR_TARGET_TEMP_LOW)
|
assert state.attributes.get(ATTR_TARGET_TEMP_LOW) == 21.0
|
||||||
assert 24.0 == state.attributes.get(ATTR_TARGET_TEMP_HIGH)
|
assert state.attributes.get(ATTR_TARGET_TEMP_HIGH) == 24.0
|
||||||
|
|
||||||
with pytest.raises(vol.Invalid):
|
with pytest.raises(vol.Invalid):
|
||||||
await common.async_set_temperature(
|
await common.async_set_temperature(
|
||||||
@ -148,83 +148,83 @@ async def test_set_target_temp_range_bad_attr(hass):
|
|||||||
|
|
||||||
state = hass.states.get(ENTITY_ECOBEE)
|
state = hass.states.get(ENTITY_ECOBEE)
|
||||||
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
assert state.attributes.get(ATTR_TEMPERATURE) is None
|
||||||
assert 21.0 == state.attributes.get(ATTR_TARGET_TEMP_LOW)
|
assert state.attributes.get(ATTR_TARGET_TEMP_LOW) == 21.0
|
||||||
assert 24.0 == state.attributes.get(ATTR_TARGET_TEMP_HIGH)
|
assert state.attributes.get(ATTR_TARGET_TEMP_HIGH) == 24.0
|
||||||
|
|
||||||
|
|
||||||
async def test_set_target_humidity_bad_attr(hass):
|
async def test_set_target_humidity_bad_attr(hass):
|
||||||
"""Test setting the target humidity without required attribute."""
|
"""Test setting the target humidity without required attribute."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 67 == state.attributes.get(ATTR_HUMIDITY)
|
assert state.attributes.get(ATTR_HUMIDITY) == 67
|
||||||
|
|
||||||
with pytest.raises(vol.Invalid):
|
with pytest.raises(vol.Invalid):
|
||||||
await common.async_set_humidity(hass, None, ENTITY_CLIMATE)
|
await common.async_set_humidity(hass, None, ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 67 == state.attributes.get(ATTR_HUMIDITY)
|
assert state.attributes.get(ATTR_HUMIDITY) == 67
|
||||||
|
|
||||||
|
|
||||||
async def test_set_target_humidity(hass):
|
async def test_set_target_humidity(hass):
|
||||||
"""Test the setting of the target humidity."""
|
"""Test the setting of the target humidity."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 67 == state.attributes.get(ATTR_HUMIDITY)
|
assert state.attributes.get(ATTR_HUMIDITY) == 67
|
||||||
|
|
||||||
await common.async_set_humidity(hass, 64, ENTITY_CLIMATE)
|
await common.async_set_humidity(hass, 64, ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert 64.0 == state.attributes.get(ATTR_HUMIDITY)
|
assert state.attributes.get(ATTR_HUMIDITY) == 64.0
|
||||||
|
|
||||||
|
|
||||||
async def test_set_fan_mode_bad_attr(hass):
|
async def test_set_fan_mode_bad_attr(hass):
|
||||||
"""Test setting fan mode without required attribute."""
|
"""Test setting fan mode without required attribute."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "On High" == state.attributes.get(ATTR_FAN_MODE)
|
assert state.attributes.get(ATTR_FAN_MODE) == "On High"
|
||||||
|
|
||||||
with pytest.raises(vol.Invalid):
|
with pytest.raises(vol.Invalid):
|
||||||
await common.async_set_fan_mode(hass, None, ENTITY_CLIMATE)
|
await common.async_set_fan_mode(hass, None, ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "On High" == state.attributes.get(ATTR_FAN_MODE)
|
assert state.attributes.get(ATTR_FAN_MODE) == "On High"
|
||||||
|
|
||||||
|
|
||||||
async def test_set_fan_mode(hass):
|
async def test_set_fan_mode(hass):
|
||||||
"""Test setting of new fan mode."""
|
"""Test setting of new fan mode."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "On High" == state.attributes.get(ATTR_FAN_MODE)
|
assert state.attributes.get(ATTR_FAN_MODE) == "On High"
|
||||||
|
|
||||||
await common.async_set_fan_mode(hass, "On Low", ENTITY_CLIMATE)
|
await common.async_set_fan_mode(hass, "On Low", ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "On Low" == state.attributes.get(ATTR_FAN_MODE)
|
assert state.attributes.get(ATTR_FAN_MODE) == "On Low"
|
||||||
|
|
||||||
|
|
||||||
async def test_set_swing_mode_bad_attr(hass):
|
async def test_set_swing_mode_bad_attr(hass):
|
||||||
"""Test setting swing mode without required attribute."""
|
"""Test setting swing mode without required attribute."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "Off" == state.attributes.get(ATTR_SWING_MODE)
|
assert state.attributes.get(ATTR_SWING_MODE) == "Off"
|
||||||
|
|
||||||
with pytest.raises(vol.Invalid):
|
with pytest.raises(vol.Invalid):
|
||||||
await common.async_set_swing_mode(hass, None, ENTITY_CLIMATE)
|
await common.async_set_swing_mode(hass, None, ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "Off" == state.attributes.get(ATTR_SWING_MODE)
|
assert state.attributes.get(ATTR_SWING_MODE) == "Off"
|
||||||
|
|
||||||
|
|
||||||
async def test_set_swing(hass):
|
async def test_set_swing(hass):
|
||||||
"""Test setting of new swing mode."""
|
"""Test setting of new swing mode."""
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "Off" == state.attributes.get(ATTR_SWING_MODE)
|
assert state.attributes.get(ATTR_SWING_MODE) == "Off"
|
||||||
|
|
||||||
await common.async_set_swing_mode(hass, "Auto", ENTITY_CLIMATE)
|
await common.async_set_swing_mode(hass, "Auto", ENTITY_CLIMATE)
|
||||||
await hass.async_block_till_done()
|
await hass.async_block_till_done()
|
||||||
|
|
||||||
state = hass.states.get(ENTITY_CLIMATE)
|
state = hass.states.get(ENTITY_CLIMATE)
|
||||||
assert "Auto" == state.attributes.get(ATTR_SWING_MODE)
|
assert state.attributes.get(ATTR_SWING_MODE) == "Auto"
|
||||||
|
|
||||||
|
|
||||||
async def test_set_hvac_bad_attr_and_state(hass):
|
async def test_set_hvac_bad_attr_and_state(hass):
|
||||||
|
@ -24,15 +24,15 @@ async def test_state_attributes(hass):
|
|||||||
assert light.is_on(hass, ENTITY_LIGHT)
|
assert light.is_on(hass, ENTITY_LIGHT)
|
||||||
assert (0.4, 0.4) == state.attributes.get(light.ATTR_XY_COLOR)
|
assert (0.4, 0.4) == state.attributes.get(light.ATTR_XY_COLOR)
|
||||||
assert state.attributes.get(light.ATTR_BRIGHTNESS) == 25
|
assert state.attributes.get(light.ATTR_BRIGHTNESS) == 25
|
||||||
assert (255, 234, 164) == state.attributes.get(light.ATTR_RGB_COLOR)
|
assert state.attributes.get(light.ATTR_RGB_COLOR) == (255, 234, 164)
|
||||||
assert state.attributes.get(light.ATTR_EFFECT) == "rainbow"
|
assert state.attributes.get(light.ATTR_EFFECT) == "rainbow"
|
||||||
await common.async_turn_on(
|
await common.async_turn_on(
|
||||||
hass, ENTITY_LIGHT, rgb_color=(251, 253, 255), white_value=254
|
hass, ENTITY_LIGHT, rgb_color=(251, 253, 255), white_value=254
|
||||||
)
|
)
|
||||||
state = hass.states.get(ENTITY_LIGHT)
|
state = hass.states.get(ENTITY_LIGHT)
|
||||||
assert state.attributes.get(light.ATTR_WHITE_VALUE) == 254
|
assert state.attributes.get(light.ATTR_WHITE_VALUE) == 254
|
||||||
assert (250, 252, 255) == state.attributes.get(light.ATTR_RGB_COLOR)
|
assert state.attributes.get(light.ATTR_RGB_COLOR) == (250, 252, 255)
|
||||||
assert (0.319, 0.326) == state.attributes.get(light.ATTR_XY_COLOR)
|
assert state.attributes.get(light.ATTR_XY_COLOR) == (0.319, 0.326)
|
||||||
await common.async_turn_on(hass, ENTITY_LIGHT, color_temp=400, effect="none")
|
await common.async_turn_on(hass, ENTITY_LIGHT, color_temp=400, effect="none")
|
||||||
state = hass.states.get(ENTITY_LIGHT)
|
state = hass.states.get(ENTITY_LIGHT)
|
||||||
assert state.attributes.get(light.ATTR_COLOR_TEMP) == 400
|
assert state.attributes.get(light.ATTR_COLOR_TEMP) == 400
|
||||||
|
@ -1,10 +1,10 @@
|
|||||||
"""The tests for the Demo lock platform."""
|
"""The tests for the Demo lock platform."""
|
||||||
import unittest
|
import pytest
|
||||||
|
|
||||||
from homeassistant.components import lock
|
from homeassistant.components import lock
|
||||||
from homeassistant.setup import setup_component
|
from homeassistant.setup import async_setup_component
|
||||||
|
|
||||||
from tests.common import get_test_home_assistant, mock_service
|
from tests.common import async_mock_service
|
||||||
from tests.components.lock import common
|
from tests.components.lock import common
|
||||||
|
|
||||||
FRONT = "lock.front_door"
|
FRONT = "lock.front_door"
|
||||||
@ -12,43 +12,38 @@ KITCHEN = "lock.kitchen_door"
|
|||||||
OPENABLE_LOCK = "lock.openable_lock"
|
OPENABLE_LOCK = "lock.openable_lock"
|
||||||
|
|
||||||
|
|
||||||
class TestLockDemo(unittest.TestCase):
|
@pytest.fixture(autouse=True)
|
||||||
"""Test the demo lock."""
|
def setup_comp(hass):
|
||||||
|
"""Set up demo component."""
|
||||||
|
hass.loop.run_until_complete(
|
||||||
|
async_setup_component(hass, lock.DOMAIN, {lock.DOMAIN: {"platform": "demo"}})
|
||||||
|
)
|
||||||
|
|
||||||
def setUp(self): # pylint: disable=invalid-name
|
|
||||||
"""Set up things to be run when tests are started."""
|
|
||||||
self.hass = get_test_home_assistant()
|
|
||||||
assert setup_component(self.hass, lock.DOMAIN, {"lock": {"platform": "demo"}})
|
|
||||||
|
|
||||||
def tearDown(self): # pylint: disable=invalid-name
|
async def test_is_locked(hass):
|
||||||
"""Stop everything that was started."""
|
"""Test if lock is locked."""
|
||||||
self.hass.stop()
|
assert lock.is_locked(hass, FRONT)
|
||||||
|
assert hass.states.is_state(FRONT, "locked")
|
||||||
|
|
||||||
def test_is_locked(self):
|
assert not lock.is_locked(hass, KITCHEN)
|
||||||
"""Test if lock is locked."""
|
assert hass.states.is_state(KITCHEN, "unlocked")
|
||||||
assert lock.is_locked(self.hass, FRONT)
|
|
||||||
self.hass.states.is_state(FRONT, "locked")
|
|
||||||
|
|
||||||
assert not lock.is_locked(self.hass, KITCHEN)
|
|
||||||
self.hass.states.is_state(KITCHEN, "unlocked")
|
|
||||||
|
|
||||||
def test_locking(self):
|
async def test_locking(hass):
|
||||||
"""Test the locking of a lock."""
|
"""Test the locking of a lock."""
|
||||||
common.lock(self.hass, KITCHEN)
|
await common.async_lock(hass, KITCHEN)
|
||||||
self.hass.block_till_done()
|
assert lock.is_locked(hass, KITCHEN)
|
||||||
|
|
||||||
assert lock.is_locked(self.hass, KITCHEN)
|
|
||||||
|
|
||||||
def test_unlocking(self):
|
async def test_unlocking(hass):
|
||||||
"""Test the unlocking of a lock."""
|
"""Test the unlocking of a lock."""
|
||||||
common.unlock(self.hass, FRONT)
|
await common.async_unlock(hass, FRONT)
|
||||||
self.hass.block_till_done()
|
assert not lock.is_locked(hass, FRONT)
|
||||||
|
|
||||||
assert not lock.is_locked(self.hass, FRONT)
|
|
||||||
|
|
||||||
def test_opening(self):
|
async def test_opening(hass):
|
||||||
"""Test the opening of a lock."""
|
"""Test the opening of a lock."""
|
||||||
calls = mock_service(self.hass, lock.DOMAIN, lock.SERVICE_OPEN)
|
calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_OPEN)
|
||||||
common.open_lock(self.hass, OPENABLE_LOCK)
|
await common.async_open_lock(hass, OPENABLE_LOCK)
|
||||||
self.hass.block_till_done()
|
await hass.async_block_till_done()
|
||||||
assert 1 == len(calls)
|
assert len(calls) == 1
|
||||||
|
@ -1,5 +1,5 @@
|
|||||||
"""The tests for the Demo vacuum platform."""
|
"""The tests for the Demo vacuum platform."""
|
||||||
import unittest
|
import pytest
|
||||||
|
|
||||||
from homeassistant.components import vacuum
|
from homeassistant.components import vacuum
|
||||||
from homeassistant.components.demo.vacuum import (
|
from homeassistant.components.demo.vacuum import (
|
||||||
@ -34,9 +34,9 @@ from homeassistant.const import (
|
|||||||
STATE_OFF,
|
STATE_OFF,
|
||||||
STATE_ON,
|
STATE_ON,
|
||||||
)
|
)
|
||||||
from homeassistant.setup import setup_component
|
from homeassistant.setup import async_setup_component
|
||||||
|
|
||||||
from tests.common import get_test_home_assistant, mock_service
|
from tests.common import async_mock_service
|
||||||
from tests.components.vacuum import common
|
from tests.components.vacuum import common
|
||||||
|
|
||||||
ENTITY_VACUUM_BASIC = f"{DOMAIN}.{DEMO_VACUUM_BASIC}".lower()
|
ENTITY_VACUUM_BASIC = f"{DOMAIN}.{DEMO_VACUUM_BASIC}".lower()
|
||||||
@ -47,326 +47,293 @@ ENTITY_VACUUM_NONE = f"{DOMAIN}.{DEMO_VACUUM_NONE}".lower()
|
|||||||
ENTITY_VACUUM_STATE = f"{DOMAIN}.{DEMO_VACUUM_STATE}".lower()
|
ENTITY_VACUUM_STATE = f"{DOMAIN}.{DEMO_VACUUM_STATE}".lower()
|
||||||
|
|
||||||
|
|
||||||
class TestVacuumDemo(unittest.TestCase):
|
@pytest.fixture(autouse=True)
|
||||||
"""Test the Demo vacuum."""
|
async def setup_demo_vacuum(hass):
|
||||||
|
"""Initialize setup demo vacuum."""
|
||||||
|
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "demo"}})
|
||||||
|
|
||||||
def setUp(self): # pylint: disable=invalid-name
|
|
||||||
"""Set up things to be run when tests are started."""
|
|
||||||
self.hass = get_test_home_assistant()
|
|
||||||
assert setup_component(self.hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "demo"}})
|
|
||||||
|
|
||||||
def tearDown(self): # pylint: disable=invalid-name
|
async def test_supported_features(hass):
|
||||||
"""Stop down everything that was started."""
|
"""Test vacuum supported features."""
|
||||||
self.hass.stop()
|
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
|
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == 2047
|
||||||
|
assert state.attributes.get(ATTR_STATUS) == "Charging"
|
||||||
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) == 100
|
||||||
|
assert state.attributes.get(ATTR_FAN_SPEED) == "medium"
|
||||||
|
assert state.attributes.get(ATTR_FAN_SPEED_LIST) == FAN_SPEEDS
|
||||||
|
assert state.state == STATE_OFF
|
||||||
|
|
||||||
def test_supported_features(self):
|
state = hass.states.get(ENTITY_VACUUM_MOST)
|
||||||
"""Test vacuum supported features."""
|
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == 219
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
assert state.attributes.get(ATTR_STATUS) == "Charging"
|
||||||
assert 2047 == state.attributes.get(ATTR_SUPPORTED_FEATURES)
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) == 100
|
||||||
assert "Charging" == state.attributes.get(ATTR_STATUS)
|
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
||||||
assert 100 == state.attributes.get(ATTR_BATTERY_LEVEL)
|
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
||||||
assert "medium" == state.attributes.get(ATTR_FAN_SPEED)
|
assert state.state == STATE_OFF
|
||||||
assert FAN_SPEEDS == state.attributes.get(ATTR_FAN_SPEED_LIST)
|
|
||||||
assert STATE_OFF == state.state
|
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_MOST)
|
state = hass.states.get(ENTITY_VACUUM_BASIC)
|
||||||
assert 219 == state.attributes.get(ATTR_SUPPORTED_FEATURES)
|
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == 195
|
||||||
assert "Charging" == state.attributes.get(ATTR_STATUS)
|
assert state.attributes.get(ATTR_STATUS) == "Charging"
|
||||||
assert 100 == state.attributes.get(ATTR_BATTERY_LEVEL)
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) == 100
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
||||||
assert STATE_OFF == state.state
|
assert state.state == STATE_OFF
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
|
state = hass.states.get(ENTITY_VACUUM_MINIMAL)
|
||||||
assert 195 == state.attributes.get(ATTR_SUPPORTED_FEATURES)
|
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == 3
|
||||||
assert "Charging" == state.attributes.get(ATTR_STATUS)
|
assert state.attributes.get(ATTR_STATUS) is None
|
||||||
assert 100 == state.attributes.get(ATTR_BATTERY_LEVEL)
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) is None
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
||||||
assert STATE_OFF == state.state
|
assert state.state == STATE_OFF
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_MINIMAL)
|
state = hass.states.get(ENTITY_VACUUM_NONE)
|
||||||
assert 3 == state.attributes.get(ATTR_SUPPORTED_FEATURES)
|
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == 0
|
||||||
assert state.attributes.get(ATTR_STATUS) is None
|
assert state.attributes.get(ATTR_STATUS) is None
|
||||||
assert state.attributes.get(ATTR_BATTERY_LEVEL) is None
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) is None
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
||||||
assert STATE_OFF == state.state
|
assert state.state == STATE_OFF
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_NONE)
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
assert 0 == state.attributes.get(ATTR_SUPPORTED_FEATURES)
|
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == 13436
|
||||||
assert state.attributes.get(ATTR_STATUS) is None
|
assert state.state == STATE_DOCKED
|
||||||
assert state.attributes.get(ATTR_BATTERY_LEVEL) is None
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) == 100
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED) is None
|
assert state.attributes.get(ATTR_FAN_SPEED) == "medium"
|
||||||
assert state.attributes.get(ATTR_FAN_SPEED_LIST) is None
|
assert state.attributes.get(ATTR_FAN_SPEED_LIST) == FAN_SPEEDS
|
||||||
assert STATE_OFF == state.state
|
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
|
||||||
assert 13436 == state.attributes.get(ATTR_SUPPORTED_FEATURES)
|
|
||||||
assert STATE_DOCKED == state.state
|
|
||||||
assert 100 == state.attributes.get(ATTR_BATTERY_LEVEL)
|
|
||||||
assert "medium" == state.attributes.get(ATTR_FAN_SPEED)
|
|
||||||
assert FAN_SPEEDS == state.attributes.get(ATTR_FAN_SPEED_LIST)
|
|
||||||
|
|
||||||
def test_methods(self):
|
async def test_methods(hass):
|
||||||
"""Test if methods call the services as expected."""
|
"""Test if methods call the services as expected."""
|
||||||
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_ON)
|
hass.states.async_set(ENTITY_VACUUM_BASIC, STATE_ON)
|
||||||
self.hass.block_till_done()
|
await hass.async_block_till_done()
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC)
|
assert vacuum.is_on(hass, ENTITY_VACUUM_BASIC)
|
||||||
|
|
||||||
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
|
hass.states.async_set(ENTITY_VACUUM_BASIC, STATE_OFF)
|
||||||
self.hass.block_till_done()
|
await hass.async_block_till_done()
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC)
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_BASIC)
|
||||||
|
|
||||||
common.turn_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_turn_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_turn_off(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.toggle(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_toggle(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_start_pause(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_start_pause(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.stop(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_stop(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
|
||||||
assert "Charging" != state.attributes.get(ATTR_STATUS)
|
assert state.attributes.get(ATTR_STATUS) != "Charging"
|
||||||
|
|
||||||
common.locate(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_locate(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
assert "I'm over here" in state.attributes.get(ATTR_STATUS)
|
||||||
assert "I'm over here" in state.attributes.get(ATTR_STATUS)
|
|
||||||
|
|
||||||
common.return_to_base(self.hass, ENTITY_VACUUM_COMPLETE)
|
await common.async_return_to_base(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
assert "Returning home" in state.attributes.get(ATTR_STATUS)
|
||||||
assert "Returning home" in state.attributes.get(ATTR_STATUS)
|
|
||||||
|
|
||||||
common.set_fan_speed(
|
await common.async_set_fan_speed(
|
||||||
self.hass, FAN_SPEEDS[-1], entity_id=ENTITY_VACUUM_COMPLETE
|
hass, FAN_SPEEDS[-1], entity_id=ENTITY_VACUUM_COMPLETE
|
||||||
)
|
)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
assert state.attributes.get(ATTR_FAN_SPEED) == FAN_SPEEDS[-1]
|
||||||
assert FAN_SPEEDS[-1] == state.attributes.get(ATTR_FAN_SPEED)
|
|
||||||
|
|
||||||
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_COMPLETE)
|
await common.async_clean_spot(hass, entity_id=ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
assert "spot" in state.attributes.get(ATTR_STATUS)
|
||||||
assert "spot" in state.attributes.get(ATTR_STATUS)
|
assert state.state == STATE_ON
|
||||||
assert STATE_ON == state.state
|
|
||||||
|
|
||||||
common.start(self.hass, ENTITY_VACUUM_STATE)
|
await common.async_start(hass, ENTITY_VACUUM_STATE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
assert state.state == STATE_CLEANING
|
||||||
assert STATE_CLEANING == state.state
|
|
||||||
|
|
||||||
common.pause(self.hass, ENTITY_VACUUM_STATE)
|
await common.async_pause(hass, ENTITY_VACUUM_STATE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
assert state.state == STATE_PAUSED
|
||||||
assert STATE_PAUSED == state.state
|
|
||||||
|
|
||||||
common.stop(self.hass, ENTITY_VACUUM_STATE)
|
await common.async_stop(hass, ENTITY_VACUUM_STATE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
assert state.state == STATE_IDLE
|
||||||
assert STATE_IDLE == state.state
|
|
||||||
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
|
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
|
||||||
assert STATE_DOCKED != state.state
|
assert state.state != STATE_DOCKED
|
||||||
|
|
||||||
common.return_to_base(self.hass, ENTITY_VACUUM_STATE)
|
await common.async_return_to_base(hass, ENTITY_VACUUM_STATE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
assert state.state == STATE_RETURNING
|
||||||
assert STATE_RETURNING == state.state
|
|
||||||
|
|
||||||
common.set_fan_speed(self.hass, FAN_SPEEDS[-1], entity_id=ENTITY_VACUUM_STATE)
|
await common.async_set_fan_speed(
|
||||||
self.hass.block_till_done()
|
hass, FAN_SPEEDS[-1], entity_id=ENTITY_VACUUM_STATE
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
)
|
||||||
assert FAN_SPEEDS[-1] == state.attributes.get(ATTR_FAN_SPEED)
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
|
assert state.attributes.get(ATTR_FAN_SPEED) == FAN_SPEEDS[-1]
|
||||||
|
|
||||||
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_STATE)
|
await common.async_clean_spot(hass, entity_id=ENTITY_VACUUM_STATE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
assert state.state == STATE_CLEANING
|
||||||
assert STATE_CLEANING == state.state
|
|
||||||
|
|
||||||
def test_unsupported_methods(self):
|
|
||||||
"""Test service calls for unsupported vacuums."""
|
|
||||||
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_ON)
|
|
||||||
self.hass.block_till_done()
|
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
|
||||||
|
|
||||||
common.turn_off(self.hass, ENTITY_VACUUM_NONE)
|
async def test_unsupported_methods(hass):
|
||||||
self.hass.block_till_done()
|
"""Test service calls for unsupported vacuums."""
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
hass.states.async_set(ENTITY_VACUUM_NONE, STATE_ON)
|
||||||
|
await hass.async_block_till_done()
|
||||||
|
assert vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
|
|
||||||
common.stop(self.hass, ENTITY_VACUUM_NONE)
|
await common.async_turn_off(hass, ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
assert vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
|
||||||
|
|
||||||
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_OFF)
|
await common.async_stop(hass, ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
assert vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
|
||||||
|
|
||||||
common.turn_on(self.hass, ENTITY_VACUUM_NONE)
|
hass.states.async_set(ENTITY_VACUUM_NONE, STATE_OFF)
|
||||||
self.hass.block_till_done()
|
await hass.async_block_till_done()
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
|
|
||||||
common.toggle(self.hass, ENTITY_VACUUM_NONE)
|
await common.async_turn_on(hass, ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
|
||||||
|
|
||||||
# Non supported methods:
|
await common.async_toggle(hass, ENTITY_VACUUM_NONE)
|
||||||
common.start_pause(self.hass, ENTITY_VACUUM_NONE)
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
|
|
||||||
|
|
||||||
common.locate(self.hass, ENTITY_VACUUM_NONE)
|
# Non supported methods:
|
||||||
self.hass.block_till_done()
|
await common.async_start_pause(hass, ENTITY_VACUUM_NONE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_NONE)
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
|
||||||
assert state.attributes.get(ATTR_STATUS) is None
|
|
||||||
|
|
||||||
common.return_to_base(self.hass, ENTITY_VACUUM_NONE)
|
await common.async_locate(hass, ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_NONE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_NONE)
|
assert state.attributes.get(ATTR_STATUS) is None
|
||||||
assert state.attributes.get(ATTR_STATUS) is None
|
|
||||||
|
|
||||||
common.set_fan_speed(self.hass, FAN_SPEEDS[-1], entity_id=ENTITY_VACUUM_NONE)
|
await common.async_return_to_base(hass, ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_NONE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_NONE)
|
assert state.attributes.get(ATTR_STATUS) is None
|
||||||
assert FAN_SPEEDS[-1] != state.attributes.get(ATTR_FAN_SPEED)
|
|
||||||
|
|
||||||
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_BASIC)
|
await common.async_set_fan_speed(hass, FAN_SPEEDS[-1], entity_id=ENTITY_VACUUM_NONE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_NONE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
|
assert state.attributes.get(ATTR_FAN_SPEED) != FAN_SPEEDS[-1]
|
||||||
assert "spot" not in state.attributes.get(ATTR_STATUS)
|
|
||||||
assert STATE_OFF == state.state
|
|
||||||
|
|
||||||
# VacuumDevice should not support start and pause methods.
|
await common.async_clean_spot(hass, entity_id=ENTITY_VACUUM_BASIC)
|
||||||
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_ON)
|
state = hass.states.get(ENTITY_VACUUM_BASIC)
|
||||||
self.hass.block_till_done()
|
assert "spot" not in state.attributes.get(ATTR_STATUS)
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
assert state.state == STATE_OFF
|
||||||
|
|
||||||
common.pause(self.hass, ENTITY_VACUUM_COMPLETE)
|
# VacuumDevice should not support start and pause methods.
|
||||||
self.hass.block_till_done()
|
hass.states.async_set(ENTITY_VACUUM_COMPLETE, STATE_ON)
|
||||||
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
await hass.async_block_till_done()
|
||||||
|
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
|
|
||||||
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_OFF)
|
await common.async_pause(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.start(self.hass, ENTITY_VACUUM_COMPLETE)
|
hass.states.async_set(ENTITY_VACUUM_COMPLETE, STATE_OFF)
|
||||||
self.hass.block_till_done()
|
await hass.async_block_till_done()
|
||||||
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
|
|
||||||
# StateVacuumDevice does not support on/off
|
await common.async_start(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
common.turn_on(self.hass, entity_id=ENTITY_VACUUM_STATE)
|
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
|
||||||
self.hass.block_till_done()
|
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
|
||||||
assert STATE_CLEANING != state.state
|
|
||||||
|
|
||||||
common.turn_off(self.hass, entity_id=ENTITY_VACUUM_STATE)
|
# StateVacuumDevice does not support on/off
|
||||||
self.hass.block_till_done()
|
await common.async_turn_on(hass, entity_id=ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
assert STATE_RETURNING != state.state
|
assert state.state != STATE_CLEANING
|
||||||
|
|
||||||
common.toggle(self.hass, entity_id=ENTITY_VACUUM_STATE)
|
await common.async_turn_off(hass, entity_id=ENTITY_VACUUM_STATE)
|
||||||
self.hass.block_till_done()
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
assert state.state != STATE_RETURNING
|
||||||
assert STATE_CLEANING != state.state
|
|
||||||
|
|
||||||
def test_services(self):
|
await common.async_toggle(hass, entity_id=ENTITY_VACUUM_STATE)
|
||||||
"""Test vacuum services."""
|
state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
# Test send_command
|
assert state.state != STATE_CLEANING
|
||||||
send_command_calls = mock_service(self.hass, DOMAIN, SERVICE_SEND_COMMAND)
|
|
||||||
|
|
||||||
params = {"rotate": 150, "speed": 20}
|
|
||||||
common.send_command(
|
|
||||||
self.hass, "test_command", entity_id=ENTITY_VACUUM_BASIC, params=params
|
|
||||||
)
|
|
||||||
|
|
||||||
self.hass.block_till_done()
|
async def test_services(hass):
|
||||||
assert 1 == len(send_command_calls)
|
"""Test vacuum services."""
|
||||||
call = send_command_calls[-1]
|
# Test send_command
|
||||||
|
send_command_calls = async_mock_service(hass, DOMAIN, SERVICE_SEND_COMMAND)
|
||||||
|
|
||||||
assert DOMAIN == call.domain
|
params = {"rotate": 150, "speed": 20}
|
||||||
assert SERVICE_SEND_COMMAND == call.service
|
await common.async_send_command(
|
||||||
assert ENTITY_VACUUM_BASIC == call.data[ATTR_ENTITY_ID]
|
hass, "test_command", entity_id=ENTITY_VACUUM_BASIC, params=params
|
||||||
assert "test_command" == call.data[ATTR_COMMAND]
|
)
|
||||||
assert params == call.data[ATTR_PARAMS]
|
assert len(send_command_calls) == 1
|
||||||
|
call = send_command_calls[-1]
|
||||||
|
|
||||||
# Test set fan speed
|
assert call.domain == DOMAIN
|
||||||
set_fan_speed_calls = mock_service(self.hass, DOMAIN, SERVICE_SET_FAN_SPEED)
|
assert call.service == SERVICE_SEND_COMMAND
|
||||||
|
assert call.data[ATTR_ENTITY_ID] == ENTITY_VACUUM_BASIC
|
||||||
|
assert call.data[ATTR_COMMAND] == "test_command"
|
||||||
|
assert call.data[ATTR_PARAMS] == params
|
||||||
|
|
||||||
common.set_fan_speed(self.hass, FAN_SPEEDS[0], entity_id=ENTITY_VACUUM_COMPLETE)
|
# Test set fan speed
|
||||||
|
set_fan_speed_calls = async_mock_service(hass, DOMAIN, SERVICE_SET_FAN_SPEED)
|
||||||
|
|
||||||
self.hass.block_till_done()
|
await common.async_set_fan_speed(
|
||||||
assert 1 == len(set_fan_speed_calls)
|
hass, FAN_SPEEDS[0], entity_id=ENTITY_VACUUM_COMPLETE
|
||||||
call = set_fan_speed_calls[-1]
|
)
|
||||||
|
assert len(set_fan_speed_calls) == 1
|
||||||
|
call = set_fan_speed_calls[-1]
|
||||||
|
|
||||||
assert DOMAIN == call.domain
|
assert call.domain == DOMAIN
|
||||||
assert SERVICE_SET_FAN_SPEED == call.service
|
assert call.service == SERVICE_SET_FAN_SPEED
|
||||||
assert ENTITY_VACUUM_COMPLETE == call.data[ATTR_ENTITY_ID]
|
assert call.data[ATTR_ENTITY_ID] == ENTITY_VACUUM_COMPLETE
|
||||||
assert FAN_SPEEDS[0] == call.data[ATTR_FAN_SPEED]
|
assert call.data[ATTR_FAN_SPEED] == FAN_SPEEDS[0]
|
||||||
|
|
||||||
def test_set_fan_speed(self):
|
|
||||||
"""Test vacuum service to set the fan speed."""
|
|
||||||
group_vacuums = ",".join(
|
|
||||||
[ENTITY_VACUUM_BASIC, ENTITY_VACUUM_COMPLETE, ENTITY_VACUUM_STATE]
|
|
||||||
)
|
|
||||||
old_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
|
|
||||||
old_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
|
||||||
old_state_state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
|
||||||
|
|
||||||
common.set_fan_speed(self.hass, FAN_SPEEDS[0], entity_id=group_vacuums)
|
async def test_set_fan_speed(hass):
|
||||||
|
"""Test vacuum service to set the fan speed."""
|
||||||
|
group_vacuums = ",".join(
|
||||||
|
[ENTITY_VACUUM_BASIC, ENTITY_VACUUM_COMPLETE, ENTITY_VACUUM_STATE]
|
||||||
|
)
|
||||||
|
old_state_basic = hass.states.get(ENTITY_VACUUM_BASIC)
|
||||||
|
old_state_complete = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
|
old_state_state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
|
|
||||||
self.hass.block_till_done()
|
await common.async_set_fan_speed(hass, FAN_SPEEDS[0], entity_id=group_vacuums)
|
||||||
new_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
|
|
||||||
new_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
|
||||||
new_state_state = self.hass.states.get(ENTITY_VACUUM_STATE)
|
|
||||||
|
|
||||||
assert old_state_basic == new_state_basic
|
new_state_basic = hass.states.get(ENTITY_VACUUM_BASIC)
|
||||||
assert ATTR_FAN_SPEED not in new_state_basic.attributes
|
new_state_complete = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
|
new_state_state = hass.states.get(ENTITY_VACUUM_STATE)
|
||||||
|
|
||||||
assert old_state_complete != new_state_complete
|
assert old_state_basic == new_state_basic
|
||||||
assert FAN_SPEEDS[1] == old_state_complete.attributes[ATTR_FAN_SPEED]
|
assert ATTR_FAN_SPEED not in new_state_basic.attributes
|
||||||
assert FAN_SPEEDS[0] == new_state_complete.attributes[ATTR_FAN_SPEED]
|
|
||||||
|
|
||||||
assert old_state_state != new_state_state
|
assert old_state_complete != new_state_complete
|
||||||
assert FAN_SPEEDS[1] == old_state_state.attributes[ATTR_FAN_SPEED]
|
assert old_state_complete.attributes[ATTR_FAN_SPEED] == FAN_SPEEDS[1]
|
||||||
assert FAN_SPEEDS[0] == new_state_state.attributes[ATTR_FAN_SPEED]
|
assert new_state_complete.attributes[ATTR_FAN_SPEED] == FAN_SPEEDS[0]
|
||||||
|
|
||||||
def test_send_command(self):
|
assert old_state_state != new_state_state
|
||||||
"""Test vacuum service to send a command."""
|
assert old_state_state.attributes[ATTR_FAN_SPEED] == FAN_SPEEDS[1]
|
||||||
group_vacuums = ",".join([ENTITY_VACUUM_BASIC, ENTITY_VACUUM_COMPLETE])
|
assert new_state_state.attributes[ATTR_FAN_SPEED] == FAN_SPEEDS[0]
|
||||||
old_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
|
|
||||||
old_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
|
||||||
|
|
||||||
common.send_command(
|
|
||||||
self.hass, "test_command", params={"p1": 3}, entity_id=group_vacuums
|
|
||||||
)
|
|
||||||
|
|
||||||
self.hass.block_till_done()
|
async def test_send_command(hass):
|
||||||
new_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
|
"""Test vacuum service to send a command."""
|
||||||
new_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
|
group_vacuums = ",".join([ENTITY_VACUUM_BASIC, ENTITY_VACUUM_COMPLETE])
|
||||||
|
old_state_basic = hass.states.get(ENTITY_VACUUM_BASIC)
|
||||||
|
old_state_complete = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
|
|
||||||
assert old_state_basic == new_state_basic
|
await common.async_send_command(
|
||||||
assert old_state_complete != new_state_complete
|
hass, "test_command", params={"p1": 3}, entity_id=group_vacuums
|
||||||
assert STATE_ON == new_state_complete.state
|
)
|
||||||
assert (
|
|
||||||
"Executing test_command({'p1': 3})"
|
new_state_basic = hass.states.get(ENTITY_VACUUM_BASIC)
|
||||||
== new_state_complete.attributes[ATTR_STATUS]
|
new_state_complete = hass.states.get(ENTITY_VACUUM_COMPLETE)
|
||||||
)
|
|
||||||
|
assert old_state_basic == new_state_basic
|
||||||
|
assert old_state_complete != new_state_complete
|
||||||
|
assert new_state_complete.state == STATE_ON
|
||||||
|
assert (
|
||||||
|
new_state_complete.attributes[ATTR_STATUS]
|
||||||
|
== "Executing test_command({'p1': 3})"
|
||||||
|
)
|
||||||
|
@ -1,120 +1,114 @@
|
|||||||
"""The tests for the demo water_heater component."""
|
"""The tests for the demo water_heater component."""
|
||||||
import unittest
|
|
||||||
|
|
||||||
import pytest
|
import pytest
|
||||||
import voluptuous as vol
|
import voluptuous as vol
|
||||||
|
|
||||||
from homeassistant.components import water_heater
|
from homeassistant.components import water_heater
|
||||||
from homeassistant.setup import setup_component
|
from homeassistant.setup import async_setup_component
|
||||||
from homeassistant.util.unit_system import IMPERIAL_SYSTEM
|
from homeassistant.util.unit_system import IMPERIAL_SYSTEM
|
||||||
|
|
||||||
from tests.common import get_test_home_assistant
|
|
||||||
from tests.components.water_heater import common
|
from tests.components.water_heater import common
|
||||||
|
|
||||||
ENTITY_WATER_HEATER = "water_heater.demo_water_heater"
|
ENTITY_WATER_HEATER = "water_heater.demo_water_heater"
|
||||||
ENTITY_WATER_HEATER_CELSIUS = "water_heater.demo_water_heater_celsius"
|
ENTITY_WATER_HEATER_CELSIUS = "water_heater.demo_water_heater_celsius"
|
||||||
|
|
||||||
|
|
||||||
class TestDemowater_heater(unittest.TestCase):
|
@pytest.fixture(autouse=True)
|
||||||
"""Test the demo water_heater."""
|
def setup_comp(hass):
|
||||||
|
"""Set up demo component."""
|
||||||
def setUp(self): # pylint: disable=invalid-name
|
hass.config.units = IMPERIAL_SYSTEM
|
||||||
"""Set up things to be run when tests are started."""
|
hass.loop.run_until_complete(
|
||||||
self.hass = get_test_home_assistant()
|
async_setup_component(
|
||||||
self.hass.config.units = IMPERIAL_SYSTEM
|
hass, water_heater.DOMAIN, {"water_heater": {"platform": "demo"}}
|
||||||
assert setup_component(
|
|
||||||
self.hass, water_heater.DOMAIN, {"water_heater": {"platform": "demo"}}
|
|
||||||
)
|
)
|
||||||
|
)
|
||||||
|
|
||||||
def tearDown(self): # pylint: disable=invalid-name
|
|
||||||
"""Stop down everything that was started."""
|
|
||||||
self.hass.stop()
|
|
||||||
|
|
||||||
def test_setup_params(self):
|
async def test_setup_params(hass):
|
||||||
"""Test the initial parameters."""
|
"""Test the initial parameters."""
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
assert 119 == state.attributes.get("temperature")
|
assert state.attributes.get("temperature") == 119
|
||||||
assert "off" == state.attributes.get("away_mode")
|
assert state.attributes.get("away_mode") == "off"
|
||||||
assert "eco" == state.attributes.get("operation_mode")
|
assert state.attributes.get("operation_mode") == "eco"
|
||||||
|
|
||||||
def test_default_setup_params(self):
|
|
||||||
"""Test the setup with default parameters."""
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert 110 == state.attributes.get("min_temp")
|
|
||||||
assert 140 == state.attributes.get("max_temp")
|
|
||||||
|
|
||||||
def test_set_only_target_temp_bad_attr(self):
|
async def test_default_setup_params(hass):
|
||||||
"""Test setting the target temperature without required attribute."""
|
"""Test the setup with default parameters."""
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
assert 119 == state.attributes.get("temperature")
|
assert state.attributes.get("min_temp") == 110
|
||||||
with pytest.raises(vol.Invalid):
|
assert state.attributes.get("max_temp") == 140
|
||||||
common.set_temperature(self.hass, None, ENTITY_WATER_HEATER)
|
|
||||||
self.hass.block_till_done()
|
|
||||||
assert 119 == state.attributes.get("temperature")
|
|
||||||
|
|
||||||
def test_set_only_target_temp(self):
|
|
||||||
"""Test the setting of the target temperature."""
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert 119 == state.attributes.get("temperature")
|
|
||||||
common.set_temperature(self.hass, 110, ENTITY_WATER_HEATER)
|
|
||||||
self.hass.block_till_done()
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert 110 == state.attributes.get("temperature")
|
|
||||||
|
|
||||||
def test_set_operation_bad_attr_and_state(self):
|
async def test_set_only_target_temp_bad_attr(hass):
|
||||||
"""Test setting operation mode without required attribute.
|
"""Test setting the target temperature without required attribute."""
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("temperature") == 119
|
||||||
|
with pytest.raises(vol.Invalid):
|
||||||
|
await common.async_set_temperature(hass, None, ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("temperature") == 119
|
||||||
|
|
||||||
Also check the state.
|
|
||||||
"""
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert "eco" == state.attributes.get("operation_mode")
|
|
||||||
assert "eco" == state.state
|
|
||||||
with pytest.raises(vol.Invalid):
|
|
||||||
common.set_operation_mode(self.hass, None, ENTITY_WATER_HEATER)
|
|
||||||
self.hass.block_till_done()
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert "eco" == state.attributes.get("operation_mode")
|
|
||||||
assert "eco" == state.state
|
|
||||||
|
|
||||||
def test_set_operation(self):
|
async def test_set_only_target_temp(hass):
|
||||||
"""Test setting of new operation mode."""
|
"""Test the setting of the target temperature."""
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
assert "eco" == state.attributes.get("operation_mode")
|
assert state.attributes.get("temperature") == 119
|
||||||
assert "eco" == state.state
|
await common.async_set_temperature(hass, 110, ENTITY_WATER_HEATER)
|
||||||
common.set_operation_mode(self.hass, "electric", ENTITY_WATER_HEATER)
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
self.hass.block_till_done()
|
assert state.attributes.get("temperature") == 110
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert "electric" == state.attributes.get("operation_mode")
|
|
||||||
assert "electric" == state.state
|
|
||||||
|
|
||||||
def test_set_away_mode_bad_attr(self):
|
|
||||||
"""Test setting the away mode without required attribute."""
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert "off" == state.attributes.get("away_mode")
|
|
||||||
with pytest.raises(vol.Invalid):
|
|
||||||
common.set_away_mode(self.hass, None, ENTITY_WATER_HEATER)
|
|
||||||
self.hass.block_till_done()
|
|
||||||
assert "off" == state.attributes.get("away_mode")
|
|
||||||
|
|
||||||
def test_set_away_mode_on(self):
|
async def test_set_operation_bad_attr_and_state(hass):
|
||||||
"""Test setting the away mode on/true."""
|
"""Test setting operation mode without required attribute.
|
||||||
common.set_away_mode(self.hass, True, ENTITY_WATER_HEATER)
|
|
||||||
self.hass.block_till_done()
|
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER)
|
|
||||||
assert "on" == state.attributes.get("away_mode")
|
|
||||||
|
|
||||||
def test_set_away_mode_off(self):
|
Also check the state.
|
||||||
"""Test setting the away mode off/false."""
|
"""
|
||||||
common.set_away_mode(self.hass, False, ENTITY_WATER_HEATER_CELSIUS)
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
self.hass.block_till_done()
|
assert state.attributes.get("operation_mode") == "eco"
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER_CELSIUS)
|
assert state.state == "eco"
|
||||||
assert "off" == state.attributes.get("away_mode")
|
with pytest.raises(vol.Invalid):
|
||||||
|
await common.async_set_operation_mode(hass, None, ENTITY_WATER_HEATER)
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("operation_mode") == "eco"
|
||||||
|
assert state.state == "eco"
|
||||||
|
|
||||||
def test_set_only_target_temp_with_convert(self):
|
|
||||||
"""Test the setting of the target temperature."""
|
async def test_set_operation(hass):
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER_CELSIUS)
|
"""Test setting of new operation mode."""
|
||||||
assert 113 == state.attributes.get("temperature")
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
common.set_temperature(self.hass, 114, ENTITY_WATER_HEATER_CELSIUS)
|
assert state.attributes.get("operation_mode") == "eco"
|
||||||
self.hass.block_till_done()
|
assert state.state == "eco"
|
||||||
state = self.hass.states.get(ENTITY_WATER_HEATER_CELSIUS)
|
await common.async_set_operation_mode(hass, "electric", ENTITY_WATER_HEATER)
|
||||||
assert 114 == state.attributes.get("temperature")
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("operation_mode") == "electric"
|
||||||
|
assert state.state == "electric"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_set_away_mode_bad_attr(hass):
|
||||||
|
"""Test setting the away mode without required attribute."""
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("away_mode") == "off"
|
||||||
|
with pytest.raises(vol.Invalid):
|
||||||
|
await common.async_set_away_mode(hass, None, ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("away_mode") == "off"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_set_away_mode_on(hass):
|
||||||
|
"""Test setting the away mode on/true."""
|
||||||
|
await common.async_set_away_mode(hass, True, ENTITY_WATER_HEATER)
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER)
|
||||||
|
assert state.attributes.get("away_mode") == "on"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_set_away_mode_off(hass):
|
||||||
|
"""Test setting the away mode off/false."""
|
||||||
|
await common.async_set_away_mode(hass, False, ENTITY_WATER_HEATER_CELSIUS)
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER_CELSIUS)
|
||||||
|
assert state.attributes.get("away_mode") == "off"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_set_only_target_temp_with_convert(hass):
|
||||||
|
"""Test the setting of the target temperature."""
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER_CELSIUS)
|
||||||
|
assert state.attributes.get("temperature") == 113
|
||||||
|
await common.async_set_temperature(hass, 114, ENTITY_WATER_HEATER_CELSIUS)
|
||||||
|
state = hass.states.get(ENTITY_WATER_HEATER_CELSIUS)
|
||||||
|
assert state.attributes.get("temperature") == 114
|
||||||
|
@ -84,7 +84,7 @@ async def test_get_name(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert "Melissa 12345678" == thermostat.name
|
assert thermostat.name == "Melissa 12345678"
|
||||||
|
|
||||||
|
|
||||||
async def test_current_fan_mode(hass):
|
async def test_current_fan_mode(hass):
|
||||||
@ -106,7 +106,7 @@ async def test_current_temperature(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert 27.4 == thermostat.current_temperature
|
assert thermostat.current_temperature == 27.4
|
||||||
|
|
||||||
|
|
||||||
async def test_current_temperature_no_data(hass):
|
async def test_current_temperature_no_data(hass):
|
||||||
@ -125,7 +125,7 @@ async def test_target_temperature_step(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert 1 == thermostat.target_temperature_step
|
assert thermostat.target_temperature_step == 1
|
||||||
|
|
||||||
|
|
||||||
async def test_current_operation(hass):
|
async def test_current_operation(hass):
|
||||||
@ -172,7 +172,7 @@ async def test_target_temperature(hass):
|
|||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
await thermostat.async_update()
|
await thermostat.async_update()
|
||||||
assert 16 == thermostat.target_temperature
|
assert thermostat.target_temperature == 16
|
||||||
|
|
||||||
thermostat._cur_settings = None
|
thermostat._cur_settings = None
|
||||||
assert thermostat.target_temperature is None
|
assert thermostat.target_temperature is None
|
||||||
@ -206,7 +206,7 @@ async def test_min_temp(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert 16 == thermostat.min_temp
|
assert thermostat.min_temp == 16
|
||||||
|
|
||||||
|
|
||||||
async def test_max_temp(hass):
|
async def test_max_temp(hass):
|
||||||
@ -215,7 +215,7 @@ async def test_max_temp(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert 30 == thermostat.max_temp
|
assert thermostat.max_temp == 30
|
||||||
|
|
||||||
|
|
||||||
async def test_supported_features(hass):
|
async def test_supported_features(hass):
|
||||||
@ -236,7 +236,7 @@ async def test_set_temperature(hass):
|
|||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
await thermostat.async_update()
|
await thermostat.async_update()
|
||||||
await thermostat.async_set_temperature(**{ATTR_TEMPERATURE: 25})
|
await thermostat.async_set_temperature(**{ATTR_TEMPERATURE: 25})
|
||||||
assert 25 == thermostat.target_temperature
|
assert thermostat.target_temperature == 25
|
||||||
|
|
||||||
|
|
||||||
async def test_fan_mode(hass):
|
async def test_fan_mode(hass):
|
||||||
@ -338,10 +338,10 @@ async def test_hass_mode_to_melissa(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert 1 == thermostat.hass_mode_to_melissa(HVAC_MODE_FAN_ONLY)
|
assert thermostat.hass_mode_to_melissa(HVAC_MODE_FAN_ONLY) == 1
|
||||||
assert 2 == thermostat.hass_mode_to_melissa(HVAC_MODE_HEAT)
|
assert thermostat.hass_mode_to_melissa(HVAC_MODE_HEAT) == 2
|
||||||
assert 3 == thermostat.hass_mode_to_melissa(HVAC_MODE_COOL)
|
assert thermostat.hass_mode_to_melissa(HVAC_MODE_COOL) == 3
|
||||||
assert 4 == thermostat.hass_mode_to_melissa(HVAC_MODE_DRY)
|
assert thermostat.hass_mode_to_melissa(HVAC_MODE_DRY) == 4
|
||||||
thermostat.hass_mode_to_melissa("test")
|
thermostat.hass_mode_to_melissa("test")
|
||||||
mocked_warning.assert_called_once_with(
|
mocked_warning.assert_called_once_with(
|
||||||
"Melissa have no setting for %s mode", "test"
|
"Melissa have no setting for %s mode", "test"
|
||||||
@ -357,10 +357,10 @@ async def test_hass_fan_to_melissa(hass):
|
|||||||
api = melissa_mock()
|
api = melissa_mock()
|
||||||
device = (await api.async_fetch_devices())[_SERIAL]
|
device = (await api.async_fetch_devices())[_SERIAL]
|
||||||
thermostat = MelissaClimate(api, _SERIAL, device)
|
thermostat = MelissaClimate(api, _SERIAL, device)
|
||||||
assert 0 == thermostat.hass_fan_to_melissa("auto")
|
assert thermostat.hass_fan_to_melissa("auto") == 0
|
||||||
assert 1 == thermostat.hass_fan_to_melissa(SPEED_LOW)
|
assert thermostat.hass_fan_to_melissa(SPEED_LOW) == 1
|
||||||
assert 2 == thermostat.hass_fan_to_melissa(SPEED_MEDIUM)
|
assert thermostat.hass_fan_to_melissa(SPEED_MEDIUM) == 2
|
||||||
assert 3 == thermostat.hass_fan_to_melissa(SPEED_HIGH)
|
assert thermostat.hass_fan_to_melissa(SPEED_HIGH) == 3
|
||||||
thermostat.hass_fan_to_melissa("test")
|
thermostat.hass_fan_to_melissa("test")
|
||||||
mocked_warning.assert_called_once_with(
|
mocked_warning.assert_called_once_with(
|
||||||
"Melissa have no setting for %s fan mode", "test"
|
"Melissa have no setting for %s fan mode", "test"
|
||||||
|
@ -13,22 +13,19 @@ from homeassistant.components.water_heater import (
|
|||||||
SERVICE_SET_TEMPERATURE,
|
SERVICE_SET_TEMPERATURE,
|
||||||
)
|
)
|
||||||
from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE, ENTITY_MATCH_ALL
|
from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE, ENTITY_MATCH_ALL
|
||||||
from homeassistant.loader import bind_hass
|
|
||||||
|
|
||||||
|
|
||||||
@bind_hass
|
async def async_set_away_mode(hass, away_mode, entity_id=ENTITY_MATCH_ALL):
|
||||||
def set_away_mode(hass, away_mode, entity_id=ENTITY_MATCH_ALL):
|
|
||||||
"""Turn all or specified water_heater devices away mode on."""
|
"""Turn all or specified water_heater devices away mode on."""
|
||||||
data = {ATTR_AWAY_MODE: away_mode}
|
data = {ATTR_AWAY_MODE: away_mode}
|
||||||
|
|
||||||
if entity_id:
|
if entity_id:
|
||||||
data[ATTR_ENTITY_ID] = entity_id
|
data[ATTR_ENTITY_ID] = entity_id
|
||||||
|
|
||||||
hass.services.call(DOMAIN, SERVICE_SET_AWAY_MODE, data)
|
await hass.services.async_call(DOMAIN, SERVICE_SET_AWAY_MODE, data, blocking=True)
|
||||||
|
|
||||||
|
|
||||||
@bind_hass
|
async def async_set_temperature(
|
||||||
def set_temperature(
|
|
||||||
hass, temperature=None, entity_id=ENTITY_MATCH_ALL, operation_mode=None
|
hass, temperature=None, entity_id=ENTITY_MATCH_ALL, operation_mode=None
|
||||||
):
|
):
|
||||||
"""Set new target temperature."""
|
"""Set new target temperature."""
|
||||||
@ -42,15 +39,18 @@ def set_temperature(
|
|||||||
if value is not None
|
if value is not None
|
||||||
}
|
}
|
||||||
_LOGGER.debug("set_temperature start data=%s", kwargs)
|
_LOGGER.debug("set_temperature start data=%s", kwargs)
|
||||||
hass.services.call(DOMAIN, SERVICE_SET_TEMPERATURE, kwargs)
|
await hass.services.async_call(
|
||||||
|
DOMAIN, SERVICE_SET_TEMPERATURE, kwargs, blocking=True
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
@bind_hass
|
async def async_set_operation_mode(hass, operation_mode, entity_id=ENTITY_MATCH_ALL):
|
||||||
def set_operation_mode(hass, operation_mode, entity_id=ENTITY_MATCH_ALL):
|
|
||||||
"""Set new target operation mode."""
|
"""Set new target operation mode."""
|
||||||
data = {ATTR_OPERATION_MODE: operation_mode}
|
data = {ATTR_OPERATION_MODE: operation_mode}
|
||||||
|
|
||||||
if entity_id is not None:
|
if entity_id is not None:
|
||||||
data[ATTR_ENTITY_ID] = entity_id
|
data[ATTR_ENTITY_ID] = entity_id
|
||||||
|
|
||||||
hass.services.call(DOMAIN, SERVICE_SET_OPERATION_MODE, data)
|
await hass.services.async_call(
|
||||||
|
DOMAIN, SERVICE_SET_OPERATION_MODE, data, blocking=True
|
||||||
|
)
|
||||||
|
@ -93,32 +93,32 @@ async def test_reproducing_states(hass, caplog):
|
|||||||
assert turn_off_calls[0].domain == "water_heater"
|
assert turn_off_calls[0].domain == "water_heater"
|
||||||
assert turn_off_calls[0].data == {"entity_id": "water_heater.entity_on"}
|
assert turn_off_calls[0].data == {"entity_id": "water_heater.entity_on"}
|
||||||
|
|
||||||
VALID_OP_CALLS = [
|
valid_op_calls = [
|
||||||
{"entity_id": "water_heater.entity_away", ATTR_OPERATION_MODE: STATE_GAS},
|
{"entity_id": "water_heater.entity_away", ATTR_OPERATION_MODE: STATE_GAS},
|
||||||
{"entity_id": "water_heater.entity_gas", ATTR_OPERATION_MODE: STATE_ECO},
|
{"entity_id": "water_heater.entity_gas", ATTR_OPERATION_MODE: STATE_ECO},
|
||||||
]
|
]
|
||||||
assert len(set_op_calls) == 2
|
assert len(set_op_calls) == 2
|
||||||
for call in set_op_calls:
|
for call in set_op_calls:
|
||||||
assert call.domain == "water_heater"
|
assert call.domain == "water_heater"
|
||||||
assert call.data in VALID_OP_CALLS
|
assert call.data in valid_op_calls
|
||||||
VALID_OP_CALLS.remove(call.data)
|
valid_op_calls.remove(call.data)
|
||||||
|
|
||||||
VALID_TEMP_CALLS = [
|
valid_temp_calls = [
|
||||||
{"entity_id": "water_heater.entity_off", ATTR_TEMPERATURE: 45},
|
{"entity_id": "water_heater.entity_off", ATTR_TEMPERATURE: 45},
|
||||||
{"entity_id": "water_heater.entity_gas", ATTR_TEMPERATURE: 45},
|
{"entity_id": "water_heater.entity_gas", ATTR_TEMPERATURE: 45},
|
||||||
]
|
]
|
||||||
assert len(set_temp_calls) == 2
|
assert len(set_temp_calls) == 2
|
||||||
for call in set_temp_calls:
|
for call in set_temp_calls:
|
||||||
assert call.domain == "water_heater"
|
assert call.domain == "water_heater"
|
||||||
assert call.data in VALID_TEMP_CALLS
|
assert call.data in valid_temp_calls
|
||||||
VALID_TEMP_CALLS.remove(call.data)
|
valid_temp_calls.remove(call.data)
|
||||||
|
|
||||||
VALID_AWAY_CALLS = [
|
valid_away_calls = [
|
||||||
{"entity_id": "water_heater.entity_all", ATTR_AWAY_MODE: False},
|
{"entity_id": "water_heater.entity_all", ATTR_AWAY_MODE: False},
|
||||||
{"entity_id": "water_heater.entity_gas", ATTR_AWAY_MODE: True},
|
{"entity_id": "water_heater.entity_gas", ATTR_AWAY_MODE: True},
|
||||||
]
|
]
|
||||||
assert len(set_away_calls) == 2
|
assert len(set_away_calls) == 2
|
||||||
for call in set_away_calls:
|
for call in set_away_calls:
|
||||||
assert call.domain == "water_heater"
|
assert call.domain == "water_heater"
|
||||||
assert call.data in VALID_AWAY_CALLS
|
assert call.data in valid_away_calls
|
||||||
VALID_AWAY_CALLS.remove(call.data)
|
valid_away_calls.remove(call.data)
|
||||||
|
Loading…
x
Reference in New Issue
Block a user