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

Remove service helper (5) (#16917)

Browse source 
* Update switch

* Update script

* Update light

* Fix tests

* Fix config/script hook

* Async_create_task

* Fix flux switch
This commit is contained in:
cdce8p 2018-09-27 23:13:11 +02:00 • committed by Paulus Schoutsen
parent a7248d4574
commit 70b901017f
27 changed files with 385 additions and 316 deletions
Download patch file Download diff file Expand all files Collapse all files

9
homeassistant/components/config/script.py
View file

@ -2,7 +2,8 @@
import asyncio
from homeassistant.components.config import EditKeyBasedConfigView
from homeassistant.components.script import SCRIPT_ENTRY_SCHEMA, async_reload
from homeassistant.components.script import DOMAIN, SCRIPT_ENTRY_SCHEMA
from homeassistant.const import SERVICE_RELOAD
import homeassistant.helpers.config_validation as cv
@ -12,8 +13,12 @@ CONFIG_PATH = 'scripts.yaml'
@asyncio.coroutine
def async_setup(hass):
"""Set up the script config API."""
async def hook(hass):
"""post_write_hook for Config View that reloads scripts."""
await hass.services.async_call(DOMAIN, SERVICE_RELOAD)
hass.http.register_view(EditKeyBasedConfigView(
'script', 'config', CONFIG_PATH, cv.slug, SCRIPT_ENTRY_SCHEMA,
post_write_hook=async_reload
post_write_hook=hook
))
return True

25
homeassistant/components/device_sun_light_trigger.py
View file

@ -12,7 +12,9 @@ import voluptuous as vol
from homeassistant.core import callback
import homeassistant.util.dt as dt_util
from homeassistant.const import STATE_HOME, STATE_NOT_HOME
from homeassistant.const import (
SERVICE_TURN_OFF, SERVICE_TURN_ON, STATE_HOME, STATE_NOT_HOME)
from homeassistant.components.light import DOMAIN as DOMAIN_LIGHT
from homeassistant.helpers.event import (
async_track_point_in_utc_time, async_track_state_change)
from homeassistant.helpers.sun import is_up, get_astral_event_next
@ -86,9 +88,12 @@ def async_setup(hass, config):
"""Turn on lights."""
if not device_tracker.is_on() or light.is_on(light_id):
return
light.async_turn_on(light_id,
hass.async_create_task(
hass.services.async_call(
DOMAIN_LIGHT, SERVICE_TURN_ON, dict(
entity_id=light_id,
transition=LIGHT_TRANSITION_TIME.seconds,
profile=light_profile)
profile=light_profile)))
def async_turn_on_factory(light_id):
"""Generate turn on callbacks as factory."""
@ -138,7 +143,10 @@ def async_setup(hass, config):
# Do we need lights?
if light_needed:
logger.info("Home coming event for %s. Turning lights on", entity)
light.async_turn_on(light_ids, profile=light_profile)
hass.async_create_task(
hass.services.async_call(
DOMAIN_LIGHT, SERVICE_TURN_ON,
dict(entity_id=light_ids, profile=light_profile)))
# Are we in the time span were we would turn on the lights
# if someone would be home?
@ -151,7 +159,10 @@ def async_setup(hass, config):
# when the fading in started and turn it on if so
for index, light_id in enumerate(light_ids):
if now > start_point + index * LIGHT_TRANSITION_TIME:
light.async_turn_on(light_id)
hass.async_create_task(
hass.services.async_call(
DOMAIN_LIGHT, SERVICE_TURN_ON,
dict(entity_id=light_id)))
else:
# If this light didn't happen to be turned on yet so
@ -173,7 +184,9 @@ def async_setup(hass, config):
logger.info(
"Everyone has left but there are lights on. Turning them off")
light.async_turn_off(light_ids)
hass.async_create_task(
hass.services.async_call(
DOMAIN_LIGHT, SERVICE_TURN_OFF, dict(entity_id=light_ids)))
async_track_state_change(
hass, device_group, turn_off_lights_when_all_leave,

85
homeassistant/components/light/__init__.py
View file

@ -17,7 +17,6 @@ from homeassistant.components.group import \
from homeassistant.const import (
ATTR_ENTITY_ID, SERVICE_TOGGLE, SERVICE_TURN_OFF, SERVICE_TURN_ON,
STATE_ON)
from homeassistant.core import callback
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.config_validation import PLATFORM_SCHEMA # noqa
from homeassistant.helpers.entity import ToggleEntity
@ -142,90 +141,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, transition=None, brightness=None,
brightness_pct=None, rgb_color=None, xy_color=None, hs_color=None,
color_temp=None, kelvin=None, white_value=None,
profile=None, flash=None, effect=None, color_name=None):
"""Turn all or specified light on."""
hass.add_job(
async_turn_on, hass, entity_id, transition, brightness, brightness_pct,
rgb_color, xy_color, hs_color, color_temp, kelvin, white_value,
profile, flash, effect, color_name)
@callback
@bind_hass
def async_turn_on(hass, entity_id=None, transition=None, brightness=None,
brightness_pct=None, rgb_color=None, xy_color=None,
hs_color=None, color_temp=None, kelvin=None,
white_value=None, profile=None, flash=None, effect=None,
color_name=None):
"""Turn all or specified light on."""
data = {
key: value for key, value in [
(ATTR_ENTITY_ID, entity_id),
(ATTR_PROFILE, profile),
(ATTR_TRANSITION, transition),
(ATTR_BRIGHTNESS, brightness),
(ATTR_BRIGHTNESS_PCT, brightness_pct),
(ATTR_RGB_COLOR, rgb_color),
(ATTR_XY_COLOR, xy_color),
(ATTR_HS_COLOR, hs_color),
(ATTR_COLOR_TEMP, color_temp),
(ATTR_KELVIN, kelvin),
(ATTR_WHITE_VALUE, white_value),
(ATTR_FLASH, flash),
(ATTR_EFFECT, effect),
(ATTR_COLOR_NAME, color_name),
] if value is not None
}
hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_TURN_ON, data))
@bind_hass
def turn_off(hass, entity_id=None, transition=None):
"""Turn all or specified light off."""
hass.add_job(async_turn_off, hass, entity_id, transition)
@callback
@bind_hass
def async_turn_off(hass, entity_id=None, transition=None):
"""Turn all or specified light off."""
data = {
key: value for key, value in [
(ATTR_ENTITY_ID, entity_id),
(ATTR_TRANSITION, transition),
] if value is not None
}
hass.async_add_job(hass.services.async_call(
DOMAIN, SERVICE_TURN_OFF, data))
@callback
@bind_hass
def async_toggle(hass, entity_id=None, transition=None):
"""Toggle all or specified light."""
data = {
key: value for key, value in [
(ATTR_ENTITY_ID, entity_id),
(ATTR_TRANSITION, transition),
] if value is not None
}
hass.async_add_job(hass.services.async_call(
DOMAIN, SERVICE_TOGGLE, data))
@bind_hass
def toggle(hass, entity_id=None, transition=None):
"""Toggle all or specified light."""
hass.add_job(async_toggle, hass, entity_id, transition)
def preprocess_turn_on_alternatives(params):
"""Process extra data for turn light on request."""
profile = Profiles.get(params.pop(ATTR_PROFILE, None))

36
homeassistant/components/script.py
View file

@ -15,7 +15,6 @@ import voluptuous as vol
from homeassistant.const import (
ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON,
SERVICE_TOGGLE, SERVICE_RELOAD, STATE_ON, CONF_ALIAS)
from homeassistant.core import split_entity_id
from homeassistant.loader import bind_hass
from homeassistant.helpers.entity import ToggleEntity
from homeassistant.helpers.entity_component import EntityComponent
@ -62,41 +61,6 @@ def is_on(hass, entity_id):
return hass.states.is_state(entity_id, STATE_ON)
@bind_hass
def turn_on(hass, entity_id, variables=None, context=None):
"""Turn script on."""
_, object_id = split_entity_id(entity_id)
hass.services.call(DOMAIN, object_id, variables, context=context)
@bind_hass
def turn_off(hass, entity_id):
"""Turn script on."""
hass.services.call(DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: entity_id})
@bind_hass
def toggle(hass, entity_id):
"""Toggle the script."""
hass.services.call(DOMAIN, SERVICE_TOGGLE, {ATTR_ENTITY_ID: entity_id})
@bind_hass
def reload(hass):
"""Reload script component."""
hass.services.call(DOMAIN, SERVICE_RELOAD)
@bind_hass
def async_reload(hass):
"""Reload the scripts from config.
Returns a coroutine object.
"""
return hass.services.async_call(DOMAIN, SERVICE_RELOAD)
async def async_setup(hass, config):
"""Load the scripts from the configuration."""
component = EntityComponent(

37
homeassistant/components/switch/__init__.py
View file

@ -9,7 +9,6 @@ import logging
import voluptuous as vol
from homeassistant.core import callback
from homeassistant.loader import bind_hass
from homeassistant.helpers.entity_component import EntityComponent
from homeassistant.helpers.entity import ToggleEntity
@ -56,42 +55,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 switch on."""
hass.add_job(async_turn_on, hass, entity_id)
@callback
@bind_hass
def async_turn_on(hass, entity_id=None):
"""Turn all or specified switch on."""
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_TURN_ON, data))
@bind_hass
def turn_off(hass, entity_id=None):
"""Turn all or specified switch off."""
hass.add_job(async_turn_off, hass, entity_id)
@callback
@bind_hass
def async_turn_off(hass, entity_id=None):
"""Turn all or specified switch off."""
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.async_add_job(
hass.services.async_call(DOMAIN, SERVICE_TURN_OFF, data))
@bind_hass
def toggle(hass, entity_id=None):
"""Toggle all or specified switch."""
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_TOGGLE, data)
async def async_setup(hass, config):
"""Track states and offer events for switches."""
component = hass.data[DOMAIN] = EntityComponent(

22
homeassistant/components/switch/flux.py
View file

@ -13,10 +13,10 @@ import voluptuous as vol
import homeassistant.helpers.config_validation as cv
from homeassistant.components.light import (
is_on, turn_on, VALID_TRANSITION, ATTR_TRANSITION)
is_on, DOMAIN as LIGHT_DOMAIN, VALID_TRANSITION, ATTR_TRANSITION)
from homeassistant.components.switch import DOMAIN, SwitchDevice
from homeassistant.const import (
CONF_NAME, CONF_PLATFORM, CONF_LIGHTS, CONF_MODE)
CONF_NAME, CONF_PLATFORM, CONF_LIGHTS, CONF_MODE, SERVICE_TURN_ON)
from homeassistant.helpers.event import track_time_change
from homeassistant.helpers.sun import get_astral_event_date
from homeassistant.util import slugify
@ -69,30 +69,36 @@ def set_lights_xy(hass, lights, x_val, y_val, brightness, transition):
"""Set color of array of lights."""
for light in lights:
if is_on(hass, light):
turn_on(hass, light,
hass.services.call(
LIGHT_DOMAIN, SERVICE_TURN_ON, dict(
xy_color=[x_val, y_val],
brightness=brightness,
transition=transition,
white_value=brightness)
white_value=brightness,
entity_id=light))
def set_lights_temp(hass, lights, mired, brightness, transition):
"""Set color of array of lights."""
for light in lights:
if is_on(hass, light):
turn_on(hass, light,
hass.services.call(
LIGHT_DOMAIN, SERVICE_TURN_ON, dict(
color_temp=int(mired),
brightness=brightness,
transition=transition)
transition=transition,
entity_id=light))
def set_lights_rgb(hass, lights, rgb, transition):
"""Set color of array of lights."""
for light in lights:
if is_on(hass, light):
turn_on(hass, light,
hass.services.call(
LIGHT_DOMAIN, SERVICE_TURN_ON, dict(
rgb_color=rgb,
transition=transition)
transition=transition,
entity_id=light))
def setup_platform(hass, config, add_entities, discovery_info=None):

97
tests/components/light/common.py Normal file
View file

@ -0,0 +1,97 @@
"""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.light import (
ATTR_BRIGHTNESS, ATTR_BRIGHTNESS_PCT, ATTR_COLOR_NAME, ATTR_COLOR_TEMP,
ATTR_EFFECT, ATTR_FLASH, ATTR_HS_COLOR, ATTR_KELVIN, ATTR_PROFILE,
ATTR_RGB_COLOR, ATTR_TRANSITION, ATTR_WHITE_VALUE, ATTR_XY_COLOR, DOMAIN)
from homeassistant.const import (
ATTR_ENTITY_ID, SERVICE_TOGGLE, SERVICE_TURN_OFF, SERVICE_TURN_ON)
from homeassistant.core import callback
from homeassistant.loader import bind_hass
@bind_hass
def turn_on(hass, entity_id=None, transition=None, brightness=None,
brightness_pct=None, rgb_color=None, xy_color=None, hs_color=None,
color_temp=None, kelvin=None, white_value=None,
profile=None, flash=None, effect=None, color_name=None):
"""Turn all or specified light on."""
hass.add_job(
async_turn_on, hass, entity_id, transition, brightness, brightness_pct,
rgb_color, xy_color, hs_color, color_temp, kelvin, white_value,
profile, flash, effect, color_name)
@callback
@bind_hass
def async_turn_on(hass, entity_id=None, transition=None, brightness=None,
brightness_pct=None, rgb_color=None, xy_color=None,
hs_color=None, color_temp=None, kelvin=None,
white_value=None, profile=None, flash=None, effect=None,
color_name=None):
"""Turn all or specified light on."""
data = {
key: value for key, value in [
(ATTR_ENTITY_ID, entity_id),
(ATTR_PROFILE, profile),
(ATTR_TRANSITION, transition),
(ATTR_BRIGHTNESS, brightness),
(ATTR_BRIGHTNESS_PCT, brightness_pct),
(ATTR_RGB_COLOR, rgb_color),
(ATTR_XY_COLOR, xy_color),
(ATTR_HS_COLOR, hs_color),
(ATTR_COLOR_TEMP, color_temp),
(ATTR_KELVIN, kelvin),
(ATTR_WHITE_VALUE, white_value),
(ATTR_FLASH, flash),
(ATTR_EFFECT, effect),
(ATTR_COLOR_NAME, color_name),
] if value is not None
}
hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_TURN_ON, data))
@bind_hass
def turn_off(hass, entity_id=None, transition=None):
"""Turn all or specified light off."""
hass.add_job(async_turn_off, hass, entity_id, transition)
@callback
@bind_hass
def async_turn_off(hass, entity_id=None, transition=None):
"""Turn all or specified light off."""
data = {
key: value for key, value in [
(ATTR_ENTITY_ID, entity_id),
(ATTR_TRANSITION, transition),
] if value is not None
}
hass.async_add_job(hass.services.async_call(
DOMAIN, SERVICE_TURN_OFF, data))
@bind_hass
def toggle(hass, entity_id=None, transition=None):
"""Toggle all or specified light."""
hass.add_job(async_toggle, hass, entity_id, transition)
@callback
@bind_hass
def async_toggle(hass, entity_id=None, transition=None):
"""Toggle all or specified light."""
data = {
key: value for key, value in [
(ATTR_ENTITY_ID, entity_id),
(ATTR_TRANSITION, transition),
] if value is not None
}
hass.async_add_job(hass.services.async_call(
DOMAIN, SERVICE_TOGGLE, data))

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

@ -4,6 +4,8 @@ import pytest
from homeassistant.setup import async_setup_component
from homeassistant.components import light
from tests.components.light import common
ENTITY_LIGHT = 'light.bed_light'
@ -18,7 +20,7 @@ def setup_comp(hass):
async def test_state_attributes(hass):
"""Test light state attributes."""
light.async_turn_on(
common.async_turn_on(
hass, ENTITY_LIGHT, xy_color=(.4, .4), brightness=25)
await hass.async_block_till_done()
state = hass.states.get(ENTITY_LIGHT)
@ -27,7 +29,7 @@ async def test_state_attributes(hass):
assert 25 == state.attributes.get(light.ATTR_BRIGHTNESS)
assert (255, 234, 164) == state.attributes.get(light.ATTR_RGB_COLOR)
assert 'rainbow' == state.attributes.get(light.ATTR_EFFECT)
light.async_turn_on(
common.async_turn_on(
hass, ENTITY_LIGHT, rgb_color=(251, 253, 255),
white_value=254)
await hass.async_block_till_done()
@ -35,14 +37,14 @@ async def test_state_attributes(hass):
assert 254 == state.attributes.get(light.ATTR_WHITE_VALUE)
assert (250, 252, 255) == state.attributes.get(light.ATTR_RGB_COLOR)
assert (0.319, 0.326) == state.attributes.get(light.ATTR_XY_COLOR)
light.async_turn_on(hass, ENTITY_LIGHT, color_temp=400, effect='none')
common.async_turn_on(hass, ENTITY_LIGHT, color_temp=400, effect='none')
await hass.async_block_till_done()
state = hass.states.get(ENTITY_LIGHT)
assert 400 == state.attributes.get(light.ATTR_COLOR_TEMP)
assert 153 == state.attributes.get(light.ATTR_MIN_MIREDS)
assert 500 == state.attributes.get(light.ATTR_MAX_MIREDS)
assert 'none' == state.attributes.get(light.ATTR_EFFECT)
light.async_turn_on(hass, ENTITY_LIGHT, kelvin=3000, brightness_pct=50)
common.async_turn_on(hass, ENTITY_LIGHT, kelvin=3000, brightness_pct=50)
await hass.async_block_till_done()
state = hass.states.get(ENTITY_LIGHT)
assert 333 == state.attributes.get(light.ATTR_COLOR_TEMP)

11
tests/components/light/test_group.py
View file

@ -3,10 +3,11 @@ from unittest.mock import MagicMock
import asynctest
from homeassistant.components import light
from homeassistant.components.light import group
from homeassistant.setup import async_setup_component
from tests.components.light import common
async def test_default_state(hass):
"""Test light group default state."""
@ -300,28 +301,28 @@ async def test_service_calls(hass):
await hass.async_block_till_done()
assert hass.states.get('light.light_group').state == 'on'
light.async_toggle(hass, 'light.light_group')
common.async_toggle(hass, 'light.light_group')
await hass.async_block_till_done()
assert hass.states.get('light.bed_light').state == 'off'
assert hass.states.get('light.ceiling_lights').state == 'off'
assert hass.states.get('light.kitchen_lights').state == 'off'
light.async_turn_on(hass, 'light.light_group')
common.async_turn_on(hass, 'light.light_group')
await hass.async_block_till_done()
assert hass.states.get('light.bed_light').state == 'on'
assert hass.states.get('light.ceiling_lights').state == 'on'
assert hass.states.get('light.kitchen_lights').state == 'on'
light.async_turn_off(hass, 'light.light_group')
common.async_turn_off(hass, 'light.light_group')
await hass.async_block_till_done()
assert hass.states.get('light.bed_light').state == 'off'
assert hass.states.get('light.ceiling_lights').state == 'off'
assert hass.states.get('light.kitchen_lights').state == 'off'
light.async_turn_on(hass, 'light.light_group', brightness=128,
common.async_turn_on(hass, 'light.light_group', brightness=128,
effect='Random', rgb_color=(42, 255, 255))
await hass.async_block_till_done()

49
tests/components/light/test_init.py
View file

@ -15,6 +15,7 @@ from homeassistant.helpers.intent import IntentHandleError
from tests.common import (
async_mock_service, mock_service, get_test_home_assistant, mock_storage)
from tests.components.light import common
class TestLight(unittest.TestCase):
@ -54,7 +55,7 @@ class TestLight(unittest.TestCase):
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
light.turn_on(
common.turn_on(
self.hass,
entity_id='entity_id_val',
transition='transition_val',
@ -88,7 +89,7 @@ class TestLight(unittest.TestCase):
turn_off_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_OFF)
light.turn_off(
common.turn_off(
self.hass, entity_id='entity_id_val', transition='transition_val')
self.hass.block_till_done()
@ -105,7 +106,7 @@ class TestLight(unittest.TestCase):
toggle_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TOGGLE)
light.toggle(
common.toggle(
self.hass, entity_id='entity_id_val', transition='transition_val')
self.hass.block_till_done()
@ -135,8 +136,8 @@ class TestLight(unittest.TestCase):
self.assertFalse(light.is_on(self.hass, dev3.entity_id))
# Test basic turn_on, turn_off, toggle services
light.turn_off(self.hass, entity_id=dev1.entity_id)
light.turn_on(self.hass, entity_id=dev2.entity_id)
common.turn_off(self.hass, entity_id=dev1.entity_id)
common.turn_on(self.hass, entity_id=dev2.entity_id)
self.hass.block_till_done()
@ -144,7 +145,7 @@ class TestLight(unittest.TestCase):
self.assertTrue(light.is_on(self.hass, dev2.entity_id))
# turn on all lights
light.turn_on(self.hass)
common.turn_on(self.hass)
self.hass.block_till_done()
@ -153,7 +154,7 @@ class TestLight(unittest.TestCase):
self.assertTrue(light.is_on(self.hass, dev3.entity_id))
# turn off all lights
light.turn_off(self.hass)
common.turn_off(self.hass)
self.hass.block_till_done()
@ -162,7 +163,7 @@ class TestLight(unittest.TestCase):
self.assertFalse(light.is_on(self.hass, dev3.entity_id))
# toggle all lights
light.toggle(self.hass)
common.toggle(self.hass)
self.hass.block_till_done()
@ -171,7 +172,7 @@ class TestLight(unittest.TestCase):
self.assertTrue(light.is_on(self.hass, dev3.entity_id))
# toggle all lights
light.toggle(self.hass)
common.toggle(self.hass)
self.hass.block_till_done()
@ -180,12 +181,12 @@ class TestLight(unittest.TestCase):
self.assertFalse(light.is_on(self.hass, dev3.entity_id))
# Ensure all attributes process correctly
light.turn_on(self.hass, dev1.entity_id,
common.turn_on(self.hass, dev1.entity_id,
transition=10, brightness=20, color_name='blue')
light.turn_on(
common.turn_on(
self.hass, dev2.entity_id, rgb_color=(255, 255, 255),
white_value=255)
light.turn_on(self.hass, dev3.entity_id, xy_color=(.4, .6))
common.turn_on(self.hass, dev3.entity_id, xy_color=(.4, .6))
self.hass.block_till_done()
@ -211,9 +212,9 @@ class TestLight(unittest.TestCase):
prof_name, prof_h, prof_s, prof_bri = 'relax', 35.932, 69.412, 144
# Test light profiles
light.turn_on(self.hass, dev1.entity_id, profile=prof_name)
common.turn_on(self.hass, dev1.entity_id, profile=prof_name)
# Specify a profile and a brightness attribute to overwrite it
light.turn_on(
common.turn_on(
self.hass, dev2.entity_id,
profile=prof_name, brightness=100)
@ -232,10 +233,10 @@ class TestLight(unittest.TestCase):
}, data)
# Test bad data
light.turn_on(self.hass)
light.turn_on(self.hass, dev1.entity_id, profile="nonexisting")
light.turn_on(self.hass, dev2.entity_id, xy_color=["bla-di-bla", 5])
light.turn_on(self.hass, dev3.entity_id, rgb_color=[255, None, 2])
common.turn_on(self.hass)
common.turn_on(self.hass, dev1.entity_id, profile="nonexisting")
common.turn_on(self.hass, dev2.entity_id, xy_color=["bla-di-bla", 5])
common.turn_on(self.hass, dev3.entity_id, rgb_color=[255, None, 2])
self.hass.block_till_done()
@ -249,13 +250,13 @@ class TestLight(unittest.TestCase):
self.assertEqual({}, data)
# faulty attributes will not trigger a service call
light.turn_on(
common.turn_on(
self.hass, dev1.entity_id,
profile=prof_name, brightness='bright')
light.turn_on(
common.turn_on(
self.hass, dev1.entity_id,
rgb_color='yellowish')
light.turn_on(
common.turn_on(
self.hass, dev2.entity_id,
white_value='high')
@ -299,7 +300,7 @@ class TestLight(unittest.TestCase):
dev1, _, _ = platform.DEVICES
light.turn_on(self.hass, dev1.entity_id, profile='test')
common.turn_on(self.hass, dev1.entity_id, profile='test')
self.hass.block_till_done()
@ -340,7 +341,7 @@ class TestLight(unittest.TestCase):
))
dev, _, _ = platform.DEVICES
light.turn_on(self.hass, dev.entity_id)
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call('turn_on')
self.assertEqual({
@ -380,7 +381,7 @@ class TestLight(unittest.TestCase):
dev = next(filter(lambda x: x.entity_id == 'light.ceiling_2',
platform.DEVICES))
light.turn_on(self.hass, dev.entity_id)
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call('turn_on')
self.assertEqual({

10
tests/components/light/test_litejet.py
View file

@ -5,9 +5,11 @@ from unittest import mock
from homeassistant import setup
from homeassistant.components import litejet
from tests.common import get_test_home_assistant
import homeassistant.components.light as light
from tests.common import get_test_home_assistant
from tests.components.light import common
_LOGGER = logging.getLogger(__name__)
ENTITY_LIGHT = 'light.mock_load_1'
@ -78,7 +80,7 @@ class TestLiteJetLight(unittest.TestCase):
assert not light.is_on(self.hass, ENTITY_LIGHT)
light.turn_on(self.hass, ENTITY_LIGHT, brightness=102)
common.turn_on(self.hass, ENTITY_LIGHT, brightness=102)
self.hass.block_till_done()
self.mock_lj.activate_load_at.assert_called_with(
ENTITY_LIGHT_NUMBER, 39, 0)
@ -90,11 +92,11 @@ class TestLiteJetLight(unittest.TestCase):
assert not light.is_on(self.hass, ENTITY_LIGHT)
light.turn_on(self.hass, ENTITY_LIGHT)
common.turn_on(self.hass, ENTITY_LIGHT)
self.hass.block_till_done()
self.mock_lj.activate_load.assert_called_with(ENTITY_LIGHT_NUMBER)
light.turn_off(self.hass, ENTITY_LIGHT)
common.turn_off(self.hass, ENTITY_LIGHT)
self.hass.block_till_done()
self.mock_lj.deactivate_load.assert_called_with(ENTITY_LIGHT_NUMBER)

30
tests/components/light/test_mqtt.py
View file

@ -148,9 +148,11 @@ from homeassistant.const import (
import homeassistant.components.light as light
from homeassistant.components.mqtt.discovery import async_start
import homeassistant.core as ha
from tests.common import (
assert_setup_component, get_test_home_assistant, mock_mqtt_component,
async_fire_mqtt_message, fire_mqtt_message, mock_coro)
from tests.components.light import common
class TestLightMQTT(unittest.TestCase):
@ -506,7 +508,7 @@ class TestLightMQTT(unittest.TestCase):
self.assertEqual(50, state.attributes.get('white_value'))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
light.turn_on(self.hass, 'light.test')
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -515,7 +517,7 @@ class TestLightMQTT(unittest.TestCase):
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -525,9 +527,9 @@ class TestLightMQTT(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
self.mock_publish.reset_mock()
light.turn_on(self.hass, 'light.test',
common.turn_on(self.hass, 'light.test',
brightness=50, xy_color=[0.123, 0.123])
light.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 0],
common.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 0],
white_value=80)
self.hass.block_till_done()
@ -566,7 +568,7 @@ class TestLightMQTT(unittest.TestCase):
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
light.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 64])
common.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 64])
self.hass.block_till_done()
self.mock_publish.async_publish.assert_has_calls([
@ -714,7 +716,7 @@ class TestLightMQTT(unittest.TestCase):
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
light.turn_on(self.hass, 'light.test', brightness=50)
common.turn_on(self.hass, 'light.test', brightness=50)
self.hass.block_till_done()
# Should get the following MQTT messages.
@ -726,7 +728,7 @@ class TestLightMQTT(unittest.TestCase):
], any_order=True)
self.mock_publish.async_publish.reset_mock()
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -747,7 +749,7 @@ class TestLightMQTT(unittest.TestCase):
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
light.turn_on(self.hass, 'light.test', brightness=50)
common.turn_on(self.hass, 'light.test', brightness=50)
self.hass.block_till_done()
# Should get the following MQTT messages.
@ -759,7 +761,7 @@ class TestLightMQTT(unittest.TestCase):
], any_order=True)
self.mock_publish.async_publish.reset_mock()
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -783,7 +785,7 @@ class TestLightMQTT(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
# Turn on w/ no brightness - should set to max
light.turn_on(self.hass, 'light.test')
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
# Should get the following MQTT messages.
@ -792,7 +794,7 @@ class TestLightMQTT(unittest.TestCase):
'test_light/bright', 255, 0, False)
self.mock_publish.async_publish.reset_mock()
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -800,19 +802,19 @@ class TestLightMQTT(unittest.TestCase):
self.mock_publish.async_publish.reset_mock()
# Turn on w/ brightness
light.turn_on(self.hass, 'light.test', brightness=50)
common.turn_on(self.hass, 'light.test', brightness=50)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light/bright', 50, 0, False)
self.mock_publish.async_publish.reset_mock()
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
# Turn on w/ just a color to insure brightness gets
# added and sent.
light.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 0])
common.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 0])
self.hass.block_till_done()
self.mock_publish.async_publish.assert_has_calls([

20
tests/components/light/test_mqtt_json.py
View file

@ -98,9 +98,11 @@ from homeassistant.const import (
ATTR_SUPPORTED_FEATURES)
import homeassistant.components.light as light
import homeassistant.core as ha
from tests.common import (
get_test_home_assistant, mock_mqtt_component, fire_mqtt_message,
assert_setup_component, mock_coro)
from tests.components.light import common
class TestLightMQTTJSON(unittest.TestCase):
@ -315,7 +317,7 @@ class TestLightMQTTJSON(unittest.TestCase):
self.assertEqual(191, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
light.turn_on(self.hass, 'light.test')
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -324,7 +326,7 @@ class TestLightMQTTJSON(unittest.TestCase):
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -333,7 +335,7 @@ class TestLightMQTTJSON(unittest.TestCase):
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
light.turn_on(self.hass, 'light.test',
common.turn_on(self.hass, 'light.test',
brightness=50, color_temp=155, effect='colorloop',
white_value=170)
self.hass.block_till_done()
@ -361,7 +363,7 @@ class TestLightMQTTJSON(unittest.TestCase):
self.assertEqual(170, state.attributes['white_value'])
# Test a color command
light.turn_on(self.hass, 'light.test',
common.turn_on(self.hass, 'light.test',
brightness=50, hs_color=(125, 100))
self.hass.block_till_done()
@ -398,7 +400,7 @@ class TestLightMQTTJSON(unittest.TestCase):
}
})
light.turn_on(self.hass, 'light.test', hs_color=(180.0, 50.0))
common.turn_on(self.hass, 'light.test', hs_color=(180.0, 50.0))
self.hass.block_till_done()
message_json = json.loads(
@ -427,7 +429,7 @@ class TestLightMQTTJSON(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
light.turn_on(self.hass, 'light.test', flash="short")
common.turn_on(self.hass, 'light.test', flash="short")
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
@ -443,7 +445,7 @@ class TestLightMQTTJSON(unittest.TestCase):
self.assertEqual("ON", message_json["state"])
self.mock_publish.async_publish.reset_mock()
light.turn_on(self.hass, 'light.test', flash="long")
common.turn_on(self.hass, 'light.test', flash="long")
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
@ -474,7 +476,7 @@ class TestLightMQTTJSON(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
light.turn_on(self.hass, 'light.test', transition=10)
common.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
@ -490,7 +492,7 @@ class TestLightMQTTJSON(unittest.TestCase):
self.assertEqual("ON", message_json["state"])
# Transition back off
light.turn_off(self.hass, 'light.test', transition=10)
common.turn_off(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',

19
tests/components/light/test_mqtt_template.py
View file

@ -34,9 +34,11 @@ from homeassistant.const import (
STATE_ON, STATE_OFF, STATE_UNAVAILABLE, ATTR_ASSUMED_STATE)
import homeassistant.components.light as light
import homeassistant.core as ha
from tests.common import (
get_test_home_assistant, mock_mqtt_component, fire_mqtt_message,
assert_setup_component, mock_coro)
from tests.components.light import common
class TestLightMQTTTemplate(unittest.TestCase):
@ -244,7 +246,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
# turn on the light
light.turn_on(self.hass, 'light.test')
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -254,7 +256,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.assertEqual(STATE_ON, state.state)
# turn the light off
light.turn_off(self.hass, 'light.test')
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -264,7 +266,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
# turn on the light with brightness, color
light.turn_on(self.hass, 'light.test', brightness=50,
common.turn_on(self.hass, 'light.test', brightness=50,
rgb_color=[75, 75, 75])
self.hass.block_till_done()
@ -273,7 +275,8 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.mock_publish.async_publish.reset_mock()
# turn on the light with color temp and white val
light.turn_on(self.hass, 'light.test', color_temp=200, white_value=139)
common.turn_on(self.hass, 'light.test',
color_temp=200, white_value=139)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -305,7 +308,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
# short flash
light.turn_on(self.hass, 'light.test', flash='short')
common.turn_on(self.hass, 'light.test', flash='short')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -313,7 +316,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.mock_publish.async_publish.reset_mock()
# long flash
light.turn_on(self.hass, 'light.test', flash='long')
common.turn_on(self.hass, 'light.test', flash='long')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -336,7 +339,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.assertEqual(STATE_OFF, state.state)
# transition on
light.turn_on(self.hass, 'light.test', transition=10)
common.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -344,7 +347,7 @@ class TestLightMQTTTemplate(unittest.TestCase):
self.mock_publish.async_publish.reset_mock()
# transition off
light.turn_off(self.hass, 'light.test', transition=4)
common.turn_off(self.hass, 'light.test', transition=4)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(

13
tests/components/light/test_template.py
View file

@ -3,12 +3,13 @@ import logging
from homeassistant.core import callback
from homeassistant import setup
import homeassistant.components as core
from homeassistant.components.light import ATTR_BRIGHTNESS
from homeassistant.const import STATE_ON, STATE_OFF
from tests.common import (
get_test_home_assistant, assert_setup_component)
from tests.components.light import common
_LOGGER = logging.getLogger(__name__)
@ -378,7 +379,7 @@ class TestTemplateLight:
state = self.hass.states.get('light.test_template_light')
assert state.state == STATE_OFF
core.light.turn_on(self.hass, 'light.test_template_light')
common.turn_on(self.hass, 'light.test_template_light')
self.hass.block_till_done()
assert len(self.calls) == 1
@ -418,7 +419,7 @@ class TestTemplateLight:
state = self.hass.states.get('light.test_template_light')
assert state.state == STATE_OFF
core.light.turn_on(self.hass, 'light.test_template_light')
common.turn_on(self.hass, 'light.test_template_light')
self.hass.block_till_done()
state = self.hass.states.get('light.test_template_light')
@ -461,7 +462,7 @@ class TestTemplateLight:
state = self.hass.states.get('light.test_template_light')
assert state.state == STATE_ON
core.light.turn_off(self.hass, 'light.test_template_light')
common.turn_off(self.hass, 'light.test_template_light')
self.hass.block_till_done()
assert len(self.calls) == 1
@ -498,7 +499,7 @@ class TestTemplateLight:
state = self.hass.states.get('light.test_template_light')
assert state.state == STATE_OFF
core.light.turn_off(self.hass, 'light.test_template_light')
common.turn_off(self.hass, 'light.test_template_light')
self.hass.block_till_done()
assert len(self.calls) == 1
@ -538,7 +539,7 @@ class TestTemplateLight:
state = self.hass.states.get('light.test_template_light')
assert state.attributes.get('brightness') is None
core.light.turn_on(
common.turn_on(
self.hass, 'light.test_template_light', **{ATTR_BRIGHTNESS: 124})
self.hass.block_till_done()
assert len(self.calls) == 1

3
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.light import common as common_light
from tests.components.scene import common
@ -26,7 +27,7 @@ class TestScene(unittest.TestCase):
self.light_1, self.light_2 = test_light.DEVICES[0:2]
light.turn_off(
common_light.turn_off(
self.hass, [self.light_1.entity_id, self.light_2.entity_id])
self.hass.block_till_done()

39
tests/components/switch/common.py Normal file
View file

@ -0,0 +1,39 @@
"""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.switch import DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
from homeassistant.core import callback
from homeassistant.loader import bind_hass
@bind_hass
def turn_on(hass, entity_id=None):
"""Turn all or specified switch on."""
hass.add_job(async_turn_on, hass, entity_id)
@callback
@bind_hass
def async_turn_on(hass, entity_id=None):
"""Turn all or specified switch on."""
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_TURN_ON, data))
@bind_hass
def turn_off(hass, entity_id=None):
"""Turn all or specified switch off."""
hass.add_job(async_turn_off, hass, entity_id)
@callback
@bind_hass
def async_turn_off(hass, entity_id=None):
"""Turn all or specified switch off."""
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.async_add_job(
hass.services.async_call(DOMAIN, SERVICE_TURN_OFF, data))

17
tests/components/switch/test_command_line.py
View file

@ -10,6 +10,7 @@ import homeassistant.components.switch as switch
import homeassistant.components.switch.command_line as command_line
from tests.common import get_test_home_assistant
from tests.components.switch import common
# pylint: disable=invalid-name
@ -44,13 +45,13 @@ class TestCommandSwitch(unittest.TestCase):
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
switch.turn_on(self.hass, 'switch.test')
common.turn_on(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.test')
common.turn_off(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
@ -78,13 +79,13 @@ class TestCommandSwitch(unittest.TestCase):
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
switch.turn_on(self.hass, 'switch.test')
common.turn_on(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.test')
common.turn_off(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
@ -114,13 +115,13 @@ class TestCommandSwitch(unittest.TestCase):
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
switch.turn_on(self.hass, 'switch.test')
common.turn_on(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.test')
common.turn_off(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
@ -147,13 +148,13 @@ class TestCommandSwitch(unittest.TestCase):
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
switch.turn_on(self.hass, 'switch.test')
common.turn_on(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.test')
common.turn_off(self.hass, 'switch.test')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')

36
tests/components/switch/test_flux.py
View file

@ -11,6 +11,8 @@ import homeassistant.util.dt as dt_util
from tests.common import (
assert_setup_component, get_test_home_assistant, fire_time_changed,
mock_service)
from tests.components.light import common as common_light
from tests.components.switch import common
class TestSwitchFlux(unittest.TestCase):
@ -147,7 +149,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -193,7 +195,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -240,7 +242,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -286,7 +288,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -334,7 +336,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -383,7 +385,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -434,7 +436,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -484,7 +486,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -534,7 +536,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -584,7 +586,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -633,7 +635,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -681,7 +683,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -698,9 +700,9 @@ class TestSwitchFlux(unittest.TestCase):
{light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1, dev2, dev3 = platform.DEVICES
light.turn_on(self.hass, entity_id=dev2.entity_id)
common_light.turn_on(self.hass, entity_id=dev2.entity_id)
self.hass.block_till_done()
light.turn_on(self.hass, entity_id=dev3.entity_id)
common_light.turn_on(self.hass, entity_id=dev3.entity_id)
self.hass.block_till_done()
state = self.hass.states.get(dev1.entity_id)
@ -743,7 +745,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -794,7 +796,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
@ -838,7 +840,7 @@ class TestSwitchFlux(unittest.TestCase):
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.turn_on(self.hass, 'switch.flux')
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()

9
tests/components/switch/test_init.py
View file

@ -8,6 +8,7 @@ from homeassistant.components import switch
from homeassistant.const import STATE_ON, STATE_OFF, CONF_PLATFORM
from tests.common import get_test_home_assistant
from tests.components.switch import common
class TestSwitch(unittest.TestCase):
@ -41,8 +42,8 @@ class TestSwitch(unittest.TestCase):
self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id))
self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id))
switch.turn_off(self.hass, self.switch_1.entity_id)
switch.turn_on(self.hass, self.switch_2.entity_id)
common.turn_off(self.hass, self.switch_1.entity_id)
common.turn_on(self.hass, self.switch_2.entity_id)
self.hass.block_till_done()
@ -51,7 +52,7 @@ class TestSwitch(unittest.TestCase):
self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id))
# Turn all off
switch.turn_off(self.hass)
common.turn_off(self.hass)
self.hass.block_till_done()
@ -64,7 +65,7 @@ class TestSwitch(unittest.TestCase):
self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id))
# Turn all on
switch.turn_on(self.hass)
common.turn_on(self.hass)
self.hass.block_till_done()

8
tests/components/switch/test_litejet.py
View file

@ -5,9 +5,11 @@ from unittest import mock
from homeassistant import setup
from homeassistant.components import litejet
from tests.common import get_test_home_assistant
import homeassistant.components.switch as switch
from tests.common import get_test_home_assistant
from tests.components.switch import common
_LOGGER = logging.getLogger(__name__)
ENTITY_SWITCH = 'switch.mock_switch_1'
@ -88,11 +90,11 @@ class TestLiteJetSwitch(unittest.TestCase):
assert not switch.is_on(self.hass, ENTITY_SWITCH)
switch.turn_on(self.hass, ENTITY_SWITCH)
common.turn_on(self.hass, ENTITY_SWITCH)
self.hass.block_till_done()
self.mock_lj.press_switch.assert_called_with(ENTITY_SWITCH_NUMBER)
switch.turn_off(self.hass, ENTITY_SWITCH)
common.turn_off(self.hass, ENTITY_SWITCH)
self.hass.block_till_done()
self.mock_lj.release_switch.assert_called_with(ENTITY_SWITCH_NUMBER)

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

@ -8,9 +8,11 @@ from homeassistant.const import STATE_ON, STATE_OFF, STATE_UNAVAILABLE,\
import homeassistant.core as ha
import homeassistant.components.switch as switch
from homeassistant.components.mqtt.discovery import async_start
from tests.common import (
mock_mqtt_component, fire_mqtt_message, get_test_home_assistant, mock_coro,
async_mock_mqtt_component, async_fire_mqtt_message)
from tests.components.switch import common
class TestSwitchMQTT(unittest.TestCase):
@ -75,7 +77,7 @@ class TestSwitchMQTT(unittest.TestCase):
self.assertEqual(STATE_ON, state.state)
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
switch.turn_on(self.hass, 'switch.test')
common.turn_on(self.hass, 'switch.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
@ -84,7 +86,7 @@ class TestSwitchMQTT(unittest.TestCase):
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.test')
common.turn_off(self.hass, 'switch.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(

6
tests/components/switch/test_template.py
View file

@ -1,11 +1,11 @@
"""The tests for the Template switch platform."""
from homeassistant.core import callback
from homeassistant import setup
import homeassistant.components as core
from homeassistant.const import STATE_ON, STATE_OFF
from tests.common import (
get_test_home_assistant, assert_setup_component)
from tests.components.switch import common
class TestTemplateSwitch:
@ -406,7 +406,7 @@ class TestTemplateSwitch:
state = self.hass.states.get('switch.test_template_switch')
assert state.state == STATE_OFF
core.switch.turn_on(self.hass, 'switch.test_template_switch')
common.turn_on(self.hass, 'switch.test_template_switch')
self.hass.block_till_done()
assert len(self.calls) == 1
@ -442,7 +442,7 @@ class TestTemplateSwitch:
state = self.hass.states.get('switch.test_template_switch')
assert state.state == STATE_ON
core.switch.turn_off(self.hass, 'switch.test_template_switch')
common.turn_off(self.hass, 'switch.test_template_switch')
self.hass.block_till_done()
assert len(self.calls) == 1

15
tests/components/switch/test_wake_on_lan.py
View file

@ -7,6 +7,7 @@ from homeassistant.const import STATE_ON, STATE_OFF
import homeassistant.components.switch as switch
from tests.common import get_test_home_assistant, mock_service
from tests.components.switch import common
TEST_STATE = None
@ -59,13 +60,13 @@ class TestWOLSwitch(unittest.TestCase):
TEST_STATE = True
switch.turn_on(self.hass, 'switch.wake_on_lan')
common.turn_on(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
state = self.hass.states.get('switch.wake_on_lan')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.wake_on_lan')
common.turn_off(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
state = self.hass.states.get('switch.wake_on_lan')
@ -91,7 +92,7 @@ class TestWOLSwitch(unittest.TestCase):
TEST_STATE = True
switch.turn_on(self.hass, 'switch.wake_on_lan')
common.turn_on(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
state = self.hass.states.get('switch.wake_on_lan')
@ -123,7 +124,7 @@ class TestWOLSwitch(unittest.TestCase):
state = self.hass.states.get('switch.wake_on_lan')
self.assertEqual(STATE_OFF, state.state)
switch.turn_on(self.hass, 'switch.wake_on_lan')
common.turn_on(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
@patch('wakeonlan.send_magic_packet', new=send_magic_packet)
@ -149,7 +150,7 @@ class TestWOLSwitch(unittest.TestCase):
TEST_STATE = True
switch.turn_on(self.hass, 'switch.wake_on_lan')
common.turn_on(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
state = self.hass.states.get('switch.wake_on_lan')
@ -158,7 +159,7 @@ class TestWOLSwitch(unittest.TestCase):
TEST_STATE = False
switch.turn_off(self.hass, 'switch.wake_on_lan')
common.turn_off(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
state = self.hass.states.get('switch.wake_on_lan')
@ -185,7 +186,7 @@ class TestWOLSwitch(unittest.TestCase):
TEST_STATE = True
switch.turn_on(self.hass, 'switch.wake_on_lan')
common.turn_on(self.hass, 'switch.wake_on_lan')
self.hass.block_till_done()
state = self.hass.states.get('switch.wake_on_lan')

7
tests/components/test_device_sun_light_trigger.py
View file

@ -12,6 +12,7 @@ from homeassistant.components import (
from homeassistant.util import dt as dt_util
from tests.common import get_test_home_assistant, fire_time_changed
from tests.components.light import common as common_light
class TestDeviceSunLightTrigger(unittest.TestCase):
@ -68,7 +69,7 @@ class TestDeviceSunLightTrigger(unittest.TestCase):
self.hass, device_sun_light_trigger.DOMAIN, {
device_sun_light_trigger.DOMAIN: {}}))
light.turn_off(self.hass)
common_light.turn_off(self.hass)
self.hass.block_till_done()
@ -81,7 +82,7 @@ class TestDeviceSunLightTrigger(unittest.TestCase):
def test_lights_turn_off_when_everyone_leaves(self):
"""Test lights turn off when everyone leaves the house."""
light.turn_on(self.hass)
common_light.turn_on(self.hass)
self.hass.block_till_done()
@ -100,7 +101,7 @@ class TestDeviceSunLightTrigger(unittest.TestCase):
"""Test lights turn on when coming home after sun set."""
test_time = datetime(2017, 4, 5, 3, 2, 3, tzinfo=dt_util.UTC)
with patch('homeassistant.util.dt.utcnow', return_value=test_time):
light.turn_off(self.hass)
common_light.turn_off(self.hass)
self.hass.block_till_done()
self.assertTrue(setup_component(

60
tests/components/test_script.py
View file

@ -3,9 +3,13 @@
import unittest
from unittest.mock import patch
from homeassistant.core import Context, callback
from homeassistant.setup import setup_component
from homeassistant.components import script
from homeassistant.components.script import DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID, SERVICE_RELOAD, SERVICE_TOGGLE, SERVICE_TURN_OFF)
from homeassistant.core import Context, callback, split_entity_id
from homeassistant.loader import bind_hass
from homeassistant.setup import setup_component
from tests.common import get_test_home_assistant
@ -13,6 +17,44 @@ from tests.common import get_test_home_assistant
ENTITY_ID = 'script.test'
@bind_hass
def turn_on(hass, entity_id, variables=None, context=None):
"""Turn script on.
This is a legacy helper method. Do not use it for new tests.
"""
_, object_id = split_entity_id(entity_id)
hass.services.call(DOMAIN, object_id, variables, context=context)
@bind_hass
def turn_off(hass, entity_id):
"""Turn script on.
This is a legacy helper method. Do not use it for new tests.
"""
hass.services.call(DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: entity_id})
@bind_hass
def toggle(hass, entity_id):
"""Toggle the script.
This is a legacy helper method. Do not use it for new tests.
"""
hass.services.call(DOMAIN, SERVICE_TOGGLE, {ATTR_ENTITY_ID: entity_id})
@bind_hass
def reload(hass):
"""Reload script component.
This is a legacy helper method. Do not use it for new tests.
"""
hass.services.call(DOMAIN, SERVICE_RELOAD)
class TestScriptComponent(unittest.TestCase):
"""Test the Script component."""
@ -76,17 +118,17 @@ class TestScriptComponent(unittest.TestCase):
}
})
script.turn_on(self.hass, ENTITY_ID)
turn_on(self.hass, ENTITY_ID)
self.hass.block_till_done()
self.assertTrue(script.is_on(self.hass, ENTITY_ID))
self.assertEqual(0, len(events))
# Calling turn_on a second time should not advance the script
script.turn_on(self.hass, ENTITY_ID)
turn_on(self.hass, ENTITY_ID)
self.hass.block_till_done()
self.assertEqual(0, len(events))
script.turn_off(self.hass, ENTITY_ID)
turn_off(self.hass, ENTITY_ID)
self.hass.block_till_done()
self.assertFalse(script.is_on(self.hass, ENTITY_ID))
self.assertEqual(0, len(events))
@ -121,12 +163,12 @@ class TestScriptComponent(unittest.TestCase):
}
})
script.toggle(self.hass, ENTITY_ID)
toggle(self.hass, ENTITY_ID)
self.hass.block_till_done()
self.assertTrue(script.is_on(self.hass, ENTITY_ID))
self.assertEqual(0, len(events))
script.toggle(self.hass, ENTITY_ID)
toggle(self.hass, ENTITY_ID)
self.hass.block_till_done()
self.assertFalse(script.is_on(self.hass, ENTITY_ID))
self.assertEqual(0, len(events))
@ -156,7 +198,7 @@ class TestScriptComponent(unittest.TestCase):
},
})
script.turn_on(self.hass, ENTITY_ID, {
turn_on(self.hass, ENTITY_ID, {
'greeting': 'world'
}, context=context)
@ -204,7 +246,7 @@ class TestScriptComponent(unittest.TestCase):
}}}):
with patch('homeassistant.config.find_config_file',
return_value=''):
script.reload(self.hass)
reload(self.hass)
self.hass.block_till_done()
assert self.hass.states.get(ENTITY_ID) is None

4
tests/test_loader.py
View file

@ -79,10 +79,10 @@ def test_component_loader_non_existing(hass):
@asyncio.coroutine
def test_component_wrapper(hass):
"""Test component wrapper."""
calls = async_mock_service(hass, 'light', 'turn_on')
calls = async_mock_service(hass, 'persistent_notification', 'create')
components = loader.Components(hass)
components.light.async_turn_on('light.test')
components.persistent_notification.async_create('message')
yield from hass.async_block_till_done()
assert len(calls) == 1