566 lines
23 KiB
Python
566 lines
23 KiB
Python
"""Philips Hue lights platform tests."""
|
|
|
|
import logging
|
|
import unittest
|
|
import unittest.mock as mock
|
|
from unittest.mock import call, MagicMock, patch
|
|
|
|
from homeassistant.components import hue
|
|
import homeassistant.components.light.hue as hue_light
|
|
|
|
from tests.common import get_test_home_assistant, MockDependency
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
HUE_LIGHT_NS = 'homeassistant.components.light.hue.'
|
|
|
|
|
|
class TestSetup(unittest.TestCase):
|
|
"""Test the Hue light platform."""
|
|
|
|
def setUp(self): # pylint: disable=invalid-name
|
|
"""Setup things to be run when tests are started."""
|
|
self.hass = get_test_home_assistant()
|
|
self.skip_teardown_stop = False
|
|
|
|
def tearDown(self):
|
|
"""Stop everything that was started."""
|
|
if not self.skip_teardown_stop:
|
|
self.hass.stop()
|
|
|
|
def setup_mocks_for_update_lights(self):
|
|
"""Set up all mocks for update_lights tests."""
|
|
self.mock_bridge = MagicMock()
|
|
self.mock_bridge.bridge_id = 'bridge-id'
|
|
self.mock_bridge.allow_hue_groups = False
|
|
self.mock_api = MagicMock()
|
|
self.mock_bridge.get_api.return_value = self.mock_api
|
|
self.mock_add_devices = MagicMock()
|
|
|
|
def setup_mocks_for_process_lights(self):
|
|
"""Set up all mocks for process_lights tests."""
|
|
self.mock_bridge = self.create_mock_bridge('host')
|
|
self.mock_api = MagicMock()
|
|
self.mock_api.get.return_value = {}
|
|
self.mock_bridge.get_api.return_value = self.mock_api
|
|
|
|
def setup_mocks_for_process_groups(self):
|
|
"""Set up all mocks for process_groups tests."""
|
|
self.mock_bridge = self.create_mock_bridge('host')
|
|
self.mock_bridge.get_group.return_value = {
|
|
'name': 'Group 0', 'state': {'any_on': True}}
|
|
|
|
self.mock_api = MagicMock()
|
|
self.mock_api.get.return_value = {}
|
|
self.mock_bridge.get_api.return_value = self.mock_api
|
|
|
|
def create_mock_bridge(self, host, allow_hue_groups=True):
|
|
"""Return a mock HueBridge with reasonable defaults."""
|
|
mock_bridge = MagicMock()
|
|
mock_bridge.bridge_id = 'bridge-id'
|
|
mock_bridge.host = host
|
|
mock_bridge.allow_hue_groups = allow_hue_groups
|
|
mock_bridge.lights = {}
|
|
mock_bridge.lightgroups = {}
|
|
return mock_bridge
|
|
|
|
def create_mock_lights(self, lights):
|
|
"""Return a dict suitable for mocking api.get('lights')."""
|
|
mock_bridge_lights = lights
|
|
|
|
for light_id, info in mock_bridge_lights.items():
|
|
if 'state' not in info:
|
|
info['state'] = {'on': False}
|
|
|
|
return mock_bridge_lights
|
|
|
|
def build_mock_light(self, bridge, light_id, name):
|
|
"""Return a mock HueLight."""
|
|
light = MagicMock()
|
|
light.bridge = bridge
|
|
light.light_id = light_id
|
|
light.name = name
|
|
return light
|
|
|
|
def test_setup_platform_no_discovery_info(self):
|
|
"""Test setup_platform without discovery info."""
|
|
self.hass.data[hue.DOMAIN] = {}
|
|
mock_add_devices = MagicMock()
|
|
|
|
hue_light.setup_platform(self.hass, {}, mock_add_devices)
|
|
|
|
mock_add_devices.assert_not_called()
|
|
|
|
def test_setup_platform_no_bridge_id(self):
|
|
"""Test setup_platform without a bridge."""
|
|
self.hass.data[hue.DOMAIN] = {}
|
|
mock_add_devices = MagicMock()
|
|
|
|
hue_light.setup_platform(self.hass, {}, mock_add_devices, {})
|
|
|
|
mock_add_devices.assert_not_called()
|
|
|
|
def test_setup_platform_one_bridge(self):
|
|
"""Test setup_platform with one bridge."""
|
|
mock_bridge = MagicMock()
|
|
self.hass.data[hue.DOMAIN] = {'10.0.0.1': mock_bridge}
|
|
mock_add_devices = MagicMock()
|
|
|
|
with patch(HUE_LIGHT_NS + 'unthrottled_update_lights') \
|
|
as mock_update_lights:
|
|
hue_light.setup_platform(
|
|
self.hass, {}, mock_add_devices,
|
|
{'bridge_id': '10.0.0.1'})
|
|
mock_update_lights.assert_called_once_with(
|
|
self.hass, mock_bridge, mock_add_devices)
|
|
|
|
def test_setup_platform_multiple_bridges(self):
|
|
"""Test setup_platform wuth multiple bridges."""
|
|
mock_bridge = MagicMock()
|
|
mock_bridge2 = MagicMock()
|
|
self.hass.data[hue.DOMAIN] = {
|
|
'10.0.0.1': mock_bridge,
|
|
'192.168.0.10': mock_bridge2,
|
|
}
|
|
mock_add_devices = MagicMock()
|
|
|
|
with patch(HUE_LIGHT_NS + 'unthrottled_update_lights') \
|
|
as mock_update_lights:
|
|
hue_light.setup_platform(
|
|
self.hass, {}, mock_add_devices,
|
|
{'bridge_id': '10.0.0.1'})
|
|
hue_light.setup_platform(
|
|
self.hass, {}, mock_add_devices,
|
|
{'bridge_id': '192.168.0.10'})
|
|
|
|
mock_update_lights.assert_has_calls([
|
|
call(self.hass, mock_bridge, mock_add_devices),
|
|
call(self.hass, mock_bridge2, mock_add_devices),
|
|
])
|
|
|
|
@MockDependency('phue')
|
|
def test_update_lights_with_no_lights(self, mock_phue):
|
|
"""Test the update_lights function when no lights are found."""
|
|
self.setup_mocks_for_update_lights()
|
|
|
|
with patch(HUE_LIGHT_NS + 'process_lights', return_value=[]) \
|
|
as mock_process_lights:
|
|
with patch(HUE_LIGHT_NS + 'process_groups', return_value=[]) \
|
|
as mock_process_groups:
|
|
with patch.object(self.hass.helpers.dispatcher,
|
|
'dispatcher_send') as dispatcher_send:
|
|
hue_light.unthrottled_update_lights(
|
|
self.hass, self.mock_bridge, self.mock_add_devices)
|
|
|
|
mock_process_lights.assert_called_once_with(
|
|
self.hass, self.mock_api, self.mock_bridge, mock.ANY)
|
|
mock_process_groups.assert_not_called()
|
|
self.mock_add_devices.assert_not_called()
|
|
dispatcher_send.assert_not_called()
|
|
|
|
@MockDependency('phue')
|
|
def test_update_lights_with_some_lights(self, mock_phue):
|
|
"""Test the update_lights function with some lights."""
|
|
self.setup_mocks_for_update_lights()
|
|
mock_lights = [
|
|
self.build_mock_light(self.mock_bridge, 42, 'some'),
|
|
self.build_mock_light(self.mock_bridge, 84, 'light'),
|
|
]
|
|
|
|
with patch(HUE_LIGHT_NS + 'process_lights',
|
|
return_value=mock_lights) as mock_process_lights:
|
|
with patch(HUE_LIGHT_NS + 'process_groups', return_value=[]) \
|
|
as mock_process_groups:
|
|
with patch.object(self.hass.helpers.dispatcher,
|
|
'dispatcher_send') as dispatcher_send:
|
|
hue_light.unthrottled_update_lights(
|
|
self.hass, self.mock_bridge, self.mock_add_devices)
|
|
|
|
mock_process_lights.assert_called_once_with(
|
|
self.hass, self.mock_api, self.mock_bridge, mock.ANY)
|
|
mock_process_groups.assert_not_called()
|
|
self.mock_add_devices.assert_called_once_with(
|
|
mock_lights)
|
|
dispatcher_send.assert_not_called()
|
|
|
|
@MockDependency('phue')
|
|
def test_update_lights_no_groups(self, mock_phue):
|
|
"""Test the update_lights function when no groups are found."""
|
|
self.setup_mocks_for_update_lights()
|
|
self.mock_bridge.allow_hue_groups = True
|
|
mock_lights = [
|
|
self.build_mock_light(self.mock_bridge, 42, 'some'),
|
|
self.build_mock_light(self.mock_bridge, 84, 'light'),
|
|
]
|
|
|
|
with patch(HUE_LIGHT_NS + 'process_lights',
|
|
return_value=mock_lights) as mock_process_lights:
|
|
with patch(HUE_LIGHT_NS + 'process_groups', return_value=[]) \
|
|
as mock_process_groups:
|
|
with patch.object(self.hass.helpers.dispatcher,
|
|
'dispatcher_send') as dispatcher_send:
|
|
hue_light.unthrottled_update_lights(
|
|
self.hass, self.mock_bridge, self.mock_add_devices)
|
|
|
|
mock_process_lights.assert_called_once_with(
|
|
self.hass, self.mock_api, self.mock_bridge, mock.ANY)
|
|
mock_process_groups.assert_called_once_with(
|
|
self.hass, self.mock_api, self.mock_bridge, mock.ANY)
|
|
self.mock_add_devices.assert_called_once_with(
|
|
mock_lights)
|
|
dispatcher_send.assert_not_called()
|
|
|
|
@MockDependency('phue')
|
|
def test_update_lights_with_lights_and_groups(self, mock_phue):
|
|
"""Test the update_lights function with both lights and groups."""
|
|
self.setup_mocks_for_update_lights()
|
|
self.mock_bridge.allow_hue_groups = True
|
|
mock_lights = [
|
|
self.build_mock_light(self.mock_bridge, 42, 'some'),
|
|
self.build_mock_light(self.mock_bridge, 84, 'light'),
|
|
]
|
|
mock_groups = [
|
|
self.build_mock_light(self.mock_bridge, 15, 'and'),
|
|
self.build_mock_light(self.mock_bridge, 72, 'groups'),
|
|
]
|
|
|
|
with patch(HUE_LIGHT_NS + 'process_lights',
|
|
return_value=mock_lights) as mock_process_lights:
|
|
with patch(HUE_LIGHT_NS + 'process_groups',
|
|
return_value=mock_groups) as mock_process_groups:
|
|
with patch.object(self.hass.helpers.dispatcher,
|
|
'dispatcher_send') as dispatcher_send:
|
|
hue_light.unthrottled_update_lights(
|
|
self.hass, self.mock_bridge, self.mock_add_devices)
|
|
|
|
mock_process_lights.assert_called_once_with(
|
|
self.hass, self.mock_api, self.mock_bridge, mock.ANY)
|
|
mock_process_groups.assert_called_once_with(
|
|
self.hass, self.mock_api, self.mock_bridge, mock.ANY)
|
|
# note that mock_lights has been modified in place and
|
|
# now contains both lights and groups
|
|
self.mock_add_devices.assert_called_once_with(
|
|
mock_lights)
|
|
dispatcher_send.assert_not_called()
|
|
|
|
@MockDependency('phue')
|
|
def test_update_lights_with_two_bridges(self, mock_phue):
|
|
"""Test the update_lights function with two bridges."""
|
|
self.setup_mocks_for_update_lights()
|
|
|
|
mock_bridge_one = self.create_mock_bridge('one', False)
|
|
mock_bridge_one_lights = self.create_mock_lights(
|
|
{1: {'name': 'b1l1'}, 2: {'name': 'b1l2'}})
|
|
|
|
mock_bridge_two = self.create_mock_bridge('two', False)
|
|
mock_bridge_two_lights = self.create_mock_lights(
|
|
{1: {'name': 'b2l1'}, 3: {'name': 'b2l3'}})
|
|
|
|
with patch('homeassistant.components.light.hue.HueLight.'
|
|
'schedule_update_ha_state'):
|
|
mock_api = MagicMock()
|
|
mock_api.get.return_value = mock_bridge_one_lights
|
|
with patch.object(mock_bridge_one, 'get_api',
|
|
return_value=mock_api):
|
|
hue_light.unthrottled_update_lights(
|
|
self.hass, mock_bridge_one, self.mock_add_devices)
|
|
|
|
mock_api = MagicMock()
|
|
mock_api.get.return_value = mock_bridge_two_lights
|
|
with patch.object(mock_bridge_two, 'get_api',
|
|
return_value=mock_api):
|
|
hue_light.unthrottled_update_lights(
|
|
self.hass, mock_bridge_two, self.mock_add_devices)
|
|
|
|
self.assertEquals(sorted(mock_bridge_one.lights.keys()), [1, 2])
|
|
self.assertEquals(sorted(mock_bridge_two.lights.keys()), [1, 3])
|
|
|
|
self.assertEquals(len(self.mock_add_devices.mock_calls), 2)
|
|
|
|
# first call
|
|
name, args, kwargs = self.mock_add_devices.mock_calls[0]
|
|
self.assertEquals(len(args), 1)
|
|
self.assertEquals(len(kwargs), 0)
|
|
|
|
# one argument, a list of lights in bridge one; each of them is an
|
|
# object of type HueLight so we can't straight up compare them
|
|
lights = args[0]
|
|
self.assertEquals(
|
|
lights[0].unique_id,
|
|
'{}.b1l1.Light.1'.format(hue_light.HueLight))
|
|
self.assertEquals(
|
|
lights[1].unique_id,
|
|
'{}.b1l2.Light.2'.format(hue_light.HueLight))
|
|
|
|
# second call works the same
|
|
name, args, kwargs = self.mock_add_devices.mock_calls[1]
|
|
self.assertEquals(len(args), 1)
|
|
self.assertEquals(len(kwargs), 0)
|
|
|
|
lights = args[0]
|
|
self.assertEquals(
|
|
lights[0].unique_id,
|
|
'{}.b2l1.Light.1'.format(hue_light.HueLight))
|
|
self.assertEquals(
|
|
lights[1].unique_id,
|
|
'{}.b2l3.Light.3'.format(hue_light.HueLight))
|
|
|
|
def test_process_lights_api_error(self):
|
|
"""Test the process_lights function when the bridge errors out."""
|
|
self.setup_mocks_for_process_lights()
|
|
self.mock_api.get.return_value = None
|
|
|
|
ret = hue_light.process_lights(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals([], ret)
|
|
self.assertEquals(self.mock_bridge.lights, {})
|
|
|
|
def test_process_lights_no_lights(self):
|
|
"""Test the process_lights function when bridge returns no lights."""
|
|
self.setup_mocks_for_process_lights()
|
|
|
|
with patch.object(self.hass.helpers.dispatcher, 'dispatcher_send') \
|
|
as mock_dispatcher_send:
|
|
ret = hue_light.process_lights(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals([], ret)
|
|
mock_dispatcher_send.assert_not_called()
|
|
self.assertEquals(self.mock_bridge.lights, {})
|
|
|
|
@patch(HUE_LIGHT_NS + 'HueLight')
|
|
def test_process_lights_some_lights(self, mock_hue_light):
|
|
"""Test the process_lights function with multiple groups."""
|
|
self.setup_mocks_for_process_lights()
|
|
self.mock_api.get.return_value = {
|
|
1: {'state': 'on'}, 2: {'state': 'off'}}
|
|
|
|
with patch.object(self.hass.helpers.dispatcher, 'dispatcher_send') \
|
|
as mock_dispatcher_send:
|
|
ret = hue_light.process_lights(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals(len(ret), 2)
|
|
mock_hue_light.assert_has_calls([
|
|
call(
|
|
1, {'state': 'on'}, self.mock_bridge, mock.ANY,
|
|
self.mock_bridge.allow_unreachable,
|
|
self.mock_bridge.allow_in_emulated_hue),
|
|
call(
|
|
2, {'state': 'off'}, self.mock_bridge, mock.ANY,
|
|
self.mock_bridge.allow_unreachable,
|
|
self.mock_bridge.allow_in_emulated_hue),
|
|
])
|
|
mock_dispatcher_send.assert_not_called()
|
|
self.assertEquals(len(self.mock_bridge.lights), 2)
|
|
|
|
@patch(HUE_LIGHT_NS + 'HueLight')
|
|
def test_process_lights_new_light(self, mock_hue_light):
|
|
"""
|
|
Test the process_lights function with new groups.
|
|
|
|
Test what happens when we already have a light and a new one shows up.
|
|
"""
|
|
self.setup_mocks_for_process_lights()
|
|
self.mock_api.get.return_value = {
|
|
1: {'state': 'on'}, 2: {'state': 'off'}}
|
|
self.mock_bridge.lights = {
|
|
1: self.build_mock_light(self.mock_bridge, 1, 'foo')}
|
|
|
|
with patch.object(self.hass.helpers.dispatcher, 'dispatcher_send') \
|
|
as mock_dispatcher_send:
|
|
ret = hue_light.process_lights(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals(len(ret), 1)
|
|
mock_hue_light.assert_has_calls([
|
|
call(
|
|
2, {'state': 'off'}, self.mock_bridge, mock.ANY,
|
|
self.mock_bridge.allow_unreachable,
|
|
self.mock_bridge.allow_in_emulated_hue),
|
|
])
|
|
mock_dispatcher_send.assert_called_once_with(
|
|
'hue_light_callback_bridge-id_1')
|
|
self.assertEquals(len(self.mock_bridge.lights), 2)
|
|
|
|
def test_process_groups_api_error(self):
|
|
"""Test the process_groups function when the bridge errors out."""
|
|
self.setup_mocks_for_process_groups()
|
|
self.mock_api.get.return_value = None
|
|
|
|
ret = hue_light.process_groups(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals([], ret)
|
|
self.assertEquals(self.mock_bridge.lightgroups, {})
|
|
|
|
def test_process_groups_no_state(self):
|
|
"""Test the process_groups function when bridge returns no status."""
|
|
self.setup_mocks_for_process_groups()
|
|
self.mock_bridge.get_group.return_value = {'name': 'Group 0'}
|
|
|
|
with patch.object(self.hass.helpers.dispatcher, 'dispatcher_send') \
|
|
as mock_dispatcher_send:
|
|
ret = hue_light.process_groups(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals([], ret)
|
|
mock_dispatcher_send.assert_not_called()
|
|
self.assertEquals(self.mock_bridge.lightgroups, {})
|
|
|
|
@patch(HUE_LIGHT_NS + 'HueLight')
|
|
def test_process_groups_some_groups(self, mock_hue_light):
|
|
"""Test the process_groups function with multiple groups."""
|
|
self.setup_mocks_for_process_groups()
|
|
self.mock_api.get.return_value = {
|
|
1: {'state': 'on'}, 2: {'state': 'off'}}
|
|
|
|
with patch.object(self.hass.helpers.dispatcher, 'dispatcher_send') \
|
|
as mock_dispatcher_send:
|
|
ret = hue_light.process_groups(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals(len(ret), 2)
|
|
mock_hue_light.assert_has_calls([
|
|
call(
|
|
1, {'state': 'on'}, self.mock_bridge, mock.ANY,
|
|
self.mock_bridge.allow_unreachable,
|
|
self.mock_bridge.allow_in_emulated_hue, True),
|
|
call(
|
|
2, {'state': 'off'}, self.mock_bridge, mock.ANY,
|
|
self.mock_bridge.allow_unreachable,
|
|
self.mock_bridge.allow_in_emulated_hue, True),
|
|
])
|
|
mock_dispatcher_send.assert_not_called()
|
|
self.assertEquals(len(self.mock_bridge.lightgroups), 2)
|
|
|
|
@patch(HUE_LIGHT_NS + 'HueLight')
|
|
def test_process_groups_new_group(self, mock_hue_light):
|
|
"""
|
|
Test the process_groups function with new groups.
|
|
|
|
Test what happens when we already have a light and a new one shows up.
|
|
"""
|
|
self.setup_mocks_for_process_groups()
|
|
self.mock_api.get.return_value = {
|
|
1: {'state': 'on'}, 2: {'state': 'off'}}
|
|
self.mock_bridge.lightgroups = {
|
|
1: self.build_mock_light(self.mock_bridge, 1, 'foo')}
|
|
|
|
with patch.object(self.hass.helpers.dispatcher, 'dispatcher_send') \
|
|
as mock_dispatcher_send:
|
|
ret = hue_light.process_groups(
|
|
self.hass, self.mock_api, self.mock_bridge, None)
|
|
|
|
self.assertEquals(len(ret), 1)
|
|
mock_hue_light.assert_has_calls([
|
|
call(
|
|
2, {'state': 'off'}, self.mock_bridge, mock.ANY,
|
|
self.mock_bridge.allow_unreachable,
|
|
self.mock_bridge.allow_in_emulated_hue, True),
|
|
])
|
|
mock_dispatcher_send.assert_called_once_with(
|
|
'hue_light_callback_bridge-id_1')
|
|
self.assertEquals(len(self.mock_bridge.lightgroups), 2)
|
|
|
|
|
|
class TestHueLight(unittest.TestCase):
|
|
"""Test the HueLight class."""
|
|
|
|
def setUp(self): # pylint: disable=invalid-name
|
|
"""Setup things to be run when tests are started."""
|
|
self.hass = get_test_home_assistant()
|
|
self.skip_teardown_stop = False
|
|
|
|
self.light_id = 42
|
|
self.mock_info = MagicMock()
|
|
self.mock_bridge = MagicMock()
|
|
self.mock_update_lights = MagicMock()
|
|
self.mock_allow_unreachable = MagicMock()
|
|
self.mock_is_group = MagicMock()
|
|
self.mock_allow_in_emulated_hue = MagicMock()
|
|
self.mock_is_group = False
|
|
|
|
def tearDown(self):
|
|
"""Stop everything that was started."""
|
|
if not self.skip_teardown_stop:
|
|
self.hass.stop()
|
|
|
|
def buildLight(
|
|
self, light_id=None, info=None, update_lights=None, is_group=None):
|
|
"""Helper to build a HueLight object with minimal fuss."""
|
|
if 'state' not in info:
|
|
on_key = 'any_on' if is_group is not None else 'on'
|
|
info['state'] = {on_key: False}
|
|
|
|
return hue_light.HueLight(
|
|
light_id if light_id is not None else self.light_id,
|
|
info if info is not None else self.mock_info,
|
|
self.mock_bridge,
|
|
(update_lights
|
|
if update_lights is not None
|
|
else self.mock_update_lights),
|
|
self.mock_allow_unreachable, self.mock_allow_in_emulated_hue,
|
|
is_group if is_group is not None else self.mock_is_group)
|
|
|
|
def test_unique_id_for_light(self):
|
|
"""Test the unique_id method with lights."""
|
|
class_name = "<class 'homeassistant.components.light.hue.HueLight'>"
|
|
|
|
light = self.buildLight(info={'uniqueid': 'foobar'})
|
|
self.assertEquals(
|
|
class_name+'.foobar',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={})
|
|
self.assertEquals(
|
|
class_name+'.Unnamed Device.Light.42',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={'name': 'my-name'})
|
|
self.assertEquals(
|
|
class_name+'.my-name.Light.42',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={'type': 'my-type'})
|
|
self.assertEquals(
|
|
class_name+'.Unnamed Device.my-type.42',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={'name': 'a name', 'type': 'my-type'})
|
|
self.assertEquals(
|
|
class_name+'.a name.my-type.42',
|
|
light.unique_id)
|
|
|
|
def test_unique_id_for_group(self):
|
|
"""Test the unique_id method with groups."""
|
|
class_name = "<class 'homeassistant.components.light.hue.HueLight'>"
|
|
|
|
light = self.buildLight(info={'uniqueid': 'foobar'}, is_group=True)
|
|
self.assertEquals(
|
|
class_name+'.foobar',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={}, is_group=True)
|
|
self.assertEquals(
|
|
class_name+'.Unnamed Device.Group.42',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={'name': 'my-name'}, is_group=True)
|
|
self.assertEquals(
|
|
class_name+'.my-name.Group.42',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(info={'type': 'my-type'}, is_group=True)
|
|
self.assertEquals(
|
|
class_name+'.Unnamed Device.my-type.42',
|
|
light.unique_id)
|
|
|
|
light = self.buildLight(
|
|
info={'name': 'a name', 'type': 'my-type'},
|
|
is_group=True)
|
|
self.assertEquals(
|
|
class_name+'.a name.my-type.42',
|
|
light.unique_id)
|