diff --git a/tests/components/alert/test_init.py b/tests/components/alert/test_init.py index d4de97f3b46..96c36a87edc 100644 --- a/tests/components/alert/test_init.py +++ b/tests/components/alert/test_init.py @@ -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.""" diff --git a/tests/components/alexa/__init__.py b/tests/components/alexa/__init__.py index a3bc548ee28..d9c1a5a40cd 100644 --- a/tests/components/alexa/__init__.py +++ b/tests/components/alexa/__init__.py @@ -47,7 +47,6 @@ class MockConfig(config.AbstractConfig): async def async_accept_grant(self, code): """Accept a grant.""" - pass DEFAULT_CONFIG = MockConfig(None) diff --git a/tests/components/alexa/test_smart_home.py b/tests/components/alexa/test_smart_home.py index 87e3a94beb4..f94091a6741 100644 --- a/tests/components/alexa/test_smart_home.py +++ b/tests/components/alexa/test_smart_home.py @@ -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", diff --git a/tests/components/demo/test_climate.py b/tests/components/demo/test_climate.py index 2d1b7a85ff8..efdab74304a 100644 --- a/tests/components/demo/test_climate.py +++ b/tests/components/demo/test_climate.py @@ -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): diff --git a/tests/components/demo/test_light.py b/tests/components/demo/test_light.py index 47b5c92fd48..5d0fee65aea 100644 --- a/tests/components/demo/test_light.py +++ b/tests/components/demo/test_light.py @@ -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 diff --git a/tests/components/demo/test_lock.py b/tests/components/demo/test_lock.py index 279bd35d12a..67e3cd6409b 100644 --- a/tests/components/demo/test_lock.py +++ b/tests/components/demo/test_lock.py @@ -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 diff --git a/tests/components/demo/test_vacuum.py b/tests/components/demo/test_vacuum.py index 2bd39bf7cb3..e64e7d178cd 100644 --- a/tests/components/demo/test_vacuum.py +++ b/tests/components/demo/test_vacuum.py @@ -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})" + ) diff --git a/tests/components/demo/test_water_heater.py b/tests/components/demo/test_water_heater.py index 97efd48be4a..b8474e978c4 100644 --- a/tests/components/demo/test_water_heater.py +++ b/tests/components/demo/test_water_heater.py @@ -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 diff --git a/tests/components/melissa/test_climate.py b/tests/components/melissa/test_climate.py index 725cfc7354d..8976f85f3d1 100644 --- a/tests/components/melissa/test_climate.py +++ b/tests/components/melissa/test_climate.py @@ -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" diff --git a/tests/components/water_heater/common.py b/tests/components/water_heater/common.py index 04fd345577e..ece283f4bab 100644 --- a/tests/components/water_heater/common.py +++ b/tests/components/water_heater/common.py @@ -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 + ) diff --git a/tests/components/water_heater/test_reproduce_state.py b/tests/components/water_heater/test_reproduce_state.py index 0c12d8eb54a..93e7deb37ee 100644 --- a/tests/components/water_heater/test_reproduce_state.py +++ b/tests/components/water_heater/test_reproduce_state.py @@ -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)