Rewrite scene unittest tests to pytest style test function (#41172)

This commit is contained in:
Ariana Hlavaty 2020-10-15 22:35:30 +01:00 committed by GitHub
parent 162a5d99a2
commit e28e453c08
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

View File

@ -1,149 +1,143 @@
"""The tests for the Scene component.""" """The tests for the Scene component."""
import io import io
import unittest
import pytest
from homeassistant.components import light, scene from homeassistant.components import light, scene
from homeassistant.setup import async_setup_component, setup_component from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_ON
from homeassistant.setup import async_setup_component
from homeassistant.util.yaml import loader as yaml_loader from homeassistant.util.yaml import loader as yaml_loader
from tests.common import get_test_home_assistant, mock_service from tests.common import async_mock_service
from tests.components.light import common as common_light
from tests.components.scene import common
class TestScene(unittest.TestCase): @pytest.fixture(autouse=True)
"""Test the scene component.""" def entities(hass):
"""Initialize the test light."""
platform = getattr(hass.components, "test.light")
platform.init()
yield platform.ENTITIES[0:2]
def setUp(self): # pylint: disable=invalid-name
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
test_light = getattr(self.hass.components, "test.light")
test_light.init()
assert setup_component( async def test_config_yaml_alias_anchor(hass, entities):
self.hass, light.DOMAIN, {light.DOMAIN: {"platform": "test"}} """Test the usage of YAML aliases and anchors.
)
self.hass.block_till_done()
self.light_1, self.light_2 = test_light.ENTITIES[0:2] The following test scene configuration is equivalent to:
common_light.turn_off( scene:
self.hass, [self.light_1.entity_id, self.light_2.entity_id] - name: test
) entities:
light_1: &light_1_state
state: 'on'
brightness: 100
light_2: *light_1_state
self.hass.block_till_done() When encountering a YAML alias/anchor, the PyYAML parser will use a
reference to the original dictionary, instead of creating a copy, so
care needs to be taken to not modify the original.
"""
light_1, light_2 = await setup_lights(hass, entities)
entity_state = {"state": "on", "brightness": 100}
assert not self.light_1.is_on assert await async_setup_component(
assert not self.light_2.is_on hass,
self.addCleanup(self.tear_down_cleanup) scene.DOMAIN,
{
"scene": [
{
"name": "test",
"entities": {
light_1.entity_id: entity_state,
light_2.entity_id: entity_state,
},
}
]
},
)
await hass.async_block_till_done()
def tear_down_cleanup(self): await activate(hass, "scene.test")
"""Stop everything that was started."""
self.hass.stop()
def test_config_yaml_alias_anchor(self): assert light.is_on(hass, light_1.entity_id)
"""Test the usage of YAML aliases and anchors. assert light.is_on(hass, light_2.entity_id)
assert 100 == light_1.last_call("turn_on")[1].get("brightness")
assert 100 == light_2.last_call("turn_on")[1].get("brightness")
The following test scene configuration is equivalent to:
scene: async def test_config_yaml_bool(hass, entities):
- name: test """Test parsing of booleans in yaml config."""
entities: light_1, light_2 = await setup_lights(hass, entities)
light_1: &light_1_state
state: 'on'
brightness: 100
light_2: *light_1_state
When encountering a YAML alias/anchor, the PyYAML parser will use a config = (
reference to the original dictionary, instead of creating a copy, so "scene:\n"
care needs to be taken to not modify the original. " - name: test\n"
""" " entities:\n"
entity_state = {"state": "on", "brightness": 100} f" {light_1.entity_id}: on\n"
assert setup_component( f" {light_2.entity_id}:\n"
self.hass, " state: on\n"
scene.DOMAIN, " brightness: 100\n"
{ )
"scene": [
{
"name": "test",
"entities": {
self.light_1.entity_id: entity_state,
self.light_2.entity_id: entity_state,
},
}
]
},
)
self.hass.block_till_done()
common.activate(self.hass, "scene.test") with io.StringIO(config) as file:
self.hass.block_till_done() doc = yaml_loader.yaml.safe_load(file)
assert self.light_1.is_on assert await async_setup_component(hass, scene.DOMAIN, doc)
assert self.light_2.is_on await hass.async_block_till_done()
assert 100 == self.light_1.last_call("turn_on")[1].get("brightness")
assert 100 == self.light_2.last_call("turn_on")[1].get("brightness")
def test_config_yaml_bool(self): await activate(hass, "scene.test")
"""Test parsing of booleans in yaml config."""
config = (
"scene:\n"
" - name: test\n"
" entities:\n"
f" {self.light_1.entity_id}: on\n"
f" {self.light_2.entity_id}:\n"
" state: on\n"
" brightness: 100\n"
)
with io.StringIO(config) as file: assert light.is_on(hass, light_1.entity_id)
doc = yaml_loader.yaml.safe_load(file) assert light.is_on(hass, light_2.entity_id)
assert 100 == light_2.last_call("turn_on")[1].get("brightness")
assert setup_component(self.hass, scene.DOMAIN, doc)
common.activate(self.hass, "scene.test")
self.hass.block_till_done()
assert self.light_1.is_on async def test_activate_scene(hass, entities):
assert self.light_2.is_on """Test active scene."""
assert 100 == self.light_2.last_call("turn_on")[1].get("brightness") light_1, light_2 = await setup_lights(hass, entities)
def test_activate_scene(self): assert await async_setup_component(
"""Test active scene.""" hass,
assert setup_component( scene.DOMAIN,
self.hass, {
scene.DOMAIN, "scene": [
{ {
"scene": [ "name": "test",
{ "entities": {
"name": "test", light_1.entity_id: "on",
"entities": { light_2.entity_id: {"state": "on", "brightness": 100},
self.light_1.entity_id: "on", },
self.light_2.entity_id: {"state": "on", "brightness": 100}, }
}, ]
} },
] )
}, await hass.async_block_till_done()
) await activate(hass, "scene.test")
self.hass.block_till_done()
common.activate(self.hass, "scene.test") assert light.is_on(hass, light_1.entity_id)
self.hass.block_till_done() assert light.is_on(hass, light_2.entity_id)
assert light_2.last_call("turn_on")[1].get("brightness") == 100
assert self.light_1.is_on calls = async_mock_service(hass, "light", "turn_on")
assert self.light_2.is_on
assert self.light_2.last_call("turn_on")[1].get("brightness") == 100
turn_on_calls = mock_service(self.hass, "light", "turn_on") await hass.services.async_call(
scene.DOMAIN, "turn_on", {"transition": 42, "entity_id": "scene.test"}
)
await hass.async_block_till_done()
self.hass.services.call( assert len(calls) == 1
scene.DOMAIN, "turn_on", {"transition": 42, "entity_id": "scene.test"} assert calls[0].domain == "light"
) assert calls[0].service == "turn_on"
self.hass.block_till_done() assert calls[0].data.get("transition") == 42
assert len(turn_on_calls) == 1
assert turn_on_calls[0].domain == "light" async def activate(hass, entity_id=ENTITY_MATCH_ALL):
assert turn_on_calls[0].service == "turn_on" """Activate a scene."""
assert turn_on_calls[0].data.get("transition") == 42 data = {}
if entity_id:
data[ATTR_ENTITY_ID] = entity_id
await hass.services.async_call(scene.DOMAIN, SERVICE_TURN_ON, data, blocking=True)
async def test_services_registered(hass): async def test_services_registered(hass):
@ -152,3 +146,26 @@ async def test_services_registered(hass):
assert hass.services.has_service("scene", "reload") assert hass.services.has_service("scene", "reload")
assert hass.services.has_service("scene", "turn_on") assert hass.services.has_service("scene", "turn_on")
assert hass.services.has_service("scene", "apply") assert hass.services.has_service("scene", "apply")
async def setup_lights(hass, entities):
"""Set up the light component."""
assert await async_setup_component(
hass, light.DOMAIN, {light.DOMAIN: {"platform": "test"}}
)
await hass.async_block_till_done()
light_1, light_2 = entities
await hass.services.async_call(
"light",
"turn_off",
{"entity_id": [light_1.entity_id, light_2.entity_id]},
blocking=True,
)
await hass.async_block_till_done()
assert not light.is_on(hass, light_1.entity_id)
assert not light.is_on(hass, light_2.entity_id)
return light_1, light_2