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))
vacuum.turn_off(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.stop(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(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))
vacuum.turn_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.toggle(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
# Non supported methods:
vacuum.start_pause(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.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))
vacuum.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))
vacuum.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))
vacuum.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)
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))
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(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))
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass))
vacuum.turn_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.toggle(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.stop(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(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))
vacuum.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))
vacuum.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))
vacuum.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))
vacuum.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)
vacuum.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)
vacuum.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)
vacuum.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)
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100)
self.assertNotEqual(STATE_DOCKED, state.state)
vacuum.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)
vacuum.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))
vacuum.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)
def test_methods(self):
"""Test if methods call the services as expected."""
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_ON)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC)
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
self.hass.block_till_done()
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()
assert vacuum.is_on(self.hass)
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_OFF)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass)
common.turn_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.toggle(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.stop(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
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)
assert "I'm over here" in state.attributes.get(ATTR_STATUS)
common.return_to_base(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "Returning home" in state.attributes.get(ATTR_STATUS)
common.set_fan_speed(self.hass, FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
assert FAN_SPEEDS[-1] == state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "spot" in state.attributes.get(ATTR_STATUS)
assert STATE_ON == state.state
common.start(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
assert STATE_CLEANING == state.state
common.pause(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
assert STATE_PAUSED == state.state
common.stop(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
assert STATE_IDLE == state.state
state = self.hass.states.get(ENTITY_VACUUM_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)
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)
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)
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()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.turn_off(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.stop(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_OFF)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.turn_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.toggle(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
# Non supported methods:
common.start_pause(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.locate(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_STATUS) is None
common.return_to_base(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_STATUS) is None
common.set_fan_speed(self.hass, FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
assert FAN_SPEEDS[-1] != \
state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_BASIC)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
assert "spot" not in state.attributes.get(ATTR_STATUS)
assert STATE_OFF == state.state
# VacuumDevice should not support start and pause methods.
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_ON)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_OFF)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
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)
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)
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)
assert STATE_CLEANING != state.state
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))
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(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))
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(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))
common.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(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))
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(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))
common.stop(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(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))
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))
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))
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))
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)
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)
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)
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)
state = self.hass.states.get(ENTITY_VACUUM_STATE)
self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100)
self.assertNotEqual(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)
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))
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)
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))
common.turn_off(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(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))
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(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))
common.toggle(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(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))
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))
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))
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))
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)
# 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))
common.pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(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))
common.start(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(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)
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)
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)
def test_unsupported_methods(self):
"""Test service calls for unsupported vacuums."""
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_ON)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.turn_off(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.stop(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_OFF)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.turn_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.toggle(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
# Non supported methods:
common.start_pause(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)
common.locate(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_STATUS) is None
common.return_to_base(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_STATUS) is None
common.set_fan_speed(self.hass,
FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
assert FAN_SPEEDS[-1] != state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_BASIC)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
assert "spot" not in state.attributes.get(ATTR_STATUS)
assert STATE_OFF == state.state
# VacuumDevice should not support start and pause methods.
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_ON)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.states.set(ENTITY_VACUUM_COMPLETE, STATE_OFF)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
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)
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)
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)
assert STATE_CLEANING != state.state
def test_methods(self):
"""Test if methods call the services as expected."""
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_ON)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC)
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
self.hass.block_till_done()
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()
assert vacuum.is_on(self.hass)
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_OFF)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass)
common.turn_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.toggle(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
common.stop(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
assert not vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
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)
assert "I'm over here" in state.attributes.get(ATTR_STATUS)
common.return_to_base(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "Returning home" in state.attributes.get(ATTR_STATUS)
common.set_fan_speed(self.hass,
FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
assert FAN_SPEEDS[-1] == state.attributes.get(ATTR_FAN_SPEED)
common.clean_spot(self.hass, entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "spot" in state.attributes.get(ATTR_STATUS)
assert STATE_ON == state.state
common.start(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
assert STATE_CLEANING == state.state
common.pause(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
assert STATE_PAUSED == state.state
common.stop(self.hass, ENTITY_VACUUM_STATE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_STATE)
assert STATE_IDLE == state.state
state = self.hass.states.get(ENTITY_VACUUM_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)
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)
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)
assert STATE_CLEANING == state.state
async def test_unsupported_methods(hass):
"""Test service calls for unsupported vacuums."""
hass.states.async_set(ENTITY_VACUUM_NONE, STATE_ON)
await hass.async_block_till_done()
assert vacuum.is_on(hass, ENTITY_VACUUM_NONE)
await common.async_turn_off(hass, ENTITY_VACUUM_NONE)
assert vacuum.is_on(hass, ENTITY_VACUUM_NONE)
await common.async_stop(hass, ENTITY_VACUUM_NONE)
assert vacuum.is_on(hass, ENTITY_VACUUM_NONE)
hass.states.async_set(ENTITY_VACUUM_NONE, STATE_OFF)
await hass.async_block_till_done()
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
await common.async_turn_on(hass, ENTITY_VACUUM_NONE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
await common.async_toggle(hass, ENTITY_VACUUM_NONE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
# Non supported methods:
await common.async_start_pause(hass, ENTITY_VACUUM_NONE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_NONE)
await common.async_locate(hass, ENTITY_VACUUM_NONE)
state = hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_STATUS) is None
await common.async_return_to_base(hass, ENTITY_VACUUM_NONE)
state = hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_STATUS) is None
await common.async_set_fan_speed(hass,
FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_NONE)
state = hass.states.get(ENTITY_VACUUM_NONE)
assert state.attributes.get(ATTR_FAN_SPEED) != FAN_SPEEDS[-1]
await common.async_clean_spot(hass, entity_id=ENTITY_VACUUM_BASIC)
state = hass.states.get(ENTITY_VACUUM_BASIC)
assert "spot" not in state.attributes.get(ATTR_STATUS)
assert state.state == STATE_OFF
# VacuumEntity should not support start and pause methods.
hass.states.async_set(ENTITY_VACUUM_COMPLETE, STATE_ON)
await hass.async_block_till_done()
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_pause(hass, ENTITY_VACUUM_COMPLETE)
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
hass.states.async_set(ENTITY_VACUUM_COMPLETE, STATE_OFF)
await hass.async_block_till_done()
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_start(hass, ENTITY_VACUUM_COMPLETE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
# StateVacuumEntity does not support on/off
await common.async_turn_on(hass, entity_id=ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state != STATE_CLEANING
await common.async_turn_off(hass, entity_id=ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state != STATE_RETURNING
await common.async_toggle(hass, entity_id=ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state != STATE_CLEANING
async def test_methods(hass):
"""Test if methods call the services as expected."""
hass.states.async_set(ENTITY_VACUUM_BASIC, STATE_ON)
await hass.async_block_till_done()
assert vacuum.is_on(hass, ENTITY_VACUUM_BASIC)
hass.states.async_set(ENTITY_VACUUM_BASIC, STATE_OFF)
await hass.async_block_till_done()
assert not vacuum.is_on(hass, ENTITY_VACUUM_BASIC)
await common.async_turn_on(hass, ENTITY_VACUUM_COMPLETE)
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_turn_off(hass, ENTITY_VACUUM_COMPLETE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_toggle(hass, ENTITY_VACUUM_COMPLETE)
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_start_pause(hass, ENTITY_VACUUM_COMPLETE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_start_pause(hass, ENTITY_VACUUM_COMPLETE)
assert vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
await common.async_stop(hass, ENTITY_VACUUM_COMPLETE)
assert not vacuum.is_on(hass, ENTITY_VACUUM_COMPLETE)
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
assert state.attributes.get(ATTR_STATUS) != "Charging"
await common.async_locate(hass, ENTITY_VACUUM_COMPLETE)
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "I'm over here" in state.attributes.get(ATTR_STATUS)
await common.async_return_to_base(hass, ENTITY_VACUUM_COMPLETE)
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "Returning home" in state.attributes.get(ATTR_STATUS)
await common.async_set_fan_speed(hass,
FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_COMPLETE)
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
assert state.attributes.get(ATTR_FAN_SPEED) == FAN_SPEEDS[-1]
await common.async_clean_spot(hass, entity_id=ENTITY_VACUUM_COMPLETE)
state = hass.states.get(ENTITY_VACUUM_COMPLETE)
assert "spot" in state.attributes.get(ATTR_STATUS)
assert state.state == STATE_ON
await common.async_start(hass, ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state == STATE_CLEANING
await common.async_pause(hass, ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state == STATE_PAUSED
await common.async_stop(hass, ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state == STATE_IDLE
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.attributes.get(ATTR_BATTERY_LEVEL) < 100
assert state.state != STATE_DOCKED
await common.async_return_to_base(hass, ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state == STATE_RETURNING
async_fire_time_changed(hass, dt.utcnow() + timedelta(seconds=31))
await hass.async_block_till_done()
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state == STATE_DOCKED
await common.async_set_fan_speed(hass,
FAN_SPEEDS[-1],
entity_id=ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.attributes.get(ATTR_FAN_SPEED) == FAN_SPEEDS[-1]
await common.async_clean_spot(hass, entity_id=ENTITY_VACUUM_STATE)
state = hass.states.get(ENTITY_VACUUM_STATE)
assert state.state == STATE_CLEANING