From dd45e99302d93973f04514d02be3ee5d14bb9ea1 Mon Sep 17 00:00:00 2001 From: cdce8p <30130371+cdce8p@users.noreply.github.com> Date: Wed, 26 Sep 2018 18:02:05 +0200 Subject: [PATCH] Remove service helper (4) (#16892) * Update media_player * Update lock * Update notify * Update remote * Update scene * Update vacuum * Remove timer helpers * Removed unused legacy helpers --- homeassistant/components/lock/__init__.py | 36 ---- .../components/media_player/__init__.py | 162 ------------------ homeassistant/components/notify/__init__.py | 17 -- homeassistant/components/remote/__init__.py | 57 ------ homeassistant/components/scene/__init__.py | 12 -- homeassistant/components/timer/__init__.py | 60 ------- homeassistant/components/vacuum/__init__.py | 88 ---------- tests/components/lock/common.py | 45 +++++ tests/components/lock/test_demo.py | 8 +- tests/components/lock/test_mqtt.py | 6 +- tests/components/media_player/common.py | 150 ++++++++++++++++ tests/components/media_player/test_demo.py | 51 +++--- tests/components/notify/common.py | 24 +++ tests/components/notify/test_demo.py | 8 +- tests/components/remote/common.py | 55 ++++++ tests/components/remote/test_demo.py | 10 +- tests/components/remote/test_init.py | 8 +- tests/components/scene/common.py | 19 ++ tests/components/scene/test_init.py | 7 +- tests/components/scene/test_litejet.py | 5 +- tests/components/vacuum/common.py | 101 +++++++++++ tests/components/vacuum/test_demo.py | 70 ++++---- tests/components/vacuum/test_mqtt.py | 20 ++- 23 files changed, 499 insertions(+), 520 deletions(-) create mode 100644 tests/components/lock/common.py create mode 100644 tests/components/media_player/common.py create mode 100644 tests/components/notify/common.py create mode 100644 tests/components/remote/common.py create mode 100644 tests/components/scene/common.py create mode 100644 tests/components/vacuum/common.py diff --git a/homeassistant/components/lock/__init__.py b/homeassistant/components/lock/__init__.py index 3c4ff7cdedd..5218ea49c80 100644 --- a/homeassistant/components/lock/__init__.py +++ b/homeassistant/components/lock/__init__.py @@ -57,42 +57,6 @@ def is_locked(hass, entity_id=None): return hass.states.is_state(entity_id, STATE_LOCKED) -@bind_hass -def lock(hass, entity_id=None, code=None): - """Lock all or specified locks.""" - data = {} - if code: - data[ATTR_CODE] = code - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_LOCK, data) - - -@bind_hass -def unlock(hass, entity_id=None, code=None): - """Unlock all or specified locks.""" - data = {} - if code: - data[ATTR_CODE] = code - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_UNLOCK, data) - - -@bind_hass -def open_lock(hass, entity_id=None, code=None): - """Open all or specified locks.""" - data = {} - if code: - data[ATTR_CODE] = code - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_OPEN, data) - - @asyncio.coroutine def async_setup(hass, config): """Track states and offer events for locks.""" diff --git a/homeassistant/components/media_player/__init__.py b/homeassistant/components/media_player/__init__.py index 831009ed8bf..235ca8d5b2d 100644 --- a/homeassistant/components/media_player/__init__.py +++ b/homeassistant/components/media_player/__init__.py @@ -192,168 +192,6 @@ def is_on(hass, entity_id=None): for entity_id in entity_ids) -@bind_hass -def turn_on(hass, entity_id=None): - """Turn on specified media player or all.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_TURN_ON, data) - - -@bind_hass -def turn_off(hass, entity_id=None): - """Turn off specified media player or all.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_TURN_OFF, data) - - -@bind_hass -def toggle(hass, entity_id=None): - """Toggle specified media player or all.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_TOGGLE, data) - - -@bind_hass -def volume_up(hass, entity_id=None): - """Send the media player the command for volume up.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_VOLUME_UP, data) - - -@bind_hass -def volume_down(hass, entity_id=None): - """Send the media player the command for volume down.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_VOLUME_DOWN, data) - - -@bind_hass -def mute_volume(hass, mute, entity_id=None): - """Send the media player the command for muting the volume.""" - data = {ATTR_MEDIA_VOLUME_MUTED: mute} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_VOLUME_MUTE, data) - - -@bind_hass -def set_volume_level(hass, volume, entity_id=None): - """Send the media player the command for setting the volume.""" - data = {ATTR_MEDIA_VOLUME_LEVEL: volume} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_VOLUME_SET, data) - - -@bind_hass -def media_play_pause(hass, entity_id=None): - """Send the media player the command for play/pause.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_MEDIA_PLAY_PAUSE, data) - - -@bind_hass -def media_play(hass, entity_id=None): - """Send the media player the command for play/pause.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_MEDIA_PLAY, data) - - -@bind_hass -def media_pause(hass, entity_id=None): - """Send the media player the command for pause.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_MEDIA_PAUSE, data) - - -@bind_hass -def media_stop(hass, entity_id=None): - """Send the media player the stop command.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_MEDIA_STOP, data) - - -@bind_hass -def media_next_track(hass, entity_id=None): - """Send the media player the command for next track.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_MEDIA_NEXT_TRACK, data) - - -@bind_hass -def media_previous_track(hass, entity_id=None): - """Send the media player the command for prev track.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_MEDIA_PREVIOUS_TRACK, data) - - -@bind_hass -def media_seek(hass, position, entity_id=None): - """Send the media player the command to seek in current playing media.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - data[ATTR_MEDIA_SEEK_POSITION] = position - hass.services.call(DOMAIN, SERVICE_MEDIA_SEEK, data) - - -@bind_hass -def play_media(hass, media_type, media_id, entity_id=None, enqueue=None): - """Send the media player the command for playing media.""" - data = {ATTR_MEDIA_CONTENT_TYPE: media_type, - ATTR_MEDIA_CONTENT_ID: media_id} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - if enqueue: - data[ATTR_MEDIA_ENQUEUE] = enqueue - - hass.services.call(DOMAIN, SERVICE_PLAY_MEDIA, data) - - -@bind_hass -def select_source(hass, source, entity_id=None): - """Send the media player the command to select input source.""" - data = {ATTR_INPUT_SOURCE: source} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_SELECT_SOURCE, data) - - -@bind_hass -def select_sound_mode(hass, sound_mode, entity_id=None): - """Send the media player the command to select sound mode.""" - data = {ATTR_SOUND_MODE: sound_mode} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_SELECT_SOUND_MODE, data) - - -@bind_hass -def clear_playlist(hass, entity_id=None): - """Send the media player the command for clear playlist.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - hass.services.call(DOMAIN, SERVICE_CLEAR_PLAYLIST, data) - - -@bind_hass -def set_shuffle(hass, shuffle, entity_id=None): - """Send the media player the command to enable/disable shuffle mode.""" - data = {ATTR_MEDIA_SHUFFLE: shuffle} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_SHUFFLE_SET, data) - - WS_TYPE_MEDIA_PLAYER_THUMBNAIL = 'media_player_thumbnail' SCHEMA_WEBSOCKET_GET_THUMBNAIL = \ websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend({ diff --git a/homeassistant/components/notify/__init__.py b/homeassistant/components/notify/__init__.py index 4de35d3f850..0535d7caa6d 100644 --- a/homeassistant/components/notify/__init__.py +++ b/homeassistant/components/notify/__init__.py @@ -12,7 +12,6 @@ import voluptuous as vol from homeassistant.setup import async_prepare_setup_platform from homeassistant.exceptions import HomeAssistantError -from homeassistant.loader import bind_hass import homeassistant.helpers.config_validation as cv from homeassistant.const import CONF_NAME, CONF_PLATFORM from homeassistant.helpers import config_per_platform, discovery @@ -50,22 +49,6 @@ NOTIFY_SERVICE_SCHEMA = vol.Schema({ }) -@bind_hass -def send_message(hass, message, title=None, data=None): - """Send a notification message.""" - info = { - ATTR_MESSAGE: message - } - - if title is not None: - info[ATTR_TITLE] = title - - if data is not None: - info[ATTR_DATA] = data - - hass.services.call(DOMAIN, SERVICE_NOTIFY, info) - - @asyncio.coroutine def async_setup(hass, config): """Set up the notify services.""" diff --git a/homeassistant/components/remote/__init__.py b/homeassistant/components/remote/__init__.py index 11ecb20f7aa..3fd2a5d4c44 100644 --- a/homeassistant/components/remote/__init__.py +++ b/homeassistant/components/remote/__init__.py @@ -70,63 +70,6 @@ def is_on(hass, entity_id=None): return hass.states.is_state(entity_id, STATE_ON) -@bind_hass -def turn_on(hass, activity=None, entity_id=None): - """Turn all or specified remote on.""" - data = { - key: value for key, value in [ - (ATTR_ACTIVITY, activity), - (ATTR_ENTITY_ID, entity_id), - ] if value is not None} - hass.services.call(DOMAIN, SERVICE_TURN_ON, data) - - -@bind_hass -def turn_off(hass, activity=None, entity_id=None): - """Turn all or specified remote off.""" - data = {} - if activity: - data[ATTR_ACTIVITY] = activity - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_TURN_OFF, data) - - -@bind_hass -def toggle(hass, activity=None, entity_id=None): - """Toggle all or specified remote.""" - data = {} - if activity: - data[ATTR_ACTIVITY] = activity - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_TOGGLE, data) - - -@bind_hass -def send_command(hass, command, entity_id=None, device=None, - num_repeats=None, delay_secs=None): - """Send a command to a device.""" - data = {ATTR_COMMAND: command} - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - if device: - data[ATTR_DEVICE] = device - - if num_repeats: - data[ATTR_NUM_REPEATS] = num_repeats - - if delay_secs: - data[ATTR_DELAY_SECS] = delay_secs - - hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, data) - - @asyncio.coroutine def async_setup(hass, config): """Track states and offer events for remotes.""" diff --git a/homeassistant/components/scene/__init__.py b/homeassistant/components/scene/__init__.py index 8771a84c1d6..2bcb1c8e16d 100644 --- a/homeassistant/components/scene/__init__.py +++ b/homeassistant/components/scene/__init__.py @@ -12,7 +12,6 @@ import voluptuous as vol from homeassistant.const import ( ATTR_ENTITY_ID, CONF_PLATFORM, SERVICE_TURN_ON) -from homeassistant.loader import bind_hass import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import Entity from homeassistant.helpers.entity_component import EntityComponent @@ -61,17 +60,6 @@ SCENE_SERVICE_SCHEMA = vol.Schema({ }) -@bind_hass -def activate(hass, entity_id=None): - """Activate a scene.""" - data = {} - - if entity_id: - data[ATTR_ENTITY_ID] = entity_id - - hass.services.call(DOMAIN, SERVICE_TURN_ON, data) - - async def async_setup(hass, config): """Set up the scenes.""" logger = logging.getLogger(__name__) diff --git a/homeassistant/components/timer/__init__.py b/homeassistant/components/timer/__init__.py index 8406b3ff5ec..c29df9db858 100644 --- a/homeassistant/components/timer/__init__.py +++ b/homeassistant/components/timer/__init__.py @@ -12,12 +12,10 @@ import voluptuous as vol import homeassistant.util.dt as dt_util import homeassistant.helpers.config_validation as cv from homeassistant.const import (ATTR_ENTITY_ID, CONF_ICON, CONF_NAME) -from homeassistant.core import callback from homeassistant.helpers.entity import Entity from homeassistant.helpers.entity_component import EntityComponent from homeassistant.helpers.event import async_track_point_in_utc_time -from homeassistant.loader import bind_hass _LOGGER = logging.getLogger(__name__) @@ -63,64 +61,6 @@ CONFIG_SCHEMA = vol.Schema({ }, extra=vol.ALLOW_EXTRA) -@bind_hass -def start(hass, entity_id, duration): - """Start a timer.""" - hass.add_job(async_start, hass, entity_id, {ATTR_ENTITY_ID: entity_id, - ATTR_DURATION: duration}) - - -@callback -@bind_hass -def async_start(hass, entity_id, duration): - """Start a timer.""" - hass.async_add_job(hass.services.async_call( - DOMAIN, SERVICE_START, {ATTR_ENTITY_ID: entity_id, - ATTR_DURATION: duration})) - - -@bind_hass -def pause(hass, entity_id): - """Pause a timer.""" - hass.add_job(async_pause, hass, entity_id) - - -@callback -@bind_hass -def async_pause(hass, entity_id): - """Pause a timer.""" - hass.async_add_job(hass.services.async_call( - DOMAIN, SERVICE_PAUSE, {ATTR_ENTITY_ID: entity_id})) - - -@bind_hass -def cancel(hass, entity_id): - """Cancel a timer.""" - hass.add_job(async_cancel, hass, entity_id) - - -@callback -@bind_hass -def async_cancel(hass, entity_id): - """Cancel a timer.""" - hass.async_add_job(hass.services.async_call( - DOMAIN, SERVICE_CANCEL, {ATTR_ENTITY_ID: entity_id})) - - -@bind_hass -def finish(hass, entity_id): - """Finish a timer.""" - hass.add_job(async_cancel, hass, entity_id) - - -@callback -@bind_hass -def async_finish(hass, entity_id): - """Finish a timer.""" - hass.async_add_job(hass.services.async_call( - DOMAIN, SERVICE_FINISH, {ATTR_ENTITY_ID: entity_id})) - - async def async_setup(hass, config): """Set up a timer.""" component = EntityComponent(_LOGGER, DOMAIN, hass) diff --git a/homeassistant/components/vacuum/__init__.py b/homeassistant/components/vacuum/__init__.py index 1808737d281..7a1c3049152 100644 --- a/homeassistant/components/vacuum/__init__.py +++ b/homeassistant/components/vacuum/__init__.py @@ -94,94 +94,6 @@ def is_on(hass, entity_id=None): return hass.states.is_state(entity_id, STATE_ON) -@bind_hass -def turn_on(hass, entity_id=None): - """Turn all or specified vacuum on.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_TURN_ON, data) - - -@bind_hass -def turn_off(hass, entity_id=None): - """Turn all or specified vacuum off.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_TURN_OFF, data) - - -@bind_hass -def toggle(hass, entity_id=None): - """Toggle all or specified vacuum.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_TOGGLE, data) - - -@bind_hass -def locate(hass, entity_id=None): - """Locate all or specified vacuum.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_LOCATE, data) - - -@bind_hass -def clean_spot(hass, entity_id=None): - """Tell all or specified vacuum to perform a spot clean-up.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_CLEAN_SPOT, data) - - -@bind_hass -def return_to_base(hass, entity_id=None): - """Tell all or specified vacuum to return to base.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_RETURN_TO_BASE, data) - - -@bind_hass -def start_pause(hass, entity_id=None): - """Tell all or specified vacuum to start or pause the current task.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_START_PAUSE, data) - - -@bind_hass -def start(hass, entity_id=None): - """Tell all or specified vacuum to start or resume the current task.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_START, data) - - -@bind_hass -def pause(hass, entity_id=None): - """Tell all or the specified vacuum to pause the current task.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_PAUSE, data) - - -@bind_hass -def stop(hass, entity_id=None): - """Stop all or specified vacuum.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else None - hass.services.call(DOMAIN, SERVICE_STOP, data) - - -@bind_hass -def set_fan_speed(hass, fan_speed, entity_id=None): - """Set fan speed for all or specified vacuum.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - data[ATTR_FAN_SPEED] = fan_speed - hass.services.call(DOMAIN, SERVICE_SET_FAN_SPEED, data) - - -@bind_hass -def send_command(hass, command, params=None, entity_id=None): - """Send command to all or specified vacuum.""" - data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} - data[ATTR_COMMAND] = command - if params is not None: - data[ATTR_PARAMS] = params - hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, data) - - @asyncio.coroutine def async_setup(hass, config): """Set up the vacuum component.""" diff --git a/tests/components/lock/common.py b/tests/components/lock/common.py new file mode 100644 index 00000000000..2150b3cb894 --- /dev/null +++ b/tests/components/lock/common.py @@ -0,0 +1,45 @@ +"""Collection of helper methods. + +All containing methods are legacy helpers that should not be used by new +components. Instead call the service directly. +""" +from homeassistant.components.lock import DOMAIN +from homeassistant.const import ( + ATTR_CODE, ATTR_ENTITY_ID, SERVICE_LOCK, SERVICE_UNLOCK, SERVICE_OPEN) +from homeassistant.loader import bind_hass + + +@bind_hass +def lock(hass, entity_id=None, code=None): + """Lock all or specified locks.""" + data = {} + if code: + data[ATTR_CODE] = code + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_LOCK, data) + + +@bind_hass +def unlock(hass, entity_id=None, code=None): + """Unlock all or specified locks.""" + data = {} + if code: + data[ATTR_CODE] = code + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_UNLOCK, data) + + +@bind_hass +def open_lock(hass, entity_id=None, code=None): + """Open all or specified locks.""" + data = {} + if code: + data[ATTR_CODE] = code + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_OPEN, data) diff --git a/tests/components/lock/test_demo.py b/tests/components/lock/test_demo.py index 500cc7f9a6a..255e5307f7a 100644 --- a/tests/components/lock/test_demo.py +++ b/tests/components/lock/test_demo.py @@ -5,6 +5,8 @@ from homeassistant.setup import setup_component from homeassistant.components import lock from tests.common import get_test_home_assistant, mock_service +from tests.components.lock import common + FRONT = 'lock.front_door' KITCHEN = 'lock.kitchen_door' OPENABLE_LOCK = 'lock.openable_lock' @@ -36,14 +38,14 @@ class TestLockDemo(unittest.TestCase): def test_locking(self): """Test the locking of a lock.""" - lock.lock(self.hass, KITCHEN) + common.lock(self.hass, KITCHEN) self.hass.block_till_done() self.assertTrue(lock.is_locked(self.hass, KITCHEN)) def test_unlocking(self): """Test the unlocking of a lock.""" - lock.unlock(self.hass, FRONT) + common.unlock(self.hass, FRONT) self.hass.block_till_done() self.assertFalse(lock.is_locked(self.hass, FRONT)) @@ -51,6 +53,6 @@ class TestLockDemo(unittest.TestCase): def test_opening(self): """Test the opening of a lock.""" calls = mock_service(self.hass, lock.DOMAIN, lock.SERVICE_OPEN) - lock.open_lock(self.hass, OPENABLE_LOCK) + common.open_lock(self.hass, OPENABLE_LOCK) self.hass.block_till_done() self.assertEqual(1, len(calls)) diff --git a/tests/components/lock/test_mqtt.py b/tests/components/lock/test_mqtt.py index f85c6a11774..4d2378ff9fa 100644 --- a/tests/components/lock/test_mqtt.py +++ b/tests/components/lock/test_mqtt.py @@ -6,9 +6,11 @@ from homeassistant.const import ( STATE_LOCKED, STATE_UNLOCKED, STATE_UNAVAILABLE, ATTR_ASSUMED_STATE) import homeassistant.components.lock as lock from homeassistant.components.mqtt.discovery import async_start + from tests.common import ( mock_mqtt_component, async_fire_mqtt_message, fire_mqtt_message, get_test_home_assistant) +from tests.components.lock import common class TestLockMQTT(unittest.TestCase): @@ -69,7 +71,7 @@ class TestLockMQTT(unittest.TestCase): self.assertEqual(STATE_UNLOCKED, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) - lock.lock(self.hass, 'lock.test') + common.lock(self.hass, 'lock.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( @@ -78,7 +80,7 @@ class TestLockMQTT(unittest.TestCase): state = self.hass.states.get('lock.test') self.assertEqual(STATE_LOCKED, state.state) - lock.unlock(self.hass, 'lock.test') + common.unlock(self.hass, 'lock.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( diff --git a/tests/components/media_player/common.py b/tests/components/media_player/common.py new file mode 100644 index 00000000000..3f4d4cb9f24 --- /dev/null +++ b/tests/components/media_player/common.py @@ -0,0 +1,150 @@ +"""Collection of helper methods. + +All containing methods are legacy helpers that should not be used by new +components. Instead call the service directly. +""" +from homeassistant.components.media_player import ( + ATTR_INPUT_SOURCE, ATTR_MEDIA_CONTENT_ID, ATTR_MEDIA_CONTENT_TYPE, + ATTR_MEDIA_ENQUEUE, ATTR_MEDIA_SEEK_POSITION, ATTR_MEDIA_VOLUME_LEVEL, + ATTR_MEDIA_VOLUME_MUTED, DOMAIN, SERVICE_CLEAR_PLAYLIST, + SERVICE_PLAY_MEDIA, SERVICE_SELECT_SOURCE) +from homeassistant.const import ( + ATTR_ENTITY_ID, SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PAUSE, + SERVICE_MEDIA_PLAY, SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PREVIOUS_TRACK, + SERVICE_MEDIA_SEEK, SERVICE_TOGGLE, SERVICE_TURN_OFF, SERVICE_TURN_ON, + SERVICE_VOLUME_DOWN, SERVICE_VOLUME_MUTE, SERVICE_VOLUME_SET, + SERVICE_VOLUME_UP) +from homeassistant.loader import bind_hass + + +@bind_hass +def turn_on(hass, entity_id=None): + """Turn on specified media player or all.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_TURN_ON, data) + + +@bind_hass +def turn_off(hass, entity_id=None): + """Turn off specified media player or all.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_TURN_OFF, data) + + +@bind_hass +def toggle(hass, entity_id=None): + """Toggle specified media player or all.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_TOGGLE, data) + + +@bind_hass +def volume_up(hass, entity_id=None): + """Send the media player the command for volume up.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_VOLUME_UP, data) + + +@bind_hass +def volume_down(hass, entity_id=None): + """Send the media player the command for volume down.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_VOLUME_DOWN, data) + + +@bind_hass +def mute_volume(hass, mute, entity_id=None): + """Send the media player the command for muting the volume.""" + data = {ATTR_MEDIA_VOLUME_MUTED: mute} + + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_VOLUME_MUTE, data) + + +@bind_hass +def set_volume_level(hass, volume, entity_id=None): + """Send the media player the command for setting the volume.""" + data = {ATTR_MEDIA_VOLUME_LEVEL: volume} + + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_VOLUME_SET, data) + + +@bind_hass +def media_play_pause(hass, entity_id=None): + """Send the media player the command for play/pause.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_MEDIA_PLAY_PAUSE, data) + + +@bind_hass +def media_play(hass, entity_id=None): + """Send the media player the command for play/pause.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_MEDIA_PLAY, data) + + +@bind_hass +def media_pause(hass, entity_id=None): + """Send the media player the command for pause.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_MEDIA_PAUSE, data) + + +@bind_hass +def media_next_track(hass, entity_id=None): + """Send the media player the command for next track.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_MEDIA_NEXT_TRACK, data) + + +@bind_hass +def media_previous_track(hass, entity_id=None): + """Send the media player the command for prev track.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_MEDIA_PREVIOUS_TRACK, data) + + +@bind_hass +def media_seek(hass, position, entity_id=None): + """Send the media player the command to seek in current playing media.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + data[ATTR_MEDIA_SEEK_POSITION] = position + hass.services.call(DOMAIN, SERVICE_MEDIA_SEEK, data) + + +@bind_hass +def play_media(hass, media_type, media_id, entity_id=None, enqueue=None): + """Send the media player the command for playing media.""" + data = {ATTR_MEDIA_CONTENT_TYPE: media_type, + ATTR_MEDIA_CONTENT_ID: media_id} + + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + if enqueue: + data[ATTR_MEDIA_ENQUEUE] = enqueue + + hass.services.call(DOMAIN, SERVICE_PLAY_MEDIA, data) + + +@bind_hass +def select_source(hass, source, entity_id=None): + """Send the media player the command to select input source.""" + data = {ATTR_INPUT_SOURCE: source} + + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_SELECT_SOURCE, data) + + +@bind_hass +def clear_playlist(hass, entity_id=None): + """Send the media player the command for clear playlist.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + hass.services.call(DOMAIN, SERVICE_CLEAR_PLAYLIST, data) diff --git a/tests/components/media_player/test_demo.py b/tests/components/media_player/test_demo.py index 121018e7541..e986ac02065 100644 --- a/tests/components/media_player/test_demo.py +++ b/tests/components/media_player/test_demo.py @@ -12,6 +12,7 @@ from homeassistant.helpers.aiohttp_client import DATA_CLIENTSESSION import requests from tests.common import get_test_home_assistant, get_test_instance_port +from tests.components.media_player import common SERVER_PORT = get_test_instance_port() HTTP_BASE_URL = 'http://127.0.0.1:{}'.format(SERVER_PORT) @@ -42,12 +43,12 @@ class TestDemoMediaPlayer(unittest.TestCase): state = self.hass.states.get(entity_id) assert 'dvd' == state.attributes.get('source') - mp.select_source(self.hass, None, entity_id) + common.select_source(self.hass, None, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 'dvd' == state.attributes.get('source') - mp.select_source(self.hass, 'xbox', entity_id) + common.select_source(self.hass, 'xbox', entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 'xbox' == state.attributes.get('source') @@ -59,7 +60,7 @@ class TestDemoMediaPlayer(unittest.TestCase): {'media_player': {'platform': 'demo'}}) assert self.hass.states.is_state(entity_id, 'playing') - mp.clear_playlist(self.hass, entity_id) + common.clear_playlist(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'off') @@ -71,34 +72,34 @@ class TestDemoMediaPlayer(unittest.TestCase): state = self.hass.states.get(entity_id) assert 1.0 == state.attributes.get('volume_level') - mp.set_volume_level(self.hass, None, entity_id) + common.set_volume_level(self.hass, None, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 1.0 == state.attributes.get('volume_level') - mp.set_volume_level(self.hass, 0.5, entity_id) + common.set_volume_level(self.hass, 0.5, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 0.5 == state.attributes.get('volume_level') - mp.volume_down(self.hass, entity_id) + common.volume_down(self.hass, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 0.4 == state.attributes.get('volume_level') - mp.volume_up(self.hass, entity_id) + common.volume_up(self.hass, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 0.5 == state.attributes.get('volume_level') assert False is state.attributes.get('is_volume_muted') - mp.mute_volume(self.hass, None, entity_id) + common.mute_volume(self.hass, None, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert False is state.attributes.get('is_volume_muted') - mp.mute_volume(self.hass, True, entity_id) + common.mute_volume(self.hass, True, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert True is state.attributes.get('is_volume_muted') @@ -110,16 +111,16 @@ class TestDemoMediaPlayer(unittest.TestCase): {'media_player': {'platform': 'demo'}}) assert self.hass.states.is_state(entity_id, 'playing') - mp.turn_off(self.hass, entity_id) + common.turn_off(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'off') assert not mp.is_on(self.hass, entity_id) - mp.turn_on(self.hass, entity_id) + common.turn_on(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'playing') - mp.toggle(self.hass, entity_id) + common.toggle(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'off') assert not mp.is_on(self.hass, entity_id) @@ -131,19 +132,19 @@ class TestDemoMediaPlayer(unittest.TestCase): {'media_player': {'platform': 'demo'}}) assert self.hass.states.is_state(entity_id, 'playing') - mp.media_pause(self.hass, entity_id) + common.media_pause(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'paused') - mp.media_play_pause(self.hass, entity_id) + common.media_play_pause(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'playing') - mp.media_play_pause(self.hass, entity_id) + common.media_play_pause(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'paused') - mp.media_play(self.hass, entity_id) + common.media_play(self.hass, entity_id) self.hass.block_till_done() assert self.hass.states.is_state(entity_id, 'playing') @@ -155,17 +156,17 @@ class TestDemoMediaPlayer(unittest.TestCase): state = self.hass.states.get(entity_id) assert 1 == state.attributes.get('media_track') - mp.media_next_track(self.hass, entity_id) + common.media_next_track(self.hass, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 2 == state.attributes.get('media_track') - mp.media_next_track(self.hass, entity_id) + common.media_next_track(self.hass, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 3 == state.attributes.get('media_track') - mp.media_previous_track(self.hass, entity_id) + common.media_previous_track(self.hass, entity_id) self.hass.block_till_done() state = self.hass.states.get(entity_id) assert 2 == state.attributes.get('media_track') @@ -177,12 +178,12 @@ class TestDemoMediaPlayer(unittest.TestCase): state = self.hass.states.get(ent_id) assert 1 == state.attributes.get('media_episode') - mp.media_next_track(self.hass, ent_id) + common.media_next_track(self.hass, ent_id) self.hass.block_till_done() state = self.hass.states.get(ent_id) assert 2 == state.attributes.get('media_episode') - mp.media_previous_track(self.hass, ent_id) + common.media_previous_track(self.hass, ent_id) self.hass.block_till_done() state = self.hass.states.get(ent_id) assert 1 == state.attributes.get('media_episode') @@ -200,14 +201,14 @@ class TestDemoMediaPlayer(unittest.TestCase): state.attributes.get('supported_features')) assert state.attributes.get('media_content_id') is not None - mp.play_media(self.hass, None, 'some_id', ent_id) + common.play_media(self.hass, None, 'some_id', ent_id) self.hass.block_till_done() state = self.hass.states.get(ent_id) assert 0 < (mp.SUPPORT_PLAY_MEDIA & state.attributes.get('supported_features')) assert not 'some_id' == state.attributes.get('media_content_id') - mp.play_media(self.hass, 'youtube', 'some_id', ent_id) + common.play_media(self.hass, 'youtube', 'some_id', ent_id) self.hass.block_till_done() state = self.hass.states.get(ent_id) assert 0 < (mp.SUPPORT_PLAY_MEDIA & @@ -215,10 +216,10 @@ class TestDemoMediaPlayer(unittest.TestCase): assert 'some_id' == state.attributes.get('media_content_id') assert not mock_seek.called - mp.media_seek(self.hass, None, ent_id) + common.media_seek(self.hass, None, ent_id) self.hass.block_till_done() assert not mock_seek.called - mp.media_seek(self.hass, 100, ent_id) + common.media_seek(self.hass, 100, ent_id) self.hass.block_till_done() assert mock_seek.called diff --git a/tests/components/notify/common.py b/tests/components/notify/common.py new file mode 100644 index 00000000000..42b4b35b63f --- /dev/null +++ b/tests/components/notify/common.py @@ -0,0 +1,24 @@ +"""Collection of helper methods. + +All containing methods are legacy helpers that should not be used by new +components. Instead call the service directly. +""" +from homeassistant.components.notify import ( + ATTR_DATA, ATTR_MESSAGE, ATTR_TITLE, DOMAIN, SERVICE_NOTIFY) +from homeassistant.loader import bind_hass + + +@bind_hass +def send_message(hass, message, title=None, data=None): + """Send a notification message.""" + info = { + ATTR_MESSAGE: message + } + + if title is not None: + info[ATTR_TITLE] = title + + if data is not None: + info[ATTR_DATA] = data + + hass.services.call(DOMAIN, SERVICE_NOTIFY, info) diff --git a/tests/components/notify/test_demo.py b/tests/components/notify/test_demo.py index f9c107a447e..3be2ddcb86b 100644 --- a/tests/components/notify/test_demo.py +++ b/tests/components/notify/test_demo.py @@ -7,7 +7,9 @@ from homeassistant.setup import setup_component from homeassistant.components.notify import demo from homeassistant.core import callback from homeassistant.helpers import discovery, script + from tests.common import assert_setup_component, get_test_home_assistant +from tests.components.notify import common CONFIG = { notify.DOMAIN: { @@ -79,7 +81,7 @@ class TestNotifyDemo(unittest.TestCase): def test_sending_none_message(self): """Test send with None as message.""" self._setup_notify() - notify.send_message(self.hass, None) + common.send_message(self.hass, None) self.hass.block_till_done() self.assertTrue(len(self.events) == 0) @@ -87,7 +89,7 @@ class TestNotifyDemo(unittest.TestCase): """Send a templated message.""" self._setup_notify() self.hass.states.set('sensor.temperature', 10) - notify.send_message(self.hass, '{{ states.sensor.temperature.state }}', + common.send_message(self.hass, '{{ states.sensor.temperature.state }}', '{{ states.sensor.temperature.name }}') self.hass.block_till_done() last_event = self.events[-1] @@ -97,7 +99,7 @@ class TestNotifyDemo(unittest.TestCase): def test_method_forwards_correct_data(self): """Test that all data from the service gets forwarded to service.""" self._setup_notify() - notify.send_message(self.hass, 'my message', 'my title', + common.send_message(self.hass, 'my message', 'my title', {'hello': 'world'}) self.hass.block_till_done() self.assertTrue(len(self.events) == 1) diff --git a/tests/components/remote/common.py b/tests/components/remote/common.py new file mode 100644 index 00000000000..d03cf5d6d16 --- /dev/null +++ b/tests/components/remote/common.py @@ -0,0 +1,55 @@ +"""Collection of helper methods. + +All containing methods are legacy helpers that should not be used by new +components. Instead call the service directly. +""" +from homeassistant.components.remote import ( + ATTR_ACTIVITY, ATTR_COMMAND, ATTR_DELAY_SECS, ATTR_DEVICE, + ATTR_NUM_REPEATS, DOMAIN, SERVICE_SEND_COMMAND) +from homeassistant.const import ( + ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON) +from homeassistant.loader import bind_hass + + +@bind_hass +def turn_on(hass, activity=None, entity_id=None): + """Turn all or specified remote on.""" + data = { + key: value for key, value in [ + (ATTR_ACTIVITY, activity), + (ATTR_ENTITY_ID, entity_id), + ] if value is not None} + hass.services.call(DOMAIN, SERVICE_TURN_ON, data) + + +@bind_hass +def turn_off(hass, activity=None, entity_id=None): + """Turn all or specified remote off.""" + data = {} + if activity: + data[ATTR_ACTIVITY] = activity + + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_TURN_OFF, data) + + +@bind_hass +def send_command(hass, command, entity_id=None, device=None, + num_repeats=None, delay_secs=None): + """Send a command to a device.""" + data = {ATTR_COMMAND: command} + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + if device: + data[ATTR_DEVICE] = device + + if num_repeats: + data[ATTR_NUM_REPEATS] = num_repeats + + if delay_secs: + data[ATTR_DELAY_SECS] = delay_secs + + hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, data) diff --git a/tests/components/remote/test_demo.py b/tests/components/remote/test_demo.py index a0290987ff2..fbf7230c237 100644 --- a/tests/components/remote/test_demo.py +++ b/tests/components/remote/test_demo.py @@ -5,7 +5,9 @@ import unittest from homeassistant.setup import setup_component import homeassistant.components.remote as remote from homeassistant.const import STATE_ON, STATE_OFF + from tests.common import get_test_home_assistant +from tests.components.remote import common ENTITY_ID = 'remote.remote_one' @@ -28,22 +30,22 @@ class TestDemoRemote(unittest.TestCase): def test_methods(self): """Test if services call the entity methods as expected.""" - remote.turn_on(self.hass, entity_id=ENTITY_ID) + common.turn_on(self.hass, entity_id=ENTITY_ID) self.hass.block_till_done() state = self.hass.states.get(ENTITY_ID) self.assertEqual(state.state, STATE_ON) - remote.turn_off(self.hass, entity_id=ENTITY_ID) + common.turn_off(self.hass, entity_id=ENTITY_ID) self.hass.block_till_done() state = self.hass.states.get(ENTITY_ID) self.assertEqual(state.state, STATE_OFF) - remote.turn_on(self.hass, entity_id=ENTITY_ID) + common.turn_on(self.hass, entity_id=ENTITY_ID) self.hass.block_till_done() state = self.hass.states.get(ENTITY_ID) self.assertEqual(state.state, STATE_ON) - remote.send_command(self.hass, 'test', entity_id=ENTITY_ID) + common.send_command(self.hass, 'test', entity_id=ENTITY_ID) self.hass.block_till_done() state = self.hass.states.get(ENTITY_ID) self.assertEqual( diff --git a/tests/components/remote/test_init.py b/tests/components/remote/test_init.py index d98ec941f8b..21a083e3b9a 100644 --- a/tests/components/remote/test_init.py +++ b/tests/components/remote/test_init.py @@ -10,6 +10,8 @@ from homeassistant.const import ( import homeassistant.components.remote as remote from tests.common import mock_service, get_test_home_assistant +from tests.components.remote import common + TEST_PLATFORM = {remote.DOMAIN: {CONF_PLATFORM: 'test'}} SERVICE_SEND_COMMAND = 'send_command' @@ -46,7 +48,7 @@ class TestRemote(unittest.TestCase): turn_on_calls = mock_service( self.hass, remote.DOMAIN, SERVICE_TURN_ON) - remote.turn_on( + common.turn_on( self.hass, entity_id='entity_id_val') @@ -62,7 +64,7 @@ class TestRemote(unittest.TestCase): turn_off_calls = mock_service( self.hass, remote.DOMAIN, SERVICE_TURN_OFF) - remote.turn_off( + common.turn_off( self.hass, entity_id='entity_id_val') self.hass.block_till_done() @@ -79,7 +81,7 @@ class TestRemote(unittest.TestCase): send_command_calls = mock_service( self.hass, remote.DOMAIN, SERVICE_SEND_COMMAND) - remote.send_command( + common.send_command( self.hass, entity_id='entity_id_val', device='test_device', command=['test_command'], num_repeats='4', delay_secs='0.6') diff --git a/tests/components/scene/common.py b/tests/components/scene/common.py new file mode 100644 index 00000000000..4f8123ca638 --- /dev/null +++ b/tests/components/scene/common.py @@ -0,0 +1,19 @@ +"""Collection of helper methods. + +All containing methods are legacy helpers that should not be used by new +components. Instead call the service directly. +""" +from homeassistant.components.scene import DOMAIN +from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_ON +from homeassistant.loader import bind_hass + + +@bind_hass +def activate(hass, entity_id=None): + """Activate a scene.""" + data = {} + + if entity_id: + data[ATTR_ENTITY_ID] = entity_id + + hass.services.call(DOMAIN, SERVICE_TURN_ON, data) diff --git a/tests/components/scene/test_init.py b/tests/components/scene/test_init.py index 3298d7648d9..08d9af95275 100644 --- a/tests/components/scene/test_init.py +++ b/tests/components/scene/test_init.py @@ -8,6 +8,7 @@ from homeassistant.components import light, scene from homeassistant.util import yaml from tests.common import get_test_home_assistant +from tests.components.scene import common class TestScene(unittest.TestCase): @@ -68,7 +69,7 @@ class TestScene(unittest.TestCase): }] })) - scene.activate(self.hass, 'scene.test') + common.activate(self.hass, 'scene.test') self.hass.block_till_done() self.assertTrue(self.light_1.is_on) @@ -94,7 +95,7 @@ class TestScene(unittest.TestCase): doc = yaml.yaml.safe_load(file) self.assertTrue(setup_component(self.hass, scene.DOMAIN, doc)) - scene.activate(self.hass, 'scene.test') + common.activate(self.hass, 'scene.test') self.hass.block_till_done() self.assertTrue(self.light_1.is_on) @@ -117,7 +118,7 @@ class TestScene(unittest.TestCase): }] })) - scene.activate(self.hass, 'scene.test') + common.activate(self.hass, 'scene.test') self.hass.block_till_done() self.assertTrue(self.light_1.is_on) diff --git a/tests/components/scene/test_litejet.py b/tests/components/scene/test_litejet.py index 864ffc41735..57d3c178dbd 100644 --- a/tests/components/scene/test_litejet.py +++ b/tests/components/scene/test_litejet.py @@ -5,8 +5,9 @@ from unittest import mock from homeassistant import setup from homeassistant.components import litejet + from tests.common import get_test_home_assistant -import homeassistant.components.scene as scene +from tests.components.scene import common _LOGGER = logging.getLogger(__name__) @@ -59,7 +60,7 @@ class TestLiteJetScene(unittest.TestCase): def test_activate(self): """Test activating the scene.""" - scene.activate(self.hass, ENTITY_SCENE) + common.activate(self.hass, ENTITY_SCENE) self.hass.block_till_done() self.mock_lj.activate_scene.assert_called_once_with( ENTITY_SCENE_NUMBER) diff --git a/tests/components/vacuum/common.py b/tests/components/vacuum/common.py new file mode 100644 index 00000000000..436f23f5546 --- /dev/null +++ b/tests/components/vacuum/common.py @@ -0,0 +1,101 @@ +"""Collection of helper methods. + +All containing methods are legacy helpers that should not be used by new +components. Instead call the service directly. +""" +from homeassistant.components.vacuum import ( + ATTR_FAN_SPEED, ATTR_PARAMS, DOMAIN, SERVICE_CLEAN_SPOT, SERVICE_LOCATE, + SERVICE_PAUSE, SERVICE_SEND_COMMAND, SERVICE_SET_FAN_SPEED, SERVICE_START, + SERVICE_START_PAUSE, SERVICE_STOP, SERVICE_RETURN_TO_BASE) +from homeassistant.const import ( + ATTR_COMMAND, ATTR_ENTITY_ID, SERVICE_TOGGLE, + SERVICE_TURN_OFF, SERVICE_TURN_ON) +from homeassistant.loader import bind_hass + + +@bind_hass +def turn_on(hass, entity_id=None): + """Turn all or specified vacuum on.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_TURN_ON, data) + + +@bind_hass +def turn_off(hass, entity_id=None): + """Turn all or specified vacuum off.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_TURN_OFF, data) + + +@bind_hass +def toggle(hass, entity_id=None): + """Toggle all or specified vacuum.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_TOGGLE, data) + + +@bind_hass +def locate(hass, entity_id=None): + """Locate all or specified vacuum.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_LOCATE, data) + + +@bind_hass +def clean_spot(hass, entity_id=None): + """Tell all or specified vacuum to perform a spot clean-up.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_CLEAN_SPOT, data) + + +@bind_hass +def return_to_base(hass, entity_id=None): + """Tell all or specified vacuum to return to base.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_RETURN_TO_BASE, data) + + +@bind_hass +def start_pause(hass, entity_id=None): + """Tell all or specified vacuum to start or pause the current task.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_START_PAUSE, data) + + +@bind_hass +def start(hass, entity_id=None): + """Tell all or specified vacuum to start or resume the current task.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_START, data) + + +@bind_hass +def pause(hass, entity_id=None): + """Tell all or the specified vacuum to pause the current task.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_PAUSE, data) + + +@bind_hass +def stop(hass, entity_id=None): + """Stop all or specified vacuum.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else None + hass.services.call(DOMAIN, SERVICE_STOP, data) + + +@bind_hass +def set_fan_speed(hass, fan_speed, entity_id=None): + """Set fan speed for all or specified vacuum.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + data[ATTR_FAN_SPEED] = fan_speed + hass.services.call(DOMAIN, SERVICE_SET_FAN_SPEED, data) + + +@bind_hass +def send_command(hass, command, params=None, entity_id=None): + """Send command to all or specified vacuum.""" + data = {ATTR_ENTITY_ID: entity_id} if entity_id else {} + data[ATTR_COMMAND] = command + if params is not None: + data[ATTR_PARAMS] = params + hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, data) diff --git a/tests/components/vacuum/test_demo.py b/tests/components/vacuum/test_demo.py index 1fc8f8cd5c1..f88908ecc41 100644 --- a/tests/components/vacuum/test_demo.py +++ b/tests/components/vacuum/test_demo.py @@ -15,7 +15,9 @@ from homeassistant.components.vacuum.demo import ( from homeassistant.const import ( ATTR_SUPPORTED_FEATURES, CONF_PLATFORM, STATE_OFF, STATE_ON) from homeassistant.setup import setup_component + from tests.common import get_test_home_assistant, mock_service +from tests.components.vacuum import common ENTITY_VACUUM_BASIC = '{}.{}'.format(DOMAIN, DEMO_VACUUM_BASIC).lower() @@ -108,27 +110,27 @@ class TestVacuumDemo(unittest.TestCase): self.hass.block_till_done() self.assertFalse(vacuum.is_on(self.hass)) - vacuum.turn_on(self.hass, ENTITY_VACUUM_COMPLETE) + common.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) + common.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) + common.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) + common.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) + common.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) + common.stop(self.hass, ENTITY_VACUUM_COMPLETE) self.hass.block_till_done() self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)) @@ -136,39 +138,39 @@ class TestVacuumDemo(unittest.TestCase): self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100) self.assertNotEqual("Charging", state.attributes.get(ATTR_STATUS)) - vacuum.locate(self.hass, ENTITY_VACUUM_COMPLETE) + 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)) - vacuum.return_to_base(self.hass, ENTITY_VACUUM_COMPLETE) + 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)) - vacuum.set_fan_speed(self.hass, FAN_SPEEDS[-1], + 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)) - vacuum.clean_spot(self.hass, entity_id=ENTITY_VACUUM_COMPLETE) + 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) - vacuum.start(self.hass, ENTITY_VACUUM_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) - vacuum.pause(self.hass, ENTITY_VACUUM_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) - vacuum.stop(self.hass, ENTITY_VACUUM_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) @@ -177,18 +179,18 @@ class TestVacuumDemo(unittest.TestCase): self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100) self.assertNotEqual(STATE_DOCKED, state.state) - vacuum.return_to_base(self.hass, ENTITY_VACUUM_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) - vacuum.set_fan_speed(self.hass, FAN_SPEEDS[-1], + 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)) - vacuum.clean_spot(self.hass, entity_id=ENTITY_VACUUM_STATE) + 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) @@ -199,11 +201,11 @@ class TestVacuumDemo(unittest.TestCase): self.hass.block_till_done() self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)) - vacuum.turn_off(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)) - vacuum.stop(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)) @@ -211,37 +213,37 @@ class TestVacuumDemo(unittest.TestCase): self.hass.block_till_done() self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE)) - vacuum.turn_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)) - vacuum.toggle(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: - vacuum.start_pause(self.hass, ENTITY_VACUUM_NONE) + common.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) + 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)) - vacuum.return_to_base(self.hass, ENTITY_VACUUM_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)) - vacuum.set_fan_speed(self.hass, FAN_SPEEDS[-1], + 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)) - vacuum.clean_spot(self.hass, entity_id=ENTITY_VACUUM_BASIC) + 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)) @@ -252,7 +254,7 @@ class TestVacuumDemo(unittest.TestCase): self.hass.block_till_done() self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)) - vacuum.pause(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)) @@ -260,22 +262,22 @@ class TestVacuumDemo(unittest.TestCase): self.hass.block_till_done() self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE)) - vacuum.start(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 - vacuum.turn_on(self.hass, entity_id=ENTITY_VACUUM_STATE) + 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) - vacuum.turn_off(self.hass, entity_id=ENTITY_VACUUM_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) - vacuum.toggle(self.hass, entity_id=ENTITY_VACUUM_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) @@ -287,7 +289,7 @@ class TestVacuumDemo(unittest.TestCase): self.hass, DOMAIN, SERVICE_SEND_COMMAND) params = {"rotate": 150, "speed": 20} - vacuum.send_command( + common.send_command( self.hass, 'test_command', entity_id=ENTITY_VACUUM_BASIC, params=params) @@ -305,7 +307,7 @@ class TestVacuumDemo(unittest.TestCase): set_fan_speed_calls = mock_service( self.hass, DOMAIN, SERVICE_SET_FAN_SPEED) - vacuum.set_fan_speed( + common.set_fan_speed( self.hass, FAN_SPEEDS[0], entity_id=ENTITY_VACUUM_COMPLETE) self.hass.block_till_done() @@ -326,7 +328,7 @@ class TestVacuumDemo(unittest.TestCase): old_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE) old_state_state = self.hass.states.get(ENTITY_VACUUM_STATE) - vacuum.set_fan_speed( + common.set_fan_speed( self.hass, FAN_SPEEDS[0], entity_id=group_vacuums) self.hass.block_till_done() @@ -356,7 +358,7 @@ class TestVacuumDemo(unittest.TestCase): old_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC) old_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE) - vacuum.send_command( + common.send_command( self.hass, 'test_command', params={"p1": 3}, entity_id=group_vacuums) diff --git a/tests/components/vacuum/test_mqtt.py b/tests/components/vacuum/test_mqtt.py index ba2288e3fc6..ddd4289c24d 100644 --- a/tests/components/vacuum/test_mqtt.py +++ b/tests/components/vacuum/test_mqtt.py @@ -9,8 +9,10 @@ from homeassistant.components.mqtt import CONF_COMMAND_TOPIC from homeassistant.const import ( CONF_PLATFORM, STATE_OFF, STATE_ON, STATE_UNAVAILABLE, CONF_NAME) from homeassistant.setup import setup_component + from tests.common import ( fire_mqtt_message, get_test_home_assistant, mock_mqtt_component) +from tests.components.vacuum import common class TestVacuumMQTT(unittest.TestCase): @@ -69,55 +71,55 @@ class TestVacuumMQTT(unittest.TestCase): vacuum.DOMAIN: self.default_config, })) - vacuum.turn_on(self.hass, 'vacuum.mqtttest') + common.turn_on(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'turn_on', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.turn_off(self.hass, 'vacuum.mqtttest') + common.turn_off(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'turn_off', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.stop(self.hass, 'vacuum.mqtttest') + common.stop(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'stop', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.clean_spot(self.hass, 'vacuum.mqtttest') + common.clean_spot(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'clean_spot', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.locate(self.hass, 'vacuum.mqtttest') + common.locate(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'locate', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.start_pause(self.hass, 'vacuum.mqtttest') + common.start_pause(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'start_pause', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.return_to_base(self.hass, 'vacuum.mqtttest') + common.return_to_base(self.hass, 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/command', 'return_to_base', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.set_fan_speed(self.hass, 'high', 'vacuum.mqtttest') + common.set_fan_speed(self.hass, 'high', 'vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/set_fan_speed', 'high', 0, False) self.mock_publish.async_publish.reset_mock() - vacuum.send_command(self.hass, '44 FE 93', entity_id='vacuum.mqtttest') + common.send_command(self.hass, '44 FE 93', entity_id='vacuum.mqtttest') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'vacuum/send_command', '44 FE 93', 0, False)