evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove service helper (4) (#16892)

Browse source 
* Update media_player

* Update lock

* Update notify

* Update remote

* Update scene

* Update vacuum

* Remove timer helpers

* Removed unused legacy helpers
This commit is contained in:
cdce8p 2018-09-26 18:02:05 +02:00 • committed by Paulus Schoutsen
parent d0ddc28f96
commit dd45e99302
23 changed files with 499 additions and 520 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
homeassistant/components/lock/__init__.py
View file

@ -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."""

162
homeassistant/components/media_player/__init__.py
View file

@ -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({

17
homeassistant/components/notify/__init__.py
View file

@ -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."""

57
homeassistant/components/remote/__init__.py
View file

@ -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."""

12
homeassistant/components/scene/__init__.py
View file

@ -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__)

60
homeassistant/components/timer/__init__.py
View file

@ -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)

88
homeassistant/components/vacuum/__init__.py
View file

@ -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."""

45
tests/components/lock/common.py Normal file
View file

@ -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)

8
tests/components/lock/test_demo.py
View file

@ -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))

6
tests/components/lock/test_mqtt.py
View file

@ -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(

150
tests/components/media_player/common.py Normal file
View file

@ -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)

51
tests/components/media_player/test_demo.py
View file

@ -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

24
tests/components/notify/common.py Normal file
View file

@ -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)

8
tests/components/notify/test_demo.py
View file

@ -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)

55
tests/components/remote/common.py Normal file
View file

@ -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)

10
tests/components/remote/test_demo.py
View file

@ -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(

8
tests/components/remote/test_init.py
View file

@ -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')

19
tests/components/scene/common.py Normal file
View file

@ -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)

7
tests/components/scene/test_init.py
View file

@ -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)

5
tests/components/scene/test_litejet.py
View file

@ -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)

101
tests/components/vacuum/common.py Normal file
View file

@ -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)

70
tests/components/vacuum/test_demo.py
View file

@ -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)

20
tests/components/vacuum/test_mqtt.py
View file

@ -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)