diff --git a/tests/components/dyson/test_climate.py b/tests/components/dyson/test_climate.py index 124fc46f325..77105dc73db 100644 --- a/tests/components/dyson/test_climate.py +++ b/tests/components/dyson/test_climate.py @@ -1,6 +1,5 @@ """Test the Dyson fan component.""" import json -import unittest from libpurecool.const import ( FanPower, @@ -15,8 +14,8 @@ from libpurecool.dyson_pure_hotcool import DysonPureHotCool from libpurecool.dyson_pure_hotcool_link import DysonPureHotCoolLink from libpurecool.dyson_pure_state import DysonPureHotCoolState from libpurecool.dyson_pure_state_v2 import DysonPureHotCoolV2State +import pytest -from homeassistant.components import dyson as dyson_parent from homeassistant.components.climate import ( DOMAIN, SERVICE_SET_FAN_MODE, @@ -25,9 +24,16 @@ from homeassistant.components.climate import ( ) from homeassistant.components.climate.const import ( ATTR_CURRENT_HUMIDITY, + ATTR_CURRENT_TEMPERATURE, ATTR_FAN_MODE, + ATTR_FAN_MODES, ATTR_HVAC_ACTION, ATTR_HVAC_MODE, + ATTR_HVAC_MODES, + ATTR_MAX_TEMP, + ATTR_MIN_TEMP, + ATTR_TARGET_TEMP_HIGH, + ATTR_TARGET_TEMP_LOW, CURRENT_HVAC_COOL, CURRENT_HVAC_HEAT, CURRENT_HVAC_IDLE, @@ -40,19 +46,29 @@ from homeassistant.components.climate.const import ( HVAC_MODE_HEAT, HVAC_MODE_OFF, ) -from homeassistant.components.dyson import climate as dyson -from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE, TEMP_CELSIUS +from homeassistant.components.dyson import CONF_LANGUAGE, DOMAIN as DYSON_DOMAIN +from homeassistant.components.dyson.climate import FAN_DIFFUSE, FAN_FOCUS, SUPPORT_FLAGS +from homeassistant.const import ( + ATTR_ENTITY_ID, + ATTR_SUPPORTED_FEATURES, + ATTR_TEMPERATURE, + CONF_DEVICES, + CONF_PASSWORD, + CONF_USERNAME, + TEMP_CELSIUS, +) from homeassistant.setup import async_setup_component from .common import load_mock_device -from tests.async_mock import MagicMock, Mock, patch -from tests.common import get_test_home_assistant +from tests.async_mock import Mock, call, patch class MockDysonState(DysonPureHotCoolState): """Mock Dyson state.""" + # pylint: disable=super-init-not-called + def __init__(self): """Create new Mock Dyson State.""" @@ -64,11 +80,11 @@ class MockDysonState(DysonPureHotCoolState): def _get_config(): """Return a config dictionary.""" return { - dyson_parent.DOMAIN: { - dyson_parent.CONF_USERNAME: "email", - dyson_parent.CONF_PASSWORD: "password", - dyson_parent.CONF_LANGUAGE: "GB", - dyson_parent.CONF_DEVICES: [ + DYSON_DOMAIN: { + CONF_USERNAME: "email", + CONF_PASSWORD: "password", + CONF_LANGUAGE: "GB", + CONF_DEVICES: [ {"device_id": "XX-XXXXX-XX", "device_ip": "192.168.0.1"}, {"device_id": "YY-YYYYY-YY", "device_ip": "192.168.0.2"}, ], @@ -89,15 +105,6 @@ def _get_dyson_purehotcool_device(): return device -def _get_device_with_no_state(): - """Return a device with no state.""" - device = Mock(spec=DysonPureHotCoolLink) - load_mock_device(device) - device.state = None - device.environmental_state = None - return device - - def _get_device_off(): """Return a device with state off.""" device = Mock(spec=DysonPureHotCoolLink) @@ -105,22 +112,6 @@ def _get_device_off(): return device -def _get_device_focus(): - """Return a device with fan state of focus mode.""" - device = Mock(spec=DysonPureHotCoolLink) - load_mock_device(device) - device.state.focus_mode = FocusMode.FOCUS_ON.value - return device - - -def _get_device_diffuse(): - """Return a device with fan state of diffuse mode.""" - device = Mock(spec=DysonPureHotCoolLink) - load_mock_device(device) - device.state.focus_mode = FocusMode.FOCUS_OFF.value - return device - - def _get_device_cool(): """Return a device with state of cooling.""" device = Mock(spec=DysonPureHotCoolLink) @@ -132,15 +123,6 @@ def _get_device_cool(): return device -def _get_device_heat_off(): - """Return a device with state of heat reached target.""" - device = Mock(spec=DysonPureHotCoolLink) - load_mock_device(device) - device.state.heat_mode = HeatMode.HEAT_ON.value - device.state.heat_state = HeatState.HEAT_STATE_OFF.value - return device - - def _get_device_heat_on(): """Return a device with state of heating.""" device = Mock(spec=DysonPureHotCoolLink) @@ -154,236 +136,259 @@ def _get_device_heat_on(): return device -class DysonTest(unittest.TestCase): - """Dyson Climate component test class.""" +@pytest.fixture(autouse=True) +def patch_platforms_fixture(): + """Only set up the climate platform for the climate tests.""" + with patch("homeassistant.components.dyson.DYSON_PLATFORMS", new=[DOMAIN]): + yield - def setUp(self): # pylint: disable=invalid-name - """Set up things to be run when tests are started.""" - self.hass = get_test_home_assistant() - self.addCleanup(self.tear_down_cleanup) - def tear_down_cleanup(self): - """Stop everything that was started.""" - self.hass.stop() +@patch( + "homeassistant.components.dyson.DysonAccount.devices", + return_value=[_get_device_heat_on()], +) +@patch("homeassistant.components.dyson.DysonAccount.login", return_value=True) +async def test_pure_hot_cool_link_set_mode(mocked_login, mocked_devices, hass): + """Test set climate mode.""" + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) + await hass.async_block_till_done() - def test_setup_component_without_devices(self): - """Test setup component with no devices.""" - self.hass.data[dyson.DYSON_DEVICES] = [] - add_devices = MagicMock() - dyson.setup_platform(self.hass, None, add_devices) - add_devices.assert_not_called() + device = mocked_devices.return_value[0] - def test_setup_component_with_devices(self): - """Test setup component with valid devices.""" - devices = [ - _get_device_with_no_state(), - _get_device_off(), - _get_device_heat_on(), - ] - self.hass.data[dyson.DYSON_DEVICES] = devices - add_devices = MagicMock() - dyson.setup_platform(self.hass, None, add_devices, discovery_info={}) - assert add_devices.called + await hass.services.async_call( + DOMAIN, + SERVICE_SET_HVAC_MODE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_HVAC_MODE: HVAC_MODE_HEAT}, + True, + ) - def test_setup_component(self): - """Test setup component with devices.""" - device_fan = _get_device_heat_on() - device_non_fan = _get_device_off() + set_config = device.set_configuration + assert set_config.call_args == call(heat_mode=HeatMode.HEAT_ON) - def _add_device(devices): - assert len(devices) == 1 - assert devices[0].name == "Device_name" + await hass.services.async_call( + DOMAIN, + SERVICE_SET_HVAC_MODE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_HVAC_MODE: HVAC_MODE_COOL}, + True, + ) - self.hass.data[dyson.DYSON_DEVICES] = [device_fan, device_non_fan] - dyson.setup_platform(self.hass, None, _add_device) + set_config = device.set_configuration + assert set_config.call_args == call(heat_mode=HeatMode.HEAT_OFF) - def test_dyson_set_temperature(self): - """Test set climate temperature.""" - device = _get_device_heat_on() - device.temp_unit = TEMP_CELSIUS - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert not entity.should_poll - # Without target temp. - kwargs = {} - entity.set_temperature(**kwargs) - set_config = device.set_configuration - set_config.assert_not_called() +@patch( + "homeassistant.components.dyson.DysonAccount.devices", + return_value=[_get_device_heat_on()], +) +@patch("homeassistant.components.dyson.DysonAccount.login", return_value=True) +async def test_pure_hot_cool_link_set_fan(mocked_login, mocked_devices, hass): + """Test set climate fan.""" + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) + await hass.async_block_till_done() - kwargs = {ATTR_TEMPERATURE: 23} - entity.set_temperature(**kwargs) - set_config = device.set_configuration - set_config.assert_called_with( - heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(23) - ) + device = mocked_devices.return_value[0] + device.temp_unit = TEMP_CELSIUS - # Should clip the target temperature between 1 and 37 inclusive. - kwargs = {ATTR_TEMPERATURE: 50} - entity.set_temperature(**kwargs) - set_config = device.set_configuration - set_config.assert_called_with( - heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(37) - ) + await hass.services.async_call( + DOMAIN, + SERVICE_SET_FAN_MODE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_FAN_MODE: FAN_FOCUS}, + True, + ) - kwargs = {ATTR_TEMPERATURE: -5} - entity.set_temperature(**kwargs) - set_config = device.set_configuration - set_config.assert_called_with( - heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(1) - ) + set_config = device.set_configuration + assert set_config.call_args == call(focus_mode=FocusMode.FOCUS_ON) - def test_dyson_set_temperature_when_cooling_mode(self): - """Test set climate temperature when heating is off.""" - device = _get_device_cool() - device.temp_unit = TEMP_CELSIUS - entity = dyson.DysonPureHotCoolLinkEntity(device) - entity.schedule_update_ha_state = Mock() + await hass.services.async_call( + DOMAIN, + SERVICE_SET_FAN_MODE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_FAN_MODE: FAN_DIFFUSE}, + True, + ) - kwargs = {ATTR_TEMPERATURE: 23} - entity.set_temperature(**kwargs) - set_config = device.set_configuration - set_config.assert_called_with( - heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(23) - ) + set_config = device.set_configuration + assert set_config.call_args == call(focus_mode=FocusMode.FOCUS_OFF) - def test_dyson_set_fan_mode(self): - """Test set fan mode.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert not entity.should_poll - entity.set_fan_mode(dyson.FAN_FOCUS) - set_config = device.set_configuration - set_config.assert_called_with(focus_mode=FocusMode.FOCUS_ON) +@patch( + "homeassistant.components.dyson.DysonAccount.devices", + return_value=[_get_device_heat_on()], +) +@patch("homeassistant.components.dyson.DysonAccount.login", return_value=True) +async def test_pure_hot_cool_link_state(mocked_login, mocked_devices, hass): + """Test set climate temperature.""" + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) + await hass.async_block_till_done() - entity.set_fan_mode(dyson.FAN_DIFFUSE) - set_config = device.set_configuration - set_config.assert_called_with(focus_mode=FocusMode.FOCUS_OFF) + state = hass.states.get("climate.temp_name") + assert state.attributes[ATTR_SUPPORTED_FEATURES] == SUPPORT_FLAGS + assert state.attributes[ATTR_TEMPERATURE] == 23 + assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 289 - 273 + assert state.attributes[ATTR_CURRENT_HUMIDITY] == 53 + assert state.state == HVAC_MODE_HEAT + assert len(state.attributes[ATTR_HVAC_MODES]) == 2 + assert HVAC_MODE_HEAT in state.attributes[ATTR_HVAC_MODES] + assert HVAC_MODE_COOL in state.attributes[ATTR_HVAC_MODES] + assert len(state.attributes[ATTR_FAN_MODES]) == 2 + assert FAN_FOCUS in state.attributes[ATTR_FAN_MODES] + assert FAN_DIFFUSE in state.attributes[ATTR_FAN_MODES] - def test_dyson_fan_modes(self): - """Test get fan list.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert len(entity.fan_modes) == 2 - assert dyson.FAN_FOCUS in entity.fan_modes - assert dyson.FAN_DIFFUSE in entity.fan_modes + device = mocked_devices.return_value[0] + update_callback = device.add_message_listener.call_args[0][0] - def test_dyson_fan_mode_focus(self): - """Test fan focus mode.""" - device = _get_device_focus() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.fan_mode == dyson.FAN_FOCUS + device.state.focus_mode = FocusMode.FOCUS_ON.value + await hass.async_add_executor_job(update_callback, MockDysonState()) + await hass.async_block_till_done() - def test_dyson_fan_mode_diffuse(self): - """Test fan diffuse mode.""" - device = _get_device_diffuse() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.fan_mode == dyson.FAN_DIFFUSE + state = hass.states.get("climate.temp_name") + assert state.attributes[ATTR_FAN_MODE] == FAN_FOCUS - def test_dyson_set_hvac_mode(self): - """Test set operation mode.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert not entity.should_poll + device.state.focus_mode = FocusMode.FOCUS_OFF.value + await hass.async_add_executor_job(update_callback, MockDysonState()) + await hass.async_block_till_done() - entity.set_hvac_mode(dyson.HVAC_MODE_HEAT) - set_config = device.set_configuration - set_config.assert_called_with(heat_mode=HeatMode.HEAT_ON) + state = hass.states.get("climate.temp_name") + assert state.attributes[ATTR_FAN_MODE] == FAN_DIFFUSE - entity.set_hvac_mode(dyson.HVAC_MODE_COOL) - set_config = device.set_configuration - set_config.assert_called_with(heat_mode=HeatMode.HEAT_OFF) + device.state.heat_mode = HeatMode.HEAT_ON.value + device.state.heat_state = HeatState.HEAT_STATE_OFF.value + await hass.async_add_executor_job(update_callback, MockDysonState()) + await hass.async_block_till_done() - def test_dyson_operation_list(self): - """Test get operation list.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert len(entity.hvac_modes) == 2 - assert dyson.HVAC_MODE_HEAT in entity.hvac_modes - assert dyson.HVAC_MODE_COOL in entity.hvac_modes + state = hass.states.get("climate.temp_name") + assert state.state == HVAC_MODE_HEAT + assert state.attributes[ATTR_HVAC_ACTION] == CURRENT_HVAC_IDLE - def test_dyson_heat_off(self): - """Test turn off heat.""" - device = _get_device_heat_off() - entity = dyson.DysonPureHotCoolLinkEntity(device) - entity.set_hvac_mode(dyson.HVAC_MODE_COOL) - set_config = device.set_configuration - set_config.assert_called_with(heat_mode=HeatMode.HEAT_OFF) + device.environmental_state.humidity = 0 + await hass.async_add_executor_job(update_callback, MockDysonState()) + await hass.async_block_till_done() - def test_dyson_heat_on(self): - """Test turn on heat.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - entity.set_hvac_mode(dyson.HVAC_MODE_HEAT) - set_config = device.set_configuration - set_config.assert_called_with(heat_mode=HeatMode.HEAT_ON) + state = hass.states.get("climate.temp_name") + assert state.attributes.get(ATTR_CURRENT_HUMIDITY) is None - def test_dyson_heat_value_on(self): - """Test get heat value on.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.hvac_mode == dyson.HVAC_MODE_HEAT + device.environmental_state = None + await hass.async_add_executor_job(update_callback, MockDysonState()) + await hass.async_block_till_done() - def test_dyson_heat_value_off(self): - """Test get heat value off.""" - device = _get_device_cool() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.hvac_mode == dyson.HVAC_MODE_COOL + state = hass.states.get("climate.temp_name") + assert state.attributes.get(ATTR_CURRENT_HUMIDITY) is None - def test_dyson_heat_value_idle(self): - """Test get heat value idle.""" - device = _get_device_heat_off() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.hvac_mode == dyson.HVAC_MODE_HEAT - assert entity.hvac_action == dyson.CURRENT_HVAC_IDLE + device.state.heat_mode = HeatMode.HEAT_OFF.value + device.state.heat_state = HeatState.HEAT_STATE_OFF.value + await hass.async_add_executor_job(update_callback, MockDysonState()) + await hass.async_block_till_done() - def test_on_message(self): - """Test when message is received.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - entity.schedule_update_ha_state = Mock() - entity.on_message(MockDysonState()) - entity.schedule_update_ha_state.assert_called_with() + state = hass.states.get("climate.temp_name") + assert state.state == HVAC_MODE_COOL + assert state.attributes[ATTR_HVAC_ACTION] == CURRENT_HVAC_COOL - def test_general_properties(self): - """Test properties of entity.""" - device = _get_device_with_no_state() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.should_poll is False - assert entity.supported_features == dyson.SUPPORT_FLAGS - assert entity.temperature_unit == TEMP_CELSIUS - def test_property_current_humidity(self): - """Test properties of current humidity.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.current_humidity == 53 +@patch( + "homeassistant.components.dyson.DysonAccount.devices", + return_value=[], +) +@patch("homeassistant.components.dyson.DysonAccount.login", return_value=True) +async def test_setup_component_without_devices(mocked_login, mocked_devices, hass): + """Test setup component with no devices.""" + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) + await hass.async_block_till_done() - def test_property_current_humidity_with_invalid_env_state(self): - """Test properties of current humidity with invalid env state.""" - device = _get_device_off() - device.environmental_state.humidity = 0 - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.current_humidity is None + entity_ids = hass.states.async_entity_ids(DOMAIN) + assert not entity_ids - def test_property_current_humidity_without_env_state(self): - """Test properties of current humidity without env state.""" - device = _get_device_with_no_state() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.current_humidity is None - def test_property_current_temperature(self): - """Test properties of current temperature.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - # Result should be in celsius, hence then subtraction of 273. - assert entity.current_temperature == 289 - 273 +@patch( + "homeassistant.components.dyson.DysonAccount.devices", + return_value=[_get_device_heat_on()], +) +@patch("homeassistant.components.dyson.DysonAccount.login", return_value=True) +async def test_dyson_set_temperature(mocked_login, mocked_devices, hass): + """Test set climate temperature.""" + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) + await hass.async_block_till_done() - def test_property_target_temperature(self): - """Test properties of target temperature.""" - device = _get_device_heat_on() - entity = dyson.DysonPureHotCoolLinkEntity(device) - assert entity.target_temperature == 23 + device = mocked_devices.return_value[0] + device.temp_unit = TEMP_CELSIUS + + # Without correct target temp. + await hass.services.async_call( + DOMAIN, + SERVICE_SET_TEMPERATURE, + { + ATTR_ENTITY_ID: "climate.temp_name", + ATTR_TARGET_TEMP_HIGH: 25.0, + ATTR_TARGET_TEMP_LOW: 15.0, + }, + True, + ) + + set_config = device.set_configuration + assert set_config.call_count == 0 + + await hass.services.async_call( + DOMAIN, + SERVICE_SET_TEMPERATURE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_TEMPERATURE: 23}, + True, + ) + + set_config = device.set_configuration + assert set_config.call_args == call( + heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(23) + ) + + # Should clip the target temperature between 1 and 37 inclusive. + await hass.services.async_call( + DOMAIN, + SERVICE_SET_TEMPERATURE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_TEMPERATURE: 50}, + True, + ) + + set_config = device.set_configuration + assert set_config.call_args == call( + heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(37) + ) + + await hass.services.async_call( + DOMAIN, + SERVICE_SET_TEMPERATURE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_TEMPERATURE: -5}, + True, + ) + + set_config = device.set_configuration + assert set_config.call_args == call( + heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(1) + ) + + +@patch( + "homeassistant.components.dyson.DysonAccount.devices", + return_value=[_get_device_cool()], +) +@patch("homeassistant.components.dyson.DysonAccount.login", return_value=True) +async def test_dyson_set_temperature_when_cooling_mode( + mocked_login, mocked_devices, hass +): + """Test set climate temperature when heating is off.""" + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) + await hass.async_block_till_done() + + device = mocked_devices.return_value[0] + device.temp_unit = TEMP_CELSIUS + + await hass.services.async_call( + DOMAIN, + SERVICE_SET_TEMPERATURE, + {ATTR_ENTITY_ID: "climate.temp_name", ATTR_TEMPERATURE: 23}, + True, + ) + + set_config = device.set_configuration + assert set_config.call_args == call( + heat_mode=HeatMode.HEAT_ON, heat_target=HeatTarget.celsius(23) + ) @patch( @@ -395,10 +400,10 @@ async def test_setup_component_with_parent_discovery( mocked_login, mocked_devices, hass ): """Test setup_component using discovery.""" - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() - entity_ids = hass.states.async_entity_ids("climate") + entity_ids = hass.states.async_entity_ids(DOMAIN) assert len(entity_ids) == 2 @@ -410,10 +415,10 @@ async def test_setup_component_with_parent_discovery( async def test_purehotcool_component_setup_only_once(devices, login, hass): """Test if entities are created only once.""" config = _get_config() - await async_setup_component(hass, dyson_parent.DOMAIN, config) + await async_setup_component(hass, DYSON_DOMAIN, config) await hass.async_block_till_done() - entity_ids = hass.states.async_entity_ids("climate") + entity_ids = hass.states.async_entity_ids(DOMAIN) assert len(entity_ids) == 1 state = hass.states.get(entity_ids[0]) assert state.name == "Living room" @@ -427,10 +432,10 @@ async def test_purehotcool_component_setup_only_once(devices, login, hass): async def test_purehotcoollink_component_setup_only_once(devices, login, hass): """Test if entities are created only once.""" config = _get_config() - await async_setup_component(hass, dyson_parent.DOMAIN, config) + await async_setup_component(hass, DYSON_DOMAIN, config) await hass.async_block_till_done() - entity_ids = hass.states.async_entity_ids("climate") + entity_ids = hass.states.async_entity_ids(DOMAIN) assert len(entity_ids) == 1 state = hass.states.get(entity_ids[0]) assert state.name == "Temp Name" @@ -444,7 +449,7 @@ async def test_purehotcoollink_component_setup_only_once(devices, login, hass): async def test_purehotcool_update_state(devices, login, hass): """Test state update.""" device = devices.return_value[0] - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() event = { "msg": "CURRENT-STATE", @@ -476,12 +481,9 @@ async def test_purehotcool_update_state(devices, login, hass): }, } device.state = DysonPureHotCoolV2State(json.dumps(event)) + update_callback = device.add_message_listener.call_args[0][0] - for call in device.add_message_listener.call_args_list: - callback = call[0][0] - if type(callback.__self__) == dyson.DysonPureHotCoolEntity: - callback(device.state) - + await hass.async_add_executor_job(update_callback, device.state) await hass.async_block_till_done() state = hass.states.get("climate.living_room") attributes = state.attributes @@ -500,7 +502,7 @@ async def test_purehotcool_empty_env_attributes(devices, login, hass): device = devices.return_value[0] device.environmental_state.temperature = 0 device.environmental_state.humidity = None - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() state = hass.states.get("climate.living_room") @@ -518,7 +520,7 @@ async def test_purehotcool_fan_state_off(devices, login, hass): """Test device fan state off.""" device = devices.return_value[0] device.state.fan_state = FanState.FAN_OFF.value - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() state = hass.states.get("climate.living_room") @@ -536,7 +538,7 @@ async def test_purehotcool_hvac_action_cool(devices, login, hass): """Test device HVAC action cool.""" device = devices.return_value[0] device.state.fan_power = FanPower.POWER_ON.value - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() state = hass.states.get("climate.living_room") @@ -555,7 +557,7 @@ async def test_purehotcool_hvac_action_idle(devices, login, hass): device = devices.return_value[0] device.state.fan_power = FanPower.POWER_ON.value device.state.heat_mode = HeatMode.HEAT_ON.value - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() state = hass.states.get("climate.living_room") @@ -572,12 +574,12 @@ async def test_purehotcool_hvac_action_idle(devices, login, hass): async def test_purehotcool_set_temperature(devices, login, hass): """Test set temperature.""" device = devices.return_value[0] - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() state = hass.states.get("climate.living_room") attributes = state.attributes - min_temp = attributes["min_temp"] - max_temp = attributes["max_temp"] + min_temp = attributes[ATTR_MIN_TEMP] + max_temp = attributes[ATTR_MAX_TEMP] await hass.services.async_call( DOMAIN, @@ -623,7 +625,7 @@ async def test_purehotcool_set_temperature(devices, login, hass): async def test_purehotcool_set_fan_mode(devices, login, hass): """Test set fan mode.""" device = devices.return_value[0] - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() await hass.services.async_call( @@ -687,7 +689,7 @@ async def test_purehotcool_set_fan_mode(devices, login, hass): async def test_purehotcool_set_hvac_mode(devices, login, hass): """Test set HVAC mode.""" device = devices.return_value[0] - await async_setup_component(hass, dyson_parent.DOMAIN, _get_config()) + await async_setup_component(hass, DYSON_DOMAIN, _get_config()) await hass.async_block_till_done() await hass.services.async_call(