Pytest tests (#17750)

* Convert core tests

* Convert component tests to use pytest assert

* Lint 🤷‍♂️

* Fix test

* Fix 3 typos in docs
This commit is contained in:
Paulus Schoutsen authored and GitHub committed 2018-10-24 12:10:05 +02:00
1 parent 4222f7562b
commit 08fe7c3ece
223 files changed
+6747 -7237

No files matched your search

+112 -112
View File
@@ -34,8 +34,8 @@ class TestVacuumDemo(unittest.TestCase):
def setUp(self): # pylint: disable=invalid-name
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
self.assertTrue(setup_component(
self.hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: 'demo'}}))
assert setup_component(
self.hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: 'demo'}})
def tearDown(self): # pylint: disable=invalid-name
"""Stop down everything that was started."""
@@ -44,243 +44,243 @@ class TestVacuumDemo(unittest.TestCase):
def test_supported_features(self):
"""Test vacuum supported features."""
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertEqual(2047, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual("Charging", state.attributes.get(ATTR_STATUS))
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual("medium", state.attributes.get(ATTR_FAN_SPEED))
self.assertListEqual(FAN_SPEEDS,
state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
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 = self.hass.states.get(ENTITY_VACUUM_MOST)
self.assertEqual(219, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual("Charging", state.attributes.get(ATTR_STATUS))
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
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 = self.hass.states.get(ENTITY_VACUUM_BASIC)
self.assertEqual(195, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual("Charging", state.attributes.get(ATTR_STATUS))
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
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 = self.hass.states.get(ENTITY_VACUUM_MINIMAL)
self.assertEqual(3, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual(None, state.attributes.get(ATTR_STATUS))
self.assertEqual(None, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
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 = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertEqual(0, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual(None, state.attributes.get(ATTR_STATUS))
self.assertEqual(None, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
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 = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(13436, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual(STATE_DOCKED, state.state)
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual("medium", state.attributes.get(ATTR_FAN_SPEED))
self.assertListEqual(FAN_SPEEDS,
state.attributes.get(ATTR_FAN_SPEED_LIST))
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()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC)
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC)
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_ON)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass))
assert vacuum.is_on(self.hass)
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass))
assert not vacuum.is_on(self.hass)
common.turn_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.toggle(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.stop(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100)
self.assertNotEqual("Charging", state.attributes.get(ATTR_STATUS))
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
assert "Charging" != state.attributes.get(ATTR_STATUS)
common.locate(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertIn("I'm over here", state.attributes.get(ATTR_STATUS))
assert "I'm over here" in state.attributes.get(ATTR_STATUS)
common.return_to_base(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertIn("Returning home", state.attributes.get(ATTR_STATUS))
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)
self.assertEqual(FAN_SPEEDS[-1], state.attributes.get(ATTR_FAN_SPEED))
assert FAN_SPEEDS[-1] == state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertIn("spot", state.attributes.get(ATTR_STATUS))
self.assertEqual(STATE_ON, state.state)
assert "spot" in state.attributes.get(ATTR_STATUS)
assert STATE_ON == state.state
common.start(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(STATE_CLEANING, state.state)
assert STATE_CLEANING == state.state
common.pause(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(STATE_PAUSED, state.state)
assert STATE_PAUSED == state.state
common.stop(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(STATE_IDLE, state.state)
assert STATE_IDLE == state.state
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100)
self.assertNotEqual(STATE_DOCKED, state.state)
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
assert STATE_DOCKED != state.state
common.return_to_base(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(STATE_RETURNING, state.state)
assert STATE_RETURNING == state.state
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)
self.assertEqual(FAN_SPEEDS[-1], state.attributes.get(ATTR_FAN_SPEED))
assert FAN_SPEEDS[-1] == state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(STATE_CLEANING, state.state)
assert STATE_CLEANING == state.state
def test_unsupported_methods(self):
"""Test service calls for unsupported vacuums."""
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_ON)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.turn_off(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.stop(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.turn_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.toggle(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
# Non supported methods:
common.start_pause(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.locate(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertIsNone(state.attributes.get(ATTR_STATUS))
assert state.attributes.get(ATTR_STATUS) is None
common.return_to_base(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertIsNone(state.attributes.get(ATTR_STATUS))
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)
self.assertNotEqual(FAN_SPEEDS[-1],
state.attributes.get(ATTR_FAN_SPEED))
assert FAN_SPEEDS[-1] != \
state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_BASIC)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
self.assertNotIn("spot", state.attributes.get(ATTR_STATUS))
self.assertEqual(STATE_OFF, state.state)
assert "spot" not in state.attributes.get(ATTR_STATUS)
assert STATE_OFF == state.state
# VacuumDevice should not support start and pause methods.
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_ON)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
assert not vacuum.is_on(self.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)
self.assertNotEqual(STATE_CLEANING, state.state)
assert STATE_CLEANING != state.state
common.turn_off(self.hass, entity_id=ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertNotEqual(STATE_RETURNING, state.state)
assert STATE_RETURNING != state.state
common.toggle(self.hass, entity_id=ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertNotEqual(STATE_CLEANING, state.state)
assert STATE_CLEANING != state.state
def test_services(self):
"""Test vacuum services."""
@@ -294,14 +294,14 @@ class TestVacuumDemo(unittest.TestCase):
params=params)
self.hass.block_till_done()
self.assertEqual(1, len(send_command_calls))
assert 1 == len(send_command_calls)
call = send_command_calls[-1]
self.assertEqual(DOMAIN, call.domain)
self.assertEqual(SERVICE_SEND_COMMAND, call.service)
self.assertEqual(ENTITY_VACUUM_BASIC, call.data[ATTR_ENTITY_ID])
self.assertEqual('test_command', call.data[ATTR_COMMAND])
self.assertEqual(params, call.data[ATTR_PARAMS])
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]
# Test set fan speed
set_fan_speed_calls = mock_service(
@@ -311,13 +311,13 @@ class TestVacuumDemo(unittest.TestCase):
self.hass, FAN_SPEEDS[0], entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertEqual(1, len(set_fan_speed_calls))
assert 1 == len(set_fan_speed_calls)
call = set_fan_speed_calls[-1]
self.assertEqual(DOMAIN, call.domain)
self.assertEqual(SERVICE_SET_FAN_SPEED, call.service)
self.assertEqual(ENTITY_VACUUM_COMPLETE, call.data[ATTR_ENTITY_ID])
self.assertEqual(FAN_SPEEDS[0], call.data[ATTR_FAN_SPEED])
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]
def test_set_fan_speed(self):
"""Test vacuum service to set the fan speed."""
@@ -336,20 +336,20 @@ class TestVacuumDemo(unittest.TestCase):
new_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
new_state_state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertEqual(old_state_basic, new_state_basic)
self.assertNotIn(ATTR_FAN_SPEED, new_state_basic.attributes)
assert old_state_basic == new_state_basic
assert ATTR_FAN_SPEED not in new_state_basic.attributes
self.assertNotEqual(old_state_complete, new_state_complete)
self.assertEqual(FAN_SPEEDS[1],
old_state_complete.attributes[ATTR_FAN_SPEED])
self.assertEqual(FAN_SPEEDS[0],
new_state_complete.attributes[ATTR_FAN_SPEED])
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]
self.assertNotEqual(old_state_state, new_state_state)
self.assertEqual(FAN_SPEEDS[1],
old_state_state.attributes[ATTR_FAN_SPEED])
self.assertEqual(FAN_SPEEDS[0],
new_state_state.attributes[ATTR_FAN_SPEED])
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]
def test_send_command(self):
"""Test vacuum service to send a command."""
@@ -366,8 +366,8 @@ class TestVacuumDemo(unittest.TestCase):
new_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
new_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertEqual(old_state_basic, new_state_basic)
self.assertNotEqual(old_state_complete, new_state_complete)
self.assertEqual(STATE_ON, new_state_complete.state)
self.assertEqual("Executing test_command({'p1': 3})",
new_state_complete.attributes[ATTR_STATUS])
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]
+23 -23
View File
@@ -100,13 +100,13 @@ class DysonTest(unittest.TestCase):
component.entity_id = "entity_id"
component.schedule_update_ha_state = mock.Mock()
component.on_message(mock.Mock())
self.assertTrue(component.schedule_update_ha_state.called)
assert component.schedule_update_ha_state.called
def test_should_poll(self):
"""Test polling is disable."""
device = _get_vacuum_device_cleaning()
component = Dyson360EyeDevice(device)
self.assertFalse(component.should_poll)
assert not component.should_poll
def test_properties(self):
"""Test component properties."""
@@ -116,45 +116,45 @@ class DysonTest(unittest.TestCase):
component = Dyson360EyeDevice(device1)
component2 = Dyson360EyeDevice(device2)
component3 = Dyson360EyeDevice(device3)
self.assertEqual(component.name, "Device_Vacuum")
self.assertTrue(component.is_on)
self.assertEqual(component.status, "Cleaning")
self.assertEqual(component2.status, "Unknown")
self.assertEqual(component.battery_level, 85)
self.assertEqual(component.fan_speed, "Quiet")
self.assertEqual(component.fan_speed_list, ["Quiet", "Max"])
self.assertEqual(component.device_state_attributes['position'],
'(0, 0)')
self.assertTrue(component.available)
self.assertEqual(component.supported_features, 255)
self.assertEqual(component.battery_icon, "mdi:battery-80")
self.assertEqual(component3.battery_icon, "mdi:battery-charging-40")
assert component.name == "Device_Vacuum"
assert component.is_on
assert component.status == "Cleaning"
assert component2.status == "Unknown"
assert component.battery_level == 85
assert component.fan_speed == "Quiet"
assert component.fan_speed_list == ["Quiet", "Max"]
assert component.device_state_attributes['position'] == \
'(0, 0)'
assert component.available
assert component.supported_features == 255
assert component.battery_icon == "mdi:battery-80"
assert component3.battery_icon == "mdi:battery-charging-40"
def test_turn_on(self):
"""Test turn on vacuum."""
device1 = _get_vacuum_device_charging()
component1 = Dyson360EyeDevice(device1)
component1.turn_on()
self.assertTrue(device1.start.called)
assert device1.start.called
device2 = _get_vacuum_device_pause()
component2 = Dyson360EyeDevice(device2)
component2.turn_on()
self.assertTrue(device2.resume.called)
assert device2.resume.called
def test_turn_off(self):
"""Test turn off vacuum."""
device1 = _get_vacuum_device_cleaning()
component1 = Dyson360EyeDevice(device1)
component1.turn_off()
self.assertTrue(device1.pause.called)
assert device1.pause.called
def test_stop(self):
"""Test stop vacuum."""
device1 = _get_vacuum_device_cleaning()
component1 = Dyson360EyeDevice(device1)
component1.stop()
self.assertTrue(device1.pause.called)
assert device1.pause.called
def test_set_fan_speed(self):
"""Test set fan speed vacuum."""
@@ -168,21 +168,21 @@ class DysonTest(unittest.TestCase):
device1 = _get_vacuum_device_charging()
component1 = Dyson360EyeDevice(device1)
component1.start_pause()
self.assertTrue(device1.start.called)
assert device1.start.called
device2 = _get_vacuum_device_pause()
component2 = Dyson360EyeDevice(device2)
component2.start_pause()
self.assertTrue(device2.resume.called)
assert device2.resume.called
device3 = _get_vacuum_device_cleaning()
component3 = Dyson360EyeDevice(device3)
component3.start_pause()
self.assertTrue(device3.pause.called)
assert device3.pause.called
def test_return_to_base(self):
"""Test return to base."""
device = _get_vacuum_device_pause()
component = Dyson360EyeDevice(device)
component.return_to_base()
self.assertTrue(device.abort.called)
assert device.abort.called
+37 -41
View File
@@ -51,25 +51,25 @@ class TestVacuumMQTT(unittest.TestCase):
def test_default_supported_features(self):
"""Test that the correct supported features."""
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
entity = self.hass.states.get('vacuum.mqtttest')
entity_features = \
entity.attributes.get(mqtt.CONF_SUPPORTED_FEATURES, 0)
self.assertListEqual(sorted(mqtt.services_to_strings(entity_features)),
sorted(['turn_on', 'turn_off', 'stop',
'return_home', 'battery', 'status',
'clean_spot']))
assert sorted(mqtt.services_to_strings(entity_features)) == \
sorted(['turn_on', 'turn_off', 'stop',
'return_home', 'battery', 'status',
'clean_spot'])
def test_all_commands(self):
"""Test simple commands to the vacuum."""
self.default_config[mqtt.CONF_SUPPORTED_FEATURES] = \
mqtt.services_to_strings(mqtt.ALL_SERVICES)
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
common.turn_on(self.hass, 'vacuum.mqtttest')
self.hass.block_till_done()
@@ -129,9 +129,9 @@ class TestVacuumMQTT(unittest.TestCase):
self.default_config[mqtt.CONF_SUPPORTED_FEATURES] = \
mqtt.services_to_strings(mqtt.ALL_SERVICES)
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
message = """{
"battery_level": 54,
@@ -143,13 +143,11 @@ class TestVacuumMQTT(unittest.TestCase):
fire_mqtt_message(self.hass, 'vacuum/state', message)
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(
'mdi:battery-50',
assert STATE_ON == state.state
assert 'mdi:battery-50' == \
state.attributes.get(ATTR_BATTERY_ICON)
)
self.assertEqual(54, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual('max', state.attributes.get(ATTR_FAN_SPEED))
assert 54 == state.attributes.get(ATTR_BATTERY_LEVEL)
assert 'max' == state.attributes.get(ATTR_FAN_SPEED)
message = """{
"battery_level": 61,
@@ -162,13 +160,11 @@ class TestVacuumMQTT(unittest.TestCase):
fire_mqtt_message(self.hass, 'vacuum/state', message)
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(
'mdi:battery-charging-60',
assert STATE_OFF == state.state
assert 'mdi:battery-charging-60' == \
state.attributes.get(ATTR_BATTERY_ICON)
)
self.assertEqual(61, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual('min', state.attributes.get(ATTR_FAN_SPEED))
assert 61 == state.attributes.get(ATTR_BATTERY_LEVEL)
assert 'min' == state.attributes.get(ATTR_FAN_SPEED)
def test_battery_template(self):
"""Test that you can use non-default templates for battery_level."""
@@ -179,31 +175,31 @@ class TestVacuumMQTT(unittest.TestCase):
mqtt.CONF_BATTERY_LEVEL_TEMPLATE: "{{ value }}"
})
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
fire_mqtt_message(self.hass, 'retroroomba/battery_level', '54')
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(54, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(state.attributes.get(ATTR_BATTERY_ICON),
'mdi:battery-50')
assert 54 == state.attributes.get(ATTR_BATTERY_LEVEL)
assert state.attributes.get(ATTR_BATTERY_ICON) == \
'mdi:battery-50'
def test_status_invalid_json(self):
"""Test to make sure nothing breaks if the vacuum sends bad JSON."""
self.default_config[mqtt.CONF_SUPPORTED_FEATURES] = \
mqtt.services_to_strings(mqtt.ALL_SERVICES)
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
fire_mqtt_message(self.hass, 'vacuum/state', '{"asdfasas false}')
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual("Stopped", state.attributes.get(ATTR_STATUS))
assert STATE_OFF == state.state
assert "Stopped" == state.attributes.get(ATTR_STATUS)
def test_default_availability_payload(self):
"""Test availability by default payload with defined topic."""
@@ -211,24 +207,24 @@ class TestVacuumMQTT(unittest.TestCase):
'availability_topic': 'availability-topic'
})
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_UNAVAILABLE, state.state)
assert STATE_UNAVAILABLE == state.state
fire_mqtt_message(self.hass, 'availability-topic', 'online')
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertNotEqual(STATE_UNAVAILABLE, state.state)
assert STATE_UNAVAILABLE != state.state
fire_mqtt_message(self.hass, 'availability-topic', 'offline')
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_UNAVAILABLE, state.state)
assert STATE_UNAVAILABLE == state.state
def test_custom_availability_payload(self):
"""Test availability by custom payload with defined topic."""
@@ -238,21 +234,21 @@ class TestVacuumMQTT(unittest.TestCase):
'payload_not_available': 'nogood'
})
self.assertTrue(setup_component(self.hass, vacuum.DOMAIN, {
assert setup_component(self.hass, vacuum.DOMAIN, {
vacuum.DOMAIN: self.default_config,
}))
})
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_UNAVAILABLE, state.state)
assert STATE_UNAVAILABLE == state.state
fire_mqtt_message(self.hass, 'availability-topic', 'good')
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertNotEqual(STATE_UNAVAILABLE, state.state)
assert STATE_UNAVAILABLE != state.state
fire_mqtt_message(self.hass, 'availability-topic', 'nogood')
self.hass.block_till_done()
state = self.hass.states.get('vacuum.mqtttest')
self.assertEqual(STATE_UNAVAILABLE, state.state)
assert STATE_UNAVAILABLE == state.state