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