async def test_state(hass: HomeAssistant, device: DysonFanDevice):
state = hass.states.get(ENTITY_ID)
assert state.state == STATE_ON
attributes = state.attributes
assert attributes[ATTR_SPEED] == SPEED_MEDIUM
assert attributes[ATTR_SPEED_LIST] == SPEED_LIST_HA
assert attributes[ATTR_DYSON_SPEED] == 5
assert attributes[ATTR_DYSON_SPEED_LIST] == SPEED_LIST_DYSON
assert attributes[ATTR_AUTO_MODE] is False
assert attributes[ATTR_OSCILLATING] is True
assert attributes[ATTR_SUPPORTED_FEATURES] == SUPPORTED_FEATURES
er = await entity_registry.async_get_registry(hass)
assert er.async_get(ENTITY_ID).unique_id == SERIAL
device.is_on = False
device.speed = None
device.auto_mode = True
device.oscillation = False
await update_device(hass, device, MessageType.STATE)
state = hass.states.get(ENTITY_ID)
assert state.state == STATE_OFF
attributes = state.attributes
assert attributes[ATTR_SPEED] is None
assert attributes[ATTR_DYSON_SPEED] is None
assert attributes[ATTR_AUTO_MODE] is True
assert attributes[ATTR_OSCILLATING] is False
async def test_pure_cool_combined(hass: HomeAssistant, device: DysonFanDevice):
assert hass.states.get(f"sensor.{NAME}_carbon_filter_life").state == "30"
assert hass.states.get(f"sensor.{NAME}_hepa_filter_life").state == "50"
device.carbon_filter_life = 20
device.hepa_filter_life = 30
await update_device(hass, device, MessageType.STATE)
assert hass.states.get(f"sensor.{NAME}_carbon_filter_life").state == "20"
assert hass.states.get(f"sensor.{NAME}_hepa_filter_life").state == "30"
async def test_pure_cool_seperated(hass: HomeAssistant,
device: DysonFanDevice):
"""Test Pure Cool carbon and HEPA filter sensors."""
assert hass.states.get(f"sensor.{NAME}_carbon_filter_life").state == "30"
assert hass.states.get(f"sensor.{NAME}_hepa_filter_life").state == "50"
device.carbon_filter_life = 20
device.hepa_filter_life = 30
await update_device(hass, device, MessageType.STATE)
assert hass.states.get(f"sensor.{NAME}_carbon_filter_life").state == "20"
assert hass.states.get(f"sensor.{NAME}_hepa_filter_life").state == "30"
def test_command_invalid_data(
mqtt_client: MockedMQTT,
command: str,
command_args: list,
):
"""Test commands with invalid data."""
device = DysonFanDevice(SERIAL, CREDENTIAL, DEVICE_TYPE)
device.connect(HOST)
func = getattr(device, command)
with pytest.raises(ValueError):
func(*command_args)
assert len(mqtt_client.commands) == 0
def assert_command(
device: DysonFanDevice,
mqtt_client: MockedMQTT,
command: str,
command_args: list,
msg_data: dict,
):
"""Test commands of fan device."""
device.connect(HOST)
func = getattr(device, command)
func(*command_args)
assert len(mqtt_client.commands) == 1
payload = mqtt_client.commands[0]
assert payload["msg"] == "STATE-SET"
assert payload["data"] == msg_data
async def test_fan(hass: HomeAssistant, device: DysonFanDevice):
assert hass.states.get(f"sensor.{NAME}_humidity").state == "50"
state = hass.states.get(f"sensor.{NAME}_temperature")
assert state.state == "6.9"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TEMP_CELSIUS
device.humidity = 30
device.temperature = 300
hass.config.units = IMPERIAL_SYSTEM
await update_device(hass, device, MessageType.ENVIRONMENTAL)
assert hass.states.get(f"sensor.{NAME}_humidity").state == "30"
state = hass.states.get(f"sensor.{NAME}_temperature")
assert state.state == "80.3"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TEMP_FAHRENHEIT
device.temperature = ENVIRONMENTAL_OFF
await update_device(hass, device, MessageType.ENVIRONMENTAL)
assert hass.states.get(f"sensor.{NAME}_temperature").state == STATE_OFF
def test_environmental_callback(mqtt_client: MockedMQTT):
"""Test callback on environmental data."""
device = DysonFanDevice(SERIAL, CREDENTIAL, DEVICE_TYPE)
callback = MagicMock()
device.add_message_listener(callback)
device.connect(HOST)
callback.assert_called_with(MessageType.ENVIRONMENTAL)
callback.reset_mock()
device.request_environmental_data()
callback.assert_called_once_with(MessageType.ENVIRONMENTAL)
callback.reset_mock()
def test_connect_environmental_timeout(mqtt_client: MockedMQTT):
"""Test environmental data timed out during connection."""
original_publish = mqtt_client.publish
def _publish(topic: str, payload: str) -> None:
if (json.loads(payload)["msg"] ==
"REQUEST-PRODUCT-ENVIRONMENT-CURRENT-SENSOR-DATA"):
return # Do not publish environmental data request
original_publish(topic, payload)
mqtt_client.publish = _publish
device = DysonFanDevice(SERIAL, CREDENTIAL, DEVICE_TYPE)
with pytest.raises(DysonConnectTimeout):
device.connect(HOST)
assert device._status_data_available.is_set()
assert device.is_connected is False
assert mqtt_client.connected is False
assert mqtt_client.loop_started is False
def test_not_connected(mqtt_client: MockedMQTT):
"""Test making operations without connection."""
device = DysonFanDevice(SERIAL, CREDENTIAL, DEVICE_TYPE)
with pytest.raises(DysonNotConnected):
device.enable_night_mode()
with pytest.raises(DysonNotConnected):
device.request_environmental_data()
async def test_state(hass: HomeAssistant, device: DysonFanDevice):
"""Test entity state and attributes."""
state = hass.states.get(ENTITY_ID)
assert state.state == STATE_ON
attributes = state.attributes
assert attributes[ATTR_PERCENTAGE] == 50
assert attributes[ATTR_PERCENTAGE_STEP] == 10
assert attributes[ATTR_OSCILLATING] is True
assert attributes[ATTR_SUPPORTED_FEATURES] == SUPPORTED_FEATURES
er = await entity_registry.async_get_registry(hass)
assert er.async_get(ENTITY_ID).unique_id == SERIAL
device.is_on = False
device.speed = None
device.oscillation = False
await update_device(hass, device, MessageType.STATE)
state = hass.states.get(ENTITY_ID)
assert state.state == STATE_OFF
attributes = state.attributes
assert attributes[ATTR_PERCENTAGE] is None
assert attributes[ATTR_OSCILLATING] is False
def test_command(
mqtt_client: MockedMQTT,
command: str,
command_args: list,
msg_data: dict,
):
"""Test commands of fan device."""
assert_command(
DysonFanDevice(SERIAL, CREDENTIAL, DEVICE_TYPE),
mqtt_client,
command,
command_args,
msg_data,
)
def test_properties(mqtt_client: MockedMQTT):
"""Test properties of fan device."""
device = DysonFanDevice(SERIAL, CREDENTIAL, DEVICE_TYPE)
device.connect(HOST)
# Status
assert device.device_type == DEVICE_TYPE
assert device.fan_state is False
assert device.speed == 1
assert device.night_mode is False
assert device.continuous_monitoring is False
assert device.error_code == "NONE"
assert device.warning_code == "NONE"
# Environmental
assert device.humidity == ENVIRONMENTAL_OFF
assert device.temperature == ENVIRONMENTAL_OFF
assert device.sleep_timer == ENVIRONMENTAL_OFF
error_code = "0X03" # Just mock data
warning_code = "0X01" # Just mock data
new_status = {
"mode-reason": "LAPP",
"state-reason": "MODE",
"product-state": {
"fnst": ["OFF", "FAN"],
"fnsp": ["0001", "AUTO"],
"rhtm": ["OFF", "ON"],
"ercd": ["NONE", error_code],
"nmod": ["OFF", "ON"],
"wacd": ["NONE", warning_code],
},
"scheduler": {
"srsc": "8773",
"dstv": "0000",
"tzid": "0001"
},
}
mqtt_client.state_change(new_status)
assert device.fan_state is True
assert device.speed is None
assert device.night_mode is True
assert device.continuous_monitoring is True
assert device.error_code == error_code
assert device.warning_code == warning_code
mqtt_client._environmental_data = {
"data": {
"tact": "2903",
"hact": "0030",
"sltm": "0003",
}
}
device.request_environmental_data()
assert device.humidity == 30
assert device.temperature == 290.3
assert device.sleep_timer == 3
async def test_360_eye(hass: HomeAssistant, device: DysonFanDevice):
assert hass.states.get(f"sensor.{NAME}_battery_level").state == "80"
device.battery_level = 40
await update_device(hass, device, MessageType.STATE)
assert hass.states.get(f"sensor.{NAME}_battery_level").state == "40"
async def test_pure_cool_link(hass: HomeAssistant, device: DysonFanDevice):
assert hass.states.get(f"sensor.{NAME}_filter_life").state == "200"
device.filter_life = 100
await update_device(hass, device, MessageType.STATE)
assert hass.states.get(f"sensor.{NAME}_filter_life").state == "100"
async def test_pure_cool_combined(hass: HomeAssistant, device: DysonFanDevice):
"""Test Pure Cool combined filter sensor."""
assert hass.states.get(f"sensor.{NAME}_filter_life").state == "50"
device.hepa_filter_life = 30
await update_device(hass, device, MessageType.STATE)
assert hass.states.get(f"sensor.{NAME}_filter_life").state == "30"
