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:
1 parent
4222f7562b
commit
08fe7c3ece
223 files changed
+6747
-7237
No files matched your search
@@ -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]
|
||||
@@ -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
|
||||
@@ -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
|
||||
Reference in new issue
Block a user