Multiple Hue activate scene (#41353)

This commit is contained in:
fnurgel authored and GitHub committed 2020-10-11 21:01:49 +02:00
1 parent 1c6d0d138d
commit 366006e0aa
5 files changed
+402 -17

No files matched your search

+35 -1
View File
@@ -3,6 +3,7 @@ from collections import deque
from aiohue.groups import Groups
from aiohue.lights import Lights
from aiohue.scenes import Scenes
from aiohue.sensors import Sensors
import pytest
@@ -10,7 +11,7 @@ from homeassistant import config_entries
from homeassistant.components import hue
from homeassistant.components.hue import sensor_base as hue_sensor_base
from tests.async_mock import Mock, patch
from tests.async_mock import AsyncMock, Mock, patch
@pytest.fixture(autouse=True)
@@ -65,6 +66,39 @@ def create_mock_bridge(hass):
return bridge
@pytest.fixture
def mock_api(hass):
"""Mock the Hue api."""
api = Mock(initialize=AsyncMock())
api.mock_requests = []
api.mock_light_responses = deque()
api.mock_group_responses = deque()
api.mock_sensor_responses = deque()
api.mock_scene_responses = deque()
async def mock_request(method, path, **kwargs):
kwargs["method"] = method
kwargs["path"] = path
api.mock_requests.append(kwargs)
if path == "lights":
return api.mock_light_responses.popleft()
if path == "groups":
return api.mock_group_responses.popleft()
if path == "sensors":
return api.mock_sensor_responses.popleft()
if path == "scenes":
return api.mock_scene_responses.popleft()
return None
api.config.apiversion = "9.9.9"
api.lights = Lights({}, mock_request)
api.groups = Groups({}, mock_request)
api.sensors = Sensors({}, mock_request)
api.scenes = Scenes({}, mock_request)
return api
@pytest.fixture
def mock_bridge(hass):
"""Mock a Hue bridge."""
+131 -1
View File
@@ -1,6 +1,8 @@
"""Test Hue bridge."""
import pytest
from homeassistant import config_entries
from homeassistant.components import hue
from homeassistant.components.hue import bridge, errors
from homeassistant.components.hue.const import (
CONF_ALLOW_HUE_GROUPS,
@@ -88,7 +90,7 @@ async def test_reset_unloads_entry_if_setup(hass):
), patch.object(hass.config_entries, "async_forward_entry_setup") as mock_forward:
assert await hue_bridge.async_setup() is True
assert len(hass.services.async_services()) == 1
assert len(hass.services.async_services()) == 0
assert len(mock_forward.mock_calls) == 3
with patch.object(
@@ -120,3 +122,131 @@ async def test_handle_unauthorized(hass):
assert hue_bridge.authorized is False
assert len(mock_create.mock_calls) == 1
assert mock_create.mock_calls[0][1][1] == "1.2.3.4"
GROUP_RESPONSE = {
"group_1": {
"name": "Group 1",
"lights": ["1", "2"],
"type": "LightGroup",
"action": {
"on": True,
"bri": 254,
"hue": 10000,
"sat": 254,
"effect": "none",
"xy": [0.5, 0.5],
"ct": 250,
"alert": "select",
"colormode": "ct",
},
"state": {"any_on": True, "all_on": False},
}
}
SCENE_RESPONSE = {
"scene_1": {
"name": "Cozy dinner",
"lights": ["1", "2"],
"owner": "ffffffffe0341b1b376a2389376a2389",
"recycle": True,
"locked": False,
"appdata": {"version": 1, "data": "myAppData"},
"picture": "",
"lastupdated": "2015-12-03T10:09:22",
"version": 2,
}
}
async def test_hue_activate_scene(hass, mock_api):
"""Test successful hue_activate_scene."""
config_entry = config_entries.ConfigEntry(
1,
hue.DOMAIN,
"Mock Title",
{"host": "mock-host", "username": "mock-username"},
"test",
config_entries.CONN_CLASS_LOCAL_POLL,
system_options={},
options={CONF_ALLOW_HUE_GROUPS: True, CONF_ALLOW_UNREACHABLE: False},
)
hue_bridge = bridge.HueBridge(hass, config_entry)
mock_api.mock_group_responses.append(GROUP_RESPONSE)
mock_api.mock_scene_responses.append(SCENE_RESPONSE)
with patch("aiohue.Bridge", return_value=mock_api), patch.object(
hass.config_entries, "async_forward_entry_setup"
):
assert await hue_bridge.async_setup() is True
assert hue_bridge.api is mock_api
call = Mock()
call.data = {"group_name": "Group 1", "scene_name": "Cozy dinner"}
with patch("aiohue.Bridge", return_value=mock_api):
assert await hue_bridge.hue_activate_scene(call) is None
assert len(mock_api.mock_requests) == 3
assert mock_api.mock_requests[2]["json"]["scene"] == "scene_1"
assert mock_api.mock_requests[2]["path"] == "groups/group_1/action"
async def test_hue_activate_scene_group_not_found(hass, mock_api):
"""Test failed hue_activate_scene due to missing group."""
config_entry = config_entries.ConfigEntry(
1,
hue.DOMAIN,
"Mock Title",
{"host": "mock-host", "username": "mock-username"},
"test",
config_entries.CONN_CLASS_LOCAL_POLL,
system_options={},
options={CONF_ALLOW_HUE_GROUPS: True, CONF_ALLOW_UNREACHABLE: False},
)
hue_bridge = bridge.HueBridge(hass, config_entry)
mock_api.mock_group_responses.append({})
mock_api.mock_scene_responses.append(SCENE_RESPONSE)
with patch("aiohue.Bridge", return_value=mock_api), patch.object(
hass.config_entries, "async_forward_entry_setup"
):
assert await hue_bridge.async_setup() is True
assert hue_bridge.api is mock_api
call = Mock()
call.data = {"group_name": "Group 1", "scene_name": "Cozy dinner"}
with patch("aiohue.Bridge", return_value=mock_api):
assert await hue_bridge.hue_activate_scene(call) is False
async def test_hue_activate_scene_scene_not_found(hass, mock_api):
"""Test failed hue_activate_scene due to missing scene."""
config_entry = config_entries.ConfigEntry(
1,
hue.DOMAIN,
"Mock Title",
{"host": "mock-host", "username": "mock-username"},
"test",
config_entries.CONN_CLASS_LOCAL_POLL,
system_options={},
options={CONF_ALLOW_HUE_GROUPS: True, CONF_ALLOW_UNREACHABLE: False},
)
hue_bridge = bridge.HueBridge(hass, config_entry)
mock_api.mock_group_responses.append(GROUP_RESPONSE)
mock_api.mock_scene_responses.append({})
with patch("aiohue.Bridge", return_value=mock_api), patch.object(
hass.config_entries, "async_forward_entry_setup"
):
assert await hue_bridge.async_setup() is True
assert hue_bridge.api is mock_api
call = Mock()
call.data = {"group_name": "Group 1", "scene_name": "Cozy dinner"}
with patch("aiohue.Bridge", return_value=mock_api):
assert await hue_bridge.hue_activate_scene(call) is False
@@ -0,0 +1,185 @@
"""Test Hue init with multiple bridges."""
from aiohue.groups import Groups
from aiohue.lights import Lights
from aiohue.scenes import Scenes
from aiohue.sensors import Sensors
import pytest
from homeassistant import config_entries
from homeassistant.components import hue
from homeassistant.components.hue import sensor_base as hue_sensor_base
from homeassistant.setup import async_setup_component
from tests.async_mock import Mock, patch
async def setup_component(hass):
"""Hue component."""
with patch.object(hue, "async_setup_entry", return_value=True):
assert (
await async_setup_component(
hass,
hue.DOMAIN,
{},
)
is True
)
async def test_hue_activate_scene_both_responds(
hass, mock_bridge1, mock_bridge2, mock_config_entry1, mock_config_entry2
):
"""Test that makes both bridges successfully activate a scene."""
await setup_component(hass)
await setup_bridge(hass, mock_bridge1, mock_config_entry1)
await setup_bridge(hass, mock_bridge2, mock_config_entry2)
with patch.object(
mock_bridge1, "hue_activate_scene", return_value=None
) as mock_hue_activate_scene1, patch.object(
mock_bridge2, "hue_activate_scene", return_value=None
) as mock_hue_activate_scene2:
await hass.services.async_call(
"hue",
"hue_activate_scene",
{"group_name": "group_2", "scene_name": "my_scene"},
blocking=True,
)
mock_hue_activate_scene1.assert_called_once()
mock_hue_activate_scene2.assert_called_once()
async def test_hue_activate_scene_one_responds(
hass, mock_bridge1, mock_bridge2, mock_config_entry1, mock_config_entry2
):
"""Test that makes only one bridge successfully activate a scene."""
await setup_component(hass)
await setup_bridge(hass, mock_bridge1, mock_config_entry1)
await setup_bridge(hass, mock_bridge2, mock_config_entry2)
with patch.object(
mock_bridge1, "hue_activate_scene", return_value=None
) as mock_hue_activate_scene1, patch.object(
mock_bridge2, "hue_activate_scene", return_value=False
) as mock_hue_activate_scene2:
await hass.services.async_call(
"hue",
"hue_activate_scene",
{"group_name": "group_2", "scene_name": "my_scene"},
blocking=True,
)
mock_hue_activate_scene1.assert_called_once()
mock_hue_activate_scene2.assert_called_once()
async def test_hue_activate_scene_zero_responds(
hass, mock_bridge1, mock_bridge2, mock_config_entry1, mock_config_entry2
):
"""Test that makes no bridge successfully activate a scene."""
await setup_component(hass)
await setup_bridge(hass, mock_bridge1, mock_config_entry1)
await setup_bridge(hass, mock_bridge2, mock_config_entry2)
with patch.object(
mock_bridge1, "hue_activate_scene", return_value=False
) as mock_hue_activate_scene1, patch.object(
mock_bridge2, "hue_activate_scene", return_value=False
) as mock_hue_activate_scene2:
await hass.services.async_call(
"hue",
"hue_activate_scene",
{"group_name": "group_2", "scene_name": "my_scene"},
blocking=True,
)
# both were retried
assert mock_hue_activate_scene1.call_count == 2
assert mock_hue_activate_scene2.call_count == 2
async def setup_bridge(hass, mock_bridge, config_entry):
"""Load the Hue light platform with the provided bridge."""
mock_bridge.config_entry = config_entry
hass.data[hue.DOMAIN][config_entry.entry_id] = mock_bridge
await hass.config_entries.async_forward_entry_setup(config_entry, "light")
# To flush out the service call to update the group
await hass.async_block_till_done()
@pytest.fixture
def mock_config_entry1(hass):
"""Mock a config entry."""
return create_config_entry()
@pytest.fixture
def mock_config_entry2(hass):
"""Mock a config entry."""
return create_config_entry()
def create_config_entry():
"""Mock a config entry."""
return config_entries.ConfigEntry(
1,
hue.DOMAIN,
"Mock Title",
{"host": "mock-host"},
"test",
config_entries.CONN_CLASS_LOCAL_POLL,
system_options={},
)
@pytest.fixture
def mock_bridge1(hass):
"""Mock a Hue bridge."""
return create_mock_bridge(hass)
@pytest.fixture
def mock_bridge2(hass):
"""Mock a Hue bridge."""
return create_mock_bridge(hass)
def create_mock_bridge(hass):
"""Create a mock Hue bridge."""
bridge = Mock(
hass=hass,
available=True,
authorized=True,
allow_unreachable=False,
allow_groups=False,
api=Mock(),
reset_jobs=[],
spec=hue.HueBridge,
)
bridge.sensor_manager = hue_sensor_base.SensorManager(bridge)
bridge.mock_requests = []
async def mock_request(method, path, **kwargs):
kwargs["method"] = method
kwargs["path"] = path
bridge.mock_requests.append(kwargs)
return {}
async def async_request_call(task):
await task()
bridge.async_request_call = async_request_call
bridge.api.config.apiversion = "9.9.9"
bridge.api.lights = Lights({}, mock_request)
bridge.api.groups = Groups({}, mock_request)
bridge.api.sensors = Sensors({}, mock_request)
bridge.api.scenes = Scenes({}, mock_request)
return bridge