def test_flash(self):
"""Test flash."""
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_template',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'command_on_template': 'on,{{ flash }}',
'command_off_template': 'off',
'qos': 0
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
# short flash
common.turn_on(self.hass, 'light.test', flash='short')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on,short', 0, False)
self.mock_publish.async_publish.reset_mock()
# long flash
common.turn_on(self.hass, 'light.test', flash='long')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on,long', 0, False)
def test_light_profiles(self):
"""Test light profiles."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
with open(user_light_file, 'w') as user_file:
user_file.write('id,x,y,brightness\n')
user_file.write('test,.4,.6,100\n')
assert setup_component(
self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}
)
dev1, _, _ = platform.DEVICES
common.turn_on(self.hass, dev1.entity_id, profile='test')
self.hass.block_till_done()
_, data = dev1.last_call('turn_on')
assert {
light.ATTR_HS_COLOR: (71.059, 100),
light.ATTR_BRIGHTNESS: 100
} == data
def test_light_profiles(self):
"""Test light profiles."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
with open(user_light_file, 'w') as user_file:
user_file.write('id,x,y,brightness\n')
user_file.write('test,.4,.6,100\n')
assert setup_component(
self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}
)
dev1, _, _ = platform.DEVICES
common.turn_on(self.hass, dev1.entity_id, profile='test')
self.hass.block_till_done()
_, data = dev1.last_call('turn_on')
assert {
light.ATTR_HS_COLOR: (71.059, 100),
light.ATTR_BRIGHTNESS: 100
} == data
def test_on_command_last(self):
"""Test on command being sent after brightness."""
config = {
light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light/set',
'brightness_command_topic': 'test_light/bright',
}
}
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
common.turn_on(self.hass, 'light.test', brightness=50)
self.hass.block_till_done()
# Should get the following MQTT messages.
# test_light/bright: 50
# test_light/set: 'ON'
self.mock_publish.async_publish.assert_has_calls([
mock.call('test_light/bright', 50, 0, False),
mock.call('test_light/set', 'ON', 0, False),
],
any_order=True)
self.mock_publish.async_publish.reset_mock()
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light/set', 'OFF', 0, False)
def test_sending_mqtt_rgb_command_with_template(self):
"""Test the sending of RGB command with template."""
config = {
light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'rgb_command_topic': 'test_light_rgb/rgb/set',
'rgb_command_template': '{{ "#%02x%02x%02x" | '
'format(red, green, blue)}}',
'payload_on': 'on',
'payload_off': 'off',
'qos': 0
}
}
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
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([
mock.call('test_light_rgb/set', 'on', 0, False),
mock.call('test_light_rgb/rgb/set', '#ff803f', 0, False),
],
any_order=True)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((255, 128, 63), state.attributes['rgb_color'])
def test_on_command_last(self):
"""Test on command being sent after brightness."""
config = {light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light/set',
'brightness_command_topic': 'test_light/bright',
}}
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
common.turn_on(self.hass, 'light.test', brightness=50)
self.hass.block_till_done()
# Should get the following MQTT messages.
# test_light/bright: 50
# test_light/set: 'ON'
self.mock_publish.async_publish.assert_has_calls([
mock.call('test_light/bright', 50, 0, False),
mock.call('test_light/set', 'ON', 0, False),
], any_order=True)
self.mock_publish.async_publish.reset_mock()
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light/set', 'OFF', 0, False)
def test_sending_mqtt_rgb_command_with_template(self):
"""Test the sending of RGB command with template."""
config = {light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'rgb_command_topic': 'test_light_rgb/rgb/set',
'rgb_command_template': '{{ "#%02x%02x%02x" | '
'format(red, green, blue)}}',
'payload_on': 'on',
'payload_off': 'off',
'qos': 0
}}
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
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([
mock.call('test_light_rgb/set', 'on', 0, False),
mock.call('test_light_rgb/rgb/set', '#ff803f', 0, False),
], any_order=True)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((255, 128, 63), state.attributes['rgb_color'])
def test_transition(self):
"""Test for transition time being sent when included."""
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_template',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'command_on_template': 'on,{{ transition }}',
'command_off_template': 'off,{{ transition|d }}'
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
# transition on
common.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on,10', 0, False)
self.mock_publish.async_publish.reset_mock()
# transition off
common.turn_off(self.hass, 'light.test', transition=4)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'off,4', 0, False)
def test_on_brightness(self):
"""Test turning the light on with brightness."""
assert self.light().state == "off"
assert self.other_light().state == "off"
assert not light.is_on(self.hass, ENTITY_LIGHT)
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)
def test_on_off(self):
"""Test turning the light on and off."""
assert self.light().state == 'off'
assert self.other_light().state == 'off'
assert not light.is_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)
common.turn_off(self.hass, ENTITY_LIGHT)
self.hass.block_till_done()
self.mock_lj.deactivate_load.assert_called_with(ENTITY_LIGHT_NUMBER)
def test_flash_short_and_long(self):
"""Test for flash length being sent when included."""
assert setup_component(
self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_json',
'name': 'test',
'state_topic': 'test_light_rgb',
'command_topic': 'test_light_rgb/set',
'flash_time_short': 5,
'flash_time_long': 15,
'qos': 0
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
common.turn_on(self.hass, 'light.test', flash="short")
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(5, message_json["flash"])
self.assertEqual("ON", message_json["state"])
self.mock_publish.async_publish.reset_mock()
common.turn_on(self.hass, 'light.test', flash="long")
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(15, message_json["flash"])
self.assertEqual("ON", message_json["state"])
def test_lights_turn_off_when_everyone_leaves(self):
"""Test lights turn off when everyone leaves the house."""
common_light.turn_on(self.hass)
self.hass.block_till_done()
assert setup_component(self.hass, device_sun_light_trigger.DOMAIN,
{device_sun_light_trigger.DOMAIN: {}})
self.hass.states.set(device_tracker.ENTITY_ID_ALL_DEVICES,
STATE_NOT_HOME)
self.hass.block_till_done()
assert not light.is_on(self.hass)
def test_white_value_action_no_template(self):
"""Test setting white value with optimistic template."""
assert setup.setup_component(
self.hass,
"light",
{
"light": {
"platform": "template",
"lights": {
"test_template_light": {
"value_template": "{{1 == 1}}",
"turn_on": {
"service": "light.turn_on",
"entity_id": "light.test_state",
},
"turn_off": {
"service": "light.turn_off",
"entity_id": "light.test_state",
},
"set_white_value": {
"service": "test.automation",
"data_template": {
"entity_id": "test.test_state",
"white_value": "{{white_value}}",
},
},
}
},
}
},
)
self.hass.block_till_done()
self.hass.start()
self.hass.block_till_done()
state = self.hass.states.get("light.test_template_light")
assert state.attributes.get("white_value") is None
common.turn_on(
self.hass, "light.test_template_light", **{ATTR_WHITE_VALUE: 124}
)
self.hass.block_till_done()
assert len(self.calls) == 1
assert self.calls[0].data["white_value"] == "124"
state = self.hass.states.get("light.test_template_light")
assert state is not None
assert state.attributes.get("white_value") == 124
def test_flash_short_and_long(self):
"""Test for flash length being sent when included."""
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_json',
'name': 'test',
'state_topic': 'test_light_rgb',
'command_topic': 'test_light_rgb/set',
'flash_time_short': 5,
'flash_time_long': 15,
'qos': 0
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
common.turn_on(self.hass, 'light.test', flash="short")
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(5, message_json["flash"])
self.assertEqual("ON", message_json["state"])
self.mock_publish.async_publish.reset_mock()
common.turn_on(self.hass, 'light.test', flash="long")
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(15, message_json["flash"])
self.assertEqual("ON", message_json["state"])
def test_lights_turn_off_when_everyone_leaves(self):
"""Test lights turn off when everyone leaves the house."""
common_light.turn_on(self.hass)
self.hass.block_till_done()
self.assertTrue(setup_component(
self.hass, device_sun_light_trigger.DOMAIN, {
device_sun_light_trigger.DOMAIN: {}}))
self.hass.states.set(device_tracker.ENTITY_ID_ALL_DEVICES,
STATE_NOT_HOME)
self.hass.block_till_done()
self.assertFalse(light.is_on(self.hass))
def test_temperature_action_no_template(self):
"""Test setting temperature with optimistic template."""
assert setup.setup_component(
self.hass,
"light",
{
"light": {
"platform": "template",
"lights": {
"test_template_light": {
"value_template": "{{1 == 1}}",
"turn_on": {
"service": "light.turn_on",
"entity_id": "light.test_state",
},
"turn_off": {
"service": "light.turn_off",
"entity_id": "light.test_state",
},
"set_temperature": {
"service": "test.automation",
"data_template": {
"entity_id": "test.test_state",
"color_temp": "{{color_temp}}",
},
},
}
},
}
},
)
self.hass.block_till_done()
self.hass.start()
self.hass.block_till_done()
state = self.hass.states.get("light.test_template_light")
assert state.attributes.get("color_template") is None
common.turn_on(self.hass, "light.test_template_light", **{ATTR_COLOR_TEMP: 345})
self.hass.block_till_done()
assert len(self.calls) == 1
assert self.calls[0].data["color_temp"] == "345"
state = self.hass.states.get("light.test_template_light")
_LOGGER.info(str(state.attributes))
assert state is not None
assert state.attributes.get("color_temp") == 345
def test_level_action_no_template(self):
"""Test setting brightness with optimistic template."""
assert setup.setup_component(
self.hass,
"light",
{
"light": {
"platform": "template",
"lights": {
"test_template_light": {
"value_template": "{{1 == 1}}",
"turn_on": {
"service": "light.turn_on",
"entity_id": "light.test_state",
},
"turn_off": {
"service": "light.turn_off",
"entity_id": "light.test_state",
},
"set_level": {
"service": "test.automation",
"data_template": {
"entity_id": "test.test_state",
"brightness": "{{brightness}}",
},
},
}
},
}
},
)
self.hass.block_till_done()
self.hass.start()
self.hass.block_till_done()
state = self.hass.states.get("light.test_template_light")
assert state.attributes.get("brightness") is None
common.turn_on(self.hass, "light.test_template_light", **{ATTR_BRIGHTNESS: 124})
self.hass.block_till_done()
assert len(self.calls) == 1
assert self.calls[0].data["brightness"] == "124"
state = self.hass.states.get("light.test_template_light")
_LOGGER.info(str(state.attributes))
assert state is not None
assert state.attributes.get("brightness") == 124
def test_transition(self):
"""Test for transition time being sent when included."""
assert setup_component(
self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_json',
'name': 'test',
'state_topic': 'test_light_rgb',
'command_topic': 'test_light_rgb/set',
'qos': 0
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
common.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(10, message_json["transition"])
self.assertEqual("ON", message_json["state"])
# Transition back off
common.turn_off(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[1][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[1][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[1][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[1][1][1])
self.assertEqual(10, message_json["transition"])
self.assertEqual("OFF", message_json["state"])
def test_transition(self):
"""Test for transition time being sent when included."""
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_json',
'name': 'test',
'state_topic': 'test_light_rgb',
'command_topic': 'test_light_rgb/set',
'qos': 0
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
common.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(10, message_json["transition"])
self.assertEqual("ON", message_json["state"])
# Transition back off
common.turn_off(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[1][1][0])
self.assertEqual(0,
self.mock_publish.async_publish.mock_calls[1][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[1][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[1][1][1])
self.assertEqual(10, message_json["transition"])
self.assertEqual("OFF", message_json["state"])
def test_on_action_optimistic(self):
"""Test on action with optimistic state."""
assert setup.setup_component(
self.hass,
"light",
{
"light": {
"platform": "template",
"lights": {
"test_template_light": {
"turn_on": {"service": "test.automation"},
"turn_off": {
"service": "light.turn_off",
"entity_id": "light.test_state",
},
"set_level": {
"service": "light.turn_on",
"data_template": {
"entity_id": "light.test_state",
"brightness": "{{brightness}}",
},
},
}
},
}
},
)
self.hass.block_till_done()
self.hass.start()
self.hass.block_till_done()
self.hass.states.set("light.test_state", STATE_OFF)
self.hass.block_till_done()
state = self.hass.states.get("light.test_template_light")
assert state.state == STATE_OFF
common.turn_on(self.hass, "light.test_template_light")
self.hass.block_till_done()
state = self.hass.states.get("light.test_template_light")
assert len(self.calls) == 1
assert state.state == STATE_ON
def test_level_action_no_template(self):
"""Test setting brightness with optimistic template."""
assert setup.setup_component(self.hass, 'light', {
'light': {
'platform': 'template',
'lights': {
'test_template_light': {
'value_template': '{{1 == 1}}',
'turn_on': {
'service': 'light.turn_on',
'entity_id': 'light.test_state'
},
'turn_off': {
'service': 'light.turn_off',
'entity_id': 'light.test_state'
},
'set_level': {
'service': 'test.automation',
'data_template': {
'entity_id': 'test.test_state',
'brightness': '{{brightness}}'
}
},
}
}
}
})
self.hass.start()
self.hass.block_till_done()
state = self.hass.states.get('light.test_template_light')
assert state.attributes.get('brightness') is None
common.turn_on(
self.hass, 'light.test_template_light', **{ATTR_BRIGHTNESS: 124})
self.hass.block_till_done()
assert len(self.calls) == 1
assert self.calls[0].data['brightness'] == '124'
state = self.hass.states.get('light.test_template_light')
_LOGGER.info(str(state.attributes))
assert state is not None
assert state.attributes.get('brightness') == 124
def test_default_profiles_light(self):
"""Test default turn-on light profile for a specific light."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
real_isfile = os.path.isfile
real_open = open
def _mock_isfile(path):
if path == user_light_file:
return True
return real_isfile(path)
def _mock_open(path):
if path == user_light_file:
return StringIO(profile_data)
return real_open(path)
profile_data = "id,x,y,brightness\n" +\
"group.all_lights.default,.3,.5,200\n" +\
"light.ceiling_2.default,.6,.6,100\n"
with mock.patch('os.path.isfile', side_effect=_mock_isfile):
with mock.patch('builtins.open', side_effect=_mock_open):
with mock_storage():
self.assertTrue(
setup_component(
self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: 'test'
}}))
dev = next(
filter(lambda x: x.entity_id == 'light.ceiling_2',
platform.DEVICES))
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call('turn_on')
self.assertEqual(
{
light.ATTR_HS_COLOR: (50.353, 100),
light.ATTR_BRIGHTNESS: 100
}, data)
def test_default_profiles_light(self):
"""Test default turn-on light profile for a specific light."""
platform = getattr(self.hass.components, "test.light")
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
real_isfile = os.path.isfile
real_open = open
def _mock_isfile(path):
if path == user_light_file:
return True
return real_isfile(path)
def _mock_open(path, *args, **kwargs):
if path == user_light_file:
return StringIO(profile_data)
return real_open(path, *args, **kwargs)
profile_data = ("id,x,y,brightness,transition\n" +
"group.all_lights.default,.3,.5,200,0\n" +
"light.ceiling_2.default,.6,.6,100,3\n")
with mock.patch("os.path.isfile",
side_effect=_mock_isfile), mock.patch(
"builtins.open",
side_effect=_mock_open), mock_storage():
assert setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: "test"
}})
self.hass.block_till_done()
dev = next(
filter(lambda x: x.entity_id == "light.ceiling_2",
platform.ENTITIES))
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call("turn_on")
assert {
light.ATTR_HS_COLOR: (50.353, 100),
light.ATTR_BRIGHTNESS: 100,
light.ATTR_TRANSITION: 3,
} == data
def test_default_profiles_group(self):
"""Test default turn-on light profile for all lights."""
platform = getattr(self.hass.components, "test.light")
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
real_isfile = os.path.isfile
real_open = open
def _mock_isfile(path):
if path == user_light_file:
return True
return real_isfile(path)
def _mock_open(path, *args, **kwargs):
if path == user_light_file:
return StringIO(profile_data)
return real_open(path, *args, **kwargs)
profile_data = (
"id,x,y,brightness,transition\ngroup.all_lights.default,.4,.6,99,2\n"
)
with mock.patch("os.path.isfile",
side_effect=_mock_isfile), mock.patch(
"builtins.open",
side_effect=_mock_open), mock_storage():
assert setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: "test"
}})
self.hass.block_till_done()
ent, _, _ = platform.ENTITIES
common.turn_on(self.hass, ent.entity_id)
self.hass.block_till_done()
_, data = ent.last_call("turn_on")
assert {
light.ATTR_HS_COLOR: (71.059, 100),
light.ATTR_BRIGHTNESS: 99,
light.ATTR_TRANSITION: 2,
} == data
def test_light_profiles_with_transition(self):
"""Test light profiles with transition."""
platform = getattr(self.hass.components, "test.light")
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
with open(user_light_file, "w") as user_file:
user_file.write("id,x,y,brightness,transition\n")
user_file.write("test,.4,.6,100,2\n")
user_file.write("test_off,0,0,0,0\n")
assert setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: "test"
}})
self.hass.block_till_done()
ent1, _, _ = platform.ENTITIES
common.turn_on(self.hass, ent1.entity_id, profile="test")
self.hass.block_till_done()
_, data = ent1.last_call("turn_on")
assert light.is_on(self.hass, ent1.entity_id)
assert {
light.ATTR_HS_COLOR: (71.059, 100),
light.ATTR_BRIGHTNESS: 100,
light.ATTR_TRANSITION: 2,
} == data
common.turn_on(self.hass, ent1.entity_id, profile="test_off")
self.hass.block_till_done()
_, data = ent1.last_call("turn_off")
assert not light.is_on(self.hass, ent1.entity_id)
assert {light.ATTR_TRANSITION: 0} == data
def test_on_action_optimistic(self):
"""Test on action with optimistic state."""
assert setup.setup_component(self.hass, 'light', {
'light': {
'platform': 'template',
'lights': {
'test_template_light': {
'turn_on': {
'service': 'test.automation',
},
'turn_off': {
'service': 'light.turn_off',
'entity_id': 'light.test_state'
},
'set_level': {
'service': 'light.turn_on',
'data_template': {
'entity_id': 'light.test_state',
'brightness': '{{brightness}}'
}
}
}
}
}
})
self.hass.start()
self.hass.block_till_done()
self.hass.states.set('light.test_state', STATE_OFF)
self.hass.block_till_done()
state = self.hass.states.get('light.test_template_light')
assert state.state == STATE_OFF
common.turn_on(self.hass, 'light.test_template_light')
self.hass.block_till_done()
state = self.hass.states.get('light.test_template_light')
assert len(self.calls) == 1
assert state.state == STATE_ON
def test_sending_hs_color(self):
"""Test light.turn_on with hs color sends hs color parameters."""
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_json',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'hs': True,
}
})
common.turn_on(self.hass, 'light.test', hs_color=(180.0, 50.0))
self.hass.block_till_done()
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual("ON", message_json["state"])
self.assertEqual({
'h': 180.0,
's': 50.0,
}, message_json["color"])
def test_default_profiles_light(self):
"""Test default turn-on light profile for a specific light."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
real_isfile = os.path.isfile
real_open = open
def _mock_isfile(path):
if path == user_light_file:
return True
return real_isfile(path)
def _mock_open(path):
if path == user_light_file:
return StringIO(profile_data)
return real_open(path)
profile_data = "id,x,y,brightness\n" +\
"group.all_lights.default,.3,.5,200\n" +\
"light.ceiling_2.default,.6,.6,100\n"
with mock.patch('os.path.isfile', side_effect=_mock_isfile):
with mock.patch('builtins.open', side_effect=_mock_open):
with mock_storage():
assert setup_component(
self.hass, light.DOMAIN,
{light.DOMAIN: {CONF_PLATFORM: 'test'}}
)
dev = next(filter(lambda x: x.entity_id == 'light.ceiling_2',
platform.DEVICES))
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call('turn_on')
assert {
light.ATTR_HS_COLOR: (50.353, 100),
light.ATTR_BRIGHTNESS: 100
} == data
def test_default_profiles_group(self):
"""Test default turn-on light profile for all lights."""
platform = getattr(self.hass.components, 'test.light')
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
real_isfile = os.path.isfile
real_open = open
def _mock_isfile(path):
if path == user_light_file:
return True
return real_isfile(path)
def _mock_open(path, *args, **kwargs):
if path == user_light_file:
return StringIO(profile_data)
return real_open(path, *args, **kwargs)
profile_data = "id,x,y,brightness\n" +\
"group.all_lights.default,.4,.6,99\n"
with mock.patch('os.path.isfile', side_effect=_mock_isfile):
with mock.patch('builtins.open', side_effect=_mock_open):
with mock_storage():
assert setup_component(
self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: 'test'
}})
dev, _, _ = platform.DEVICES
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call('turn_on')
assert {
light.ATTR_HS_COLOR: (71.059, 100),
light.ATTR_BRIGHTNESS: 99
} == data
def test_on_command_brightness(self):
"""Test on command being sent as only brightness."""
config = {
light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light/set',
'brightness_command_topic': 'test_light/bright',
'rgb_command_topic': "test_light/rgb",
'on_command_type': 'brightness',
}
}
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
# Turn on w/ no brightness - should set to max
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
# Should get the following MQTT messages.
# test_light/bright: 255
self.mock_publish.async_publish.assert_called_once_with(
'test_light/bright', 255, 0, False)
self.mock_publish.async_publish.reset_mock()
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light/set', 'OFF', 0, False)
self.mock_publish.async_publish.reset_mock()
# Turn on w/ brightness
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()
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.
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([
mock.call('test_light/rgb', '255,128,0', 0, False),
mock.call('test_light/bright', 50, 0, False)
],
any_order=True)
def test_default_profiles_group(self):
"""Test default turn-on light profile for all lights."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
real_isfile = os.path.isfile
real_open = open
def _mock_isfile(path):
if path == user_light_file:
return True
return real_isfile(path)
def _mock_open(path):
if path == user_light_file:
return StringIO(profile_data)
return real_open(path)
profile_data = "id,x,y,brightness\n" +\
"group.all_lights.default,.4,.6,99\n"
with mock.patch('os.path.isfile', side_effect=_mock_isfile):
with mock.patch('builtins.open', side_effect=_mock_open):
with mock_storage():
self.assertTrue(setup_component(
self.hass, light.DOMAIN,
{light.DOMAIN: {CONF_PLATFORM: 'test'}}
))
dev, _, _ = platform.DEVICES
common.turn_on(self.hass, dev.entity_id)
self.hass.block_till_done()
_, data = dev.last_call('turn_on')
self.assertEqual({
light.ATTR_HS_COLOR: (71.059, 100),
light.ATTR_BRIGHTNESS: 99
}, data)
def test_on_command_brightness(self):
"""Test on command being sent as only brightness."""
config = {light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light/set',
'brightness_command_topic': 'test_light/bright',
'rgb_command_topic': "test_light/rgb",
'on_command_type': 'brightness',
}}
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
# Turn on w/ no brightness - should set to max
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
# Should get the following MQTT messages.
# test_light/bright: 255
self.mock_publish.async_publish.assert_called_once_with(
'test_light/bright', 255, 0, False)
self.mock_publish.async_publish.reset_mock()
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light/set', 'OFF', 0, False)
self.mock_publish.async_publish.reset_mock()
# Turn on w/ brightness
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()
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.
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([
mock.call('test_light/rgb', '255,128,0', 0, False),
mock.call('test_light/bright', 50, 0, False)
], any_order=True)
async def test_flux_with_multiple_lights(hass):
"""Test the flux switch with multiple light entities."""
platform = getattr(hass.components, "test.light")
platform.init()
assert await async_setup_component(
hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
)
ent1, ent2, ent3 = platform.ENTITIES
common_light.turn_on(hass, entity_id=ent2.entity_id)
await hass.async_block_till_done()
common_light.turn_on(hass, entity_id=ent3.entity_id)
await hass.async_block_till_done()
state = hass.states.get(ent1.entity_id)
assert STATE_ON == state.state
assert state.attributes.get("xy_color") is None
assert state.attributes.get("brightness") is None
state = hass.states.get(ent2.entity_id)
assert STATE_ON == state.state
assert state.attributes.get("xy_color") is None
assert state.attributes.get("brightness") is None
state = hass.states.get(ent3.entity_id)
assert STATE_ON == state.state
assert state.attributes.get("xy_color") is None
assert state.attributes.get("brightness") is None
test_time = dt_util.utcnow().replace(hour=12, minute=0, second=0)
sunset_time = test_time.replace(hour=17, minute=0, second=0)
sunrise_time = test_time.replace(hour=5, minute=0, second=0)
def event_date(hass, event, now=None):
if event == SUN_EVENT_SUNRISE:
print("sunrise {}".format(sunrise_time))
return sunrise_time
print("sunset {}".format(sunset_time))
return sunset_time
with patch(
"homeassistant.components.flux.switch.dt_utcnow", return_value=test_time
), patch(
"homeassistant.components.flux.switch.get_astral_event_date",
side_effect=event_date,
):
assert await async_setup_component(
hass,
switch.DOMAIN,
{
switch.DOMAIN: {
"platform": "flux",
"name": "flux",
"lights": [ent1.entity_id, ent2.entity_id, ent3.entity_id],
}
},
)
turn_on_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON)
common.turn_on(hass, "switch.flux")
await hass.async_block_till_done()
async_fire_time_changed(hass, test_time)
await hass.async_block_till_done()
call = turn_on_calls[-1]
assert call.data[light.ATTR_BRIGHTNESS] == 163
assert call.data[light.ATTR_XY_COLOR] == [0.46, 0.376]
call = turn_on_calls[-2]
assert call.data[light.ATTR_BRIGHTNESS] == 163
assert call.data[light.ATTR_XY_COLOR] == [0.46, 0.376]
call = turn_on_calls[-3]
assert call.data[light.ATTR_BRIGHTNESS] == 163
assert call.data[light.ATTR_XY_COLOR] == [0.46, 0.376]
def test_color_action_no_template(self):
"""Test setting color with optimistic template."""
assert setup.setup_component(
self.hass,
"light",
{
"light": {
"platform": "template",
"lights": {
"test_template_light": {
"value_template": "{{1 == 1}}",
"turn_on": {
"service": "light.turn_on",
"entity_id": "light.test_state",
},
"turn_off": {
"service": "light.turn_off",
"entity_id": "light.test_state",
},
"set_color": [
{
"service": "test.automation",
"data_template": {
"entity_id": "test.test_state",
"h": "{{h}}",
"s": "{{s}}",
},
},
{
"service": "test.automation",
"data_template": {
"entity_id": "test.test_state",
"s": "{{s}}",
"h": "{{h}}",
},
},
],
}
},
}
},
)
self.hass.block_till_done()
self.hass.start()
self.hass.block_till_done()
state = self.hass.states.get("light.test_template_light")
assert state.attributes.get("hs_color") is None
common.turn_on(
self.hass, "light.test_template_light", **{ATTR_HS_COLOR: (40, 50)}
)
self.hass.block_till_done()
assert len(self.calls) == 2
assert self.calls[0].data["h"] == "40"
assert self.calls[0].data["s"] == "50"
assert self.calls[1].data["h"] == "40"
assert self.calls[1].data["s"] == "50"
state = self.hass.states.get("light.test_template_light")
_LOGGER.info(str(state.attributes))
assert state is not None
assert self.calls[0].data["h"] == "40"
assert self.calls[0].data["s"] == "50"
assert self.calls[1].data["h"] == "40"
assert self.calls[1].data["s"] == "50"
def test_sending_mqtt_commands_and_optimistic(self):
"""Test the sending of command in optimistic mode."""
fake_state = ha.State('light.test', 'on', {'brightness': 95,
'hs_color': [100, 100],
'effect': 'random',
'color_temp': 100,
'white_value': 50})
with patch('homeassistant.components.light.mqtt_json'
'.async_get_last_state',
return_value=mock_coro(fake_state)):
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_json',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'brightness': True,
'color_temp': True,
'effect': True,
'rgb': True,
'white_value': True,
'qos': 2
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(95, state.attributes.get('brightness'))
self.assertEqual((100, 100), state.attributes.get('hs_color'))
self.assertEqual('random', state.attributes.get('effect'))
self.assertEqual(100, state.attributes.get('color_temp'))
self.assertEqual(50, state.attributes.get('white_value'))
self.assertEqual(191, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', '{"state": "ON"}', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', '{"state": "OFF"}', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
common.turn_on(self.hass, 'light.test',
brightness=50, color_temp=155, effect='colorloop',
white_value=170)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(2,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[0][1][1])
self.assertEqual(50, message_json["brightness"])
self.assertEqual(155, message_json["color_temp"])
self.assertEqual('colorloop', message_json["effect"])
self.assertEqual(170, message_json["white_value"])
self.assertEqual("ON", message_json["state"])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual(155, state.attributes['color_temp'])
self.assertEqual('colorloop', state.attributes['effect'])
self.assertEqual(170, state.attributes['white_value'])
# Test a color command
common.turn_on(self.hass, 'light.test',
brightness=50, hs_color=(125, 100))
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set',
self.mock_publish.async_publish.mock_calls[0][1][0])
self.assertEqual(2,
self.mock_publish.async_publish.mock_calls[0][1][2])
self.assertEqual(False,
self.mock_publish.async_publish.mock_calls[0][1][3])
# Get the sent message
message_json = json.loads(
self.mock_publish.async_publish.mock_calls[1][1][1])
self.assertEqual(50, message_json["brightness"])
self.assertEqual({
'r': 0,
'g': 255,
'b': 21,
}, message_json["color"])
self.assertEqual("ON", message_json["state"])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual((125, 100), state.attributes['hs_color'])
def test_flux_with_multiple_lights(self):
"""Test the flux switch with multiple light entities."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
self.assertTrue(
setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1, dev2, dev3 = platform.DEVICES
common_light.turn_on(self.hass, entity_id=dev2.entity_id)
self.hass.block_till_done()
common_light.turn_on(self.hass, entity_id=dev3.entity_id)
self.hass.block_till_done()
state = self.hass.states.get(dev1.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('xy_color'))
self.assertIsNone(state.attributes.get('brightness'))
state = self.hass.states.get(dev2.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('xy_color'))
self.assertIsNone(state.attributes.get('brightness'))
state = self.hass.states.get(dev3.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('xy_color'))
self.assertIsNone(state.attributes.get('brightness'))
test_time = dt_util.now().replace(hour=12, minute=0, second=0)
sunset_time = test_time.replace(hour=17, minute=0, second=0)
sunrise_time = test_time.replace(hour=5, minute=0, second=0)
def event_date(hass, event, now=None):
if event == 'sunrise':
print('sunrise {}'.format(sunrise_time))
return sunrise_time
print('sunset {}'.format(sunset_time))
return sunset_time
with patch('homeassistant.util.dt.now', return_value=test_time):
with patch('homeassistant.helpers.sun.get_astral_event_date',
side_effect=event_date):
assert setup_component(self.hass, switch.DOMAIN, {
switch.DOMAIN: {
'platform': 'flux',
'name': 'flux',
'lights': [dev1.entity_id,
dev2.entity_id,
dev3.entity_id]
}
})
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
call = turn_on_calls[-1]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 163)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.46, 0.376])
call = turn_on_calls[-2]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 163)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.46, 0.376])
call = turn_on_calls[-3]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 163)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.46, 0.376])
def test_flux_with_multiple_lights(self):
"""Test the flux switch with multiple light entities."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
self.assertTrue(
setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: 'test'
}}))
dev1, dev2, dev3 = platform.DEVICES
common_light.turn_on(self.hass, entity_id=dev2.entity_id)
self.hass.block_till_done()
common_light.turn_on(self.hass, entity_id=dev3.entity_id)
self.hass.block_till_done()
state = self.hass.states.get(dev1.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('xy_color'))
self.assertIsNone(state.attributes.get('brightness'))
state = self.hass.states.get(dev2.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('xy_color'))
self.assertIsNone(state.attributes.get('brightness'))
state = self.hass.states.get(dev3.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('xy_color'))
self.assertIsNone(state.attributes.get('brightness'))
test_time = dt_util.utcnow().replace(hour=12, minute=0, second=0)
sunset_time = test_time.replace(hour=17, minute=0, second=0)
sunrise_time = test_time.replace(hour=5, minute=0, second=0)
def event_date(hass, event, now=None):
if event == 'sunrise':
print('sunrise {}'.format(sunrise_time))
return sunrise_time
print('sunset {}'.format(sunset_time))
return sunset_time
with patch('homeassistant.components.switch.flux.dt_utcnow',
return_value=test_time), \
patch('homeassistant.helpers.sun.get_astral_event_date',
side_effect=event_date):
assert setup_component(
self.hass, switch.DOMAIN, {
switch.DOMAIN: {
'platform': 'flux',
'name': 'flux',
'lights':
[dev1.entity_id, dev2.entity_id, dev3.entity_id]
}
})
turn_on_calls = mock_service(self.hass, light.DOMAIN,
SERVICE_TURN_ON)
common.turn_on(self.hass, 'switch.flux')
self.hass.block_till_done()
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
call = turn_on_calls[-1]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 163)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.46, 0.376])
call = turn_on_calls[-2]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 163)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.46, 0.376])
call = turn_on_calls[-3]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 163)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.46, 0.376])
def test_methods(self):
"""Test if methods call the services as expected."""
# Test is_on
self.hass.states.set('light.test', STATE_ON)
self.assertTrue(light.is_on(self.hass, 'light.test'))
self.hass.states.set('light.test', STATE_OFF)
self.assertFalse(light.is_on(self.hass, 'light.test'))
self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_ON)
self.assertTrue(light.is_on(self.hass))
self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_OFF)
self.assertFalse(light.is_on(self.hass))
# Test turn_on
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
common.turn_on(
self.hass,
entity_id='entity_id_val',
transition='transition_val',
brightness='brightness_val',
rgb_color='rgb_color_val',
xy_color='xy_color_val',
profile='profile_val',
color_name='color_name_val',
white_value='white_val')
self.hass.block_till_done()
self.assertEqual(1, len(turn_on_calls))
call = turn_on_calls[-1]
self.assertEqual(light.DOMAIN, call.domain)
self.assertEqual(SERVICE_TURN_ON, call.service)
self.assertEqual('entity_id_val', call.data.get(ATTR_ENTITY_ID))
self.assertEqual(
'transition_val', call.data.get(light.ATTR_TRANSITION))
self.assertEqual(
'brightness_val', call.data.get(light.ATTR_BRIGHTNESS))
self.assertEqual('rgb_color_val', call.data.get(light.ATTR_RGB_COLOR))
self.assertEqual('xy_color_val', call.data.get(light.ATTR_XY_COLOR))
self.assertEqual('profile_val', call.data.get(light.ATTR_PROFILE))
self.assertEqual(
'color_name_val', call.data.get(light.ATTR_COLOR_NAME))
self.assertEqual('white_val', call.data.get(light.ATTR_WHITE_VALUE))
# Test turn_off
turn_off_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_OFF)
common.turn_off(
self.hass, entity_id='entity_id_val', transition='transition_val')
self.hass.block_till_done()
self.assertEqual(1, len(turn_off_calls))
call = turn_off_calls[-1]
self.assertEqual(light.DOMAIN, call.domain)
self.assertEqual(SERVICE_TURN_OFF, call.service)
self.assertEqual('entity_id_val', call.data[ATTR_ENTITY_ID])
self.assertEqual('transition_val', call.data[light.ATTR_TRANSITION])
# Test toggle
toggle_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TOGGLE)
common.toggle(
self.hass, entity_id='entity_id_val', transition='transition_val')
self.hass.block_till_done()
self.assertEqual(1, len(toggle_calls))
call = toggle_calls[-1]
self.assertEqual(light.DOMAIN, call.domain)
self.assertEqual(SERVICE_TOGGLE, call.service)
self.assertEqual('entity_id_val', call.data[ATTR_ENTITY_ID])
self.assertEqual('transition_val', call.data[light.ATTR_TRANSITION])
def test_services(self):
"""Test the provided services."""
platform = getattr(self.hass.components, "test.light")
platform.init()
assert setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {
CONF_PLATFORM: "test"
}})
ent1, ent2, ent3 = platform.ENTITIES
# Test init
assert light.is_on(self.hass, ent1.entity_id)
assert not light.is_on(self.hass, ent2.entity_id)
assert not light.is_on(self.hass, ent3.entity_id)
# Test basic turn_on, turn_off, toggle services
common.turn_off(self.hass, entity_id=ent1.entity_id)
common.turn_on(self.hass, entity_id=ent2.entity_id)
self.hass.block_till_done()
assert not light.is_on(self.hass, ent1.entity_id)
assert light.is_on(self.hass, ent2.entity_id)
# turn on all lights
common.turn_on(self.hass)
self.hass.block_till_done()
assert light.is_on(self.hass, ent1.entity_id)
assert light.is_on(self.hass, ent2.entity_id)
assert light.is_on(self.hass, ent3.entity_id)
# turn off all lights
common.turn_off(self.hass)
self.hass.block_till_done()
assert not light.is_on(self.hass, ent1.entity_id)
assert not light.is_on(self.hass, ent2.entity_id)
assert not light.is_on(self.hass, ent3.entity_id)
# turn off all lights by setting brightness to 0
common.turn_on(self.hass)
self.hass.block_till_done()
common.turn_on(self.hass, brightness=0)
self.hass.block_till_done()
assert not light.is_on(self.hass, ent1.entity_id)
assert not light.is_on(self.hass, ent2.entity_id)
assert not light.is_on(self.hass, ent3.entity_id)
# toggle all lights
common.toggle(self.hass)
self.hass.block_till_done()
assert light.is_on(self.hass, ent1.entity_id)
assert light.is_on(self.hass, ent2.entity_id)
assert light.is_on(self.hass, ent3.entity_id)
# toggle all lights
common.toggle(self.hass)
self.hass.block_till_done()
assert not light.is_on(self.hass, ent1.entity_id)
assert not light.is_on(self.hass, ent2.entity_id)
assert not light.is_on(self.hass, ent3.entity_id)
# Ensure all attributes process correctly
common.turn_on(self.hass,
ent1.entity_id,
transition=10,
brightness=20,
color_name="blue")
common.turn_on(self.hass,
ent2.entity_id,
rgb_color=(255, 255, 255),
white_value=255)
common.turn_on(self.hass, ent3.entity_id, xy_color=(0.4, 0.6))
self.hass.block_till_done()
_, data = ent1.last_call("turn_on")
assert {
light.ATTR_TRANSITION: 10,
light.ATTR_BRIGHTNESS: 20,
light.ATTR_HS_COLOR: (240, 100),
} == data
_, data = ent2.last_call("turn_on")
assert {
light.ATTR_HS_COLOR: (0, 0),
light.ATTR_WHITE_VALUE: 255
} == data
_, data = ent3.last_call("turn_on")
assert {light.ATTR_HS_COLOR: (71.059, 100)} == data
# Ensure attributes are filtered when light is turned off
common.turn_on(self.hass,
ent1.entity_id,
transition=10,
brightness=0,
color_name="blue")
common.turn_on(
self.hass,
ent2.entity_id,
brightness=0,
rgb_color=(255, 255, 255),
white_value=0,
)
common.turn_on(self.hass,
ent3.entity_id,
brightness=0,
xy_color=(0.4, 0.6))
self.hass.block_till_done()
assert not light.is_on(self.hass, ent1.entity_id)
assert not light.is_on(self.hass, ent2.entity_id)
assert not light.is_on(self.hass, ent3.entity_id)
_, data = ent1.last_call("turn_off")
assert {light.ATTR_TRANSITION: 10} == data
_, data = ent2.last_call("turn_off")
assert {} == data
_, data = ent3.last_call("turn_off")
assert {} == data
# One of the light profiles
prof_name, prof_h, prof_s, prof_bri = "relax", 35.932, 69.412, 144
# Test light profiles
common.turn_on(self.hass, ent1.entity_id, profile=prof_name)
# Specify a profile and a brightness attribute to overwrite it
common.turn_on(self.hass,
ent2.entity_id,
profile=prof_name,
brightness=100)
self.hass.block_till_done()
_, data = ent1.last_call("turn_on")
assert {
light.ATTR_BRIGHTNESS: prof_bri,
light.ATTR_HS_COLOR: (prof_h, prof_s),
} == data
_, data = ent2.last_call("turn_on")
assert {
light.ATTR_BRIGHTNESS: 100,
light.ATTR_HS_COLOR: (prof_h, prof_s),
} == data
# Test bad data
common.turn_on(self.hass)
common.turn_on(self.hass, ent1.entity_id, profile="nonexisting")
common.turn_on(self.hass, ent2.entity_id, xy_color=["bla-di-bla", 5])
common.turn_on(self.hass, ent3.entity_id, rgb_color=[255, None, 2])
self.hass.block_till_done()
_, data = ent1.last_call("turn_on")
assert {} == data
_, data = ent2.last_call("turn_on")
assert {} == data
_, data = ent3.last_call("turn_on")
assert {} == data
# faulty attributes will not trigger a service call
common.turn_on(self.hass,
ent1.entity_id,
profile=prof_name,
brightness="bright")
common.turn_on(self.hass, ent1.entity_id, rgb_color="yellowish")
common.turn_on(self.hass, ent2.entity_id, white_value="high")
self.hass.block_till_done()
_, data = ent1.last_call("turn_on")
assert {} == data
_, data = ent2.last_call("turn_on")
assert {} == data
def test_sending_mqtt_commands_and_optimistic(self):
"""Test the sending of command in optimistic mode."""
config = {
light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'brightness_command_topic': 'test_light_rgb/brightness/set',
'rgb_command_topic': 'test_light_rgb/rgb/set',
'color_temp_command_topic': 'test_light_rgb/color_temp/set',
'effect_command_topic': 'test_light_rgb/effect/set',
'white_value_command_topic': 'test_light_rgb/white_value/set',
'xy_command_topic': 'test_light_rgb/xy/set',
'effect_list': ['colorloop', 'random'],
'qos': 2,
'payload_on': 'on',
'payload_off': 'off'
}
}
fake_state = ha.State(
'light.test', 'on', {
'brightness': 95,
'hs_color': [100, 100],
'effect': 'random',
'color_temp': 100,
'white_value': 50
})
with patch('homeassistant.components.light.mqtt.async_get_last_state',
return_value=mock_coro(fake_state)):
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(95, state.attributes.get('brightness'))
self.assertEqual((100, 100), state.attributes.get('hs_color'))
self.assertEqual('random', state.attributes.get('effect'))
self.assertEqual(100, state.attributes.get('color_temp'))
self.assertEqual(50, state.attributes.get('white_value'))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'off', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.mock_publish.reset_mock()
common.turn_on(self.hass,
'light.test',
brightness=50,
xy_color=[0.123, 0.123])
common.turn_on(self.hass,
'light.test',
rgb_color=[255, 128, 0],
white_value=80)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_has_calls([
mock.call('test_light_rgb/set', 'on', 2, False),
mock.call('test_light_rgb/rgb/set', '255,128,0', 2, False),
mock.call('test_light_rgb/brightness/set', 50, 2, False),
mock.call('test_light_rgb/white_value/set', 80, 2, False),
mock.call('test_light_rgb/xy/set', '0.14,0.131', 2, False),
],
any_order=True)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((255, 128, 0), state.attributes['rgb_color'])
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual(80, state.attributes['white_value'])
self.assertEqual((0.611, 0.375), state.attributes['xy_color'])
def test_optimistic(self):
"""Test optimistic mode."""
fake_state = ha.State('light.test', 'on', {'brightness': 95,
'hs_color': [100, 100],
'effect': 'random',
'color_temp': 100,
'white_value': 50})
with patch('homeassistant.components.light.mqtt_template'
'.async_get_last_state',
return_value=mock_coro(fake_state)):
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {
light.DOMAIN: {
'platform': 'mqtt_template',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'command_on_template': 'on,'
'{{ brightness|d }},'
'{{ color_temp|d }},'
'{{ white_value|d }},'
'{{ red|d }}-'
'{{ green|d }}-'
'{{ blue|d }}',
'command_off_template': 'off',
'effect_list': ['colorloop', 'random'],
'effect_command_topic': 'test_light_rgb/effect/set',
'qos': 2
}
})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(95, state.attributes.get('brightness'))
self.assertEqual((100, 100), state.attributes.get('hs_color'))
self.assertEqual('random', state.attributes.get('effect'))
self.assertEqual(100, state.attributes.get('color_temp'))
self.assertEqual(50, state.attributes.get('white_value'))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
# turn on the light
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on,,,,--', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
# turn the light off
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'off', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
# turn on the light with brightness, color
common.turn_on(self.hass, 'light.test', brightness=50,
rgb_color=[75, 75, 75])
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on,50,,,50-50-50', 2, False)
self.mock_publish.async_publish.reset_mock()
# turn on the light with color temp and white val
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(
'test_light_rgb/set', 'on,,200,139,--', 2, False)
# check the state
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((255, 255, 255), state.attributes['rgb_color'])
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual(200, state.attributes['color_temp'])
self.assertEqual(139, state.attributes['white_value'])
def test_methods(self):
"""Test if methods call the services as expected."""
# Test is_on
self.hass.states.set('light.test', STATE_ON)
assert light.is_on(self.hass, 'light.test')
self.hass.states.set('light.test', STATE_OFF)
assert not light.is_on(self.hass, 'light.test')
self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_ON)
assert light.is_on(self.hass)
self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_OFF)
assert not light.is_on(self.hass)
# Test turn_on
turn_on_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_ON)
common.turn_on(
self.hass,
entity_id='entity_id_val',
transition='transition_val',
brightness='brightness_val',
rgb_color='rgb_color_val',
xy_color='xy_color_val',
profile='profile_val',
color_name='color_name_val',
white_value='white_val')
self.hass.block_till_done()
assert 1 == len(turn_on_calls)
call = turn_on_calls[-1]
assert light.DOMAIN == call.domain
assert SERVICE_TURN_ON == call.service
assert 'entity_id_val' == call.data.get(ATTR_ENTITY_ID)
assert 'transition_val' == call.data.get(light.ATTR_TRANSITION)
assert 'brightness_val' == call.data.get(light.ATTR_BRIGHTNESS)
assert 'rgb_color_val' == call.data.get(light.ATTR_RGB_COLOR)
assert 'xy_color_val' == call.data.get(light.ATTR_XY_COLOR)
assert 'profile_val' == call.data.get(light.ATTR_PROFILE)
assert 'color_name_val' == call.data.get(light.ATTR_COLOR_NAME)
assert 'white_val' == call.data.get(light.ATTR_WHITE_VALUE)
# Test turn_off
turn_off_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TURN_OFF)
common.turn_off(
self.hass, entity_id='entity_id_val', transition='transition_val')
self.hass.block_till_done()
assert 1 == len(turn_off_calls)
call = turn_off_calls[-1]
assert light.DOMAIN == call.domain
assert SERVICE_TURN_OFF == call.service
assert 'entity_id_val' == call.data[ATTR_ENTITY_ID]
assert 'transition_val' == call.data[light.ATTR_TRANSITION]
# Test toggle
toggle_calls = mock_service(
self.hass, light.DOMAIN, SERVICE_TOGGLE)
common.toggle(
self.hass, entity_id='entity_id_val', transition='transition_val')
self.hass.block_till_done()
assert 1 == len(toggle_calls)
call = toggle_calls[-1]
assert light.DOMAIN == call.domain
assert SERVICE_TOGGLE == call.service
assert 'entity_id_val' == call.data[ATTR_ENTITY_ID]
assert 'transition_val' == call.data[light.ATTR_TRANSITION]
def test_services(self):
"""Test the provided services."""
platform = loader.get_component(self.hass, 'light.test')
platform.init()
assert setup_component(self.hass, light.DOMAIN,
{light.DOMAIN: {CONF_PLATFORM: 'test'}})
dev1, dev2, dev3 = platform.DEVICES
# Test init
assert light.is_on(self.hass, dev1.entity_id)
assert not light.is_on(self.hass, dev2.entity_id)
assert not light.is_on(self.hass, dev3.entity_id)
# Test basic turn_on, turn_off, toggle services
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()
assert not light.is_on(self.hass, dev1.entity_id)
assert light.is_on(self.hass, dev2.entity_id)
# turn on all lights
common.turn_on(self.hass)
self.hass.block_till_done()
assert light.is_on(self.hass, dev1.entity_id)
assert light.is_on(self.hass, dev2.entity_id)
assert light.is_on(self.hass, dev3.entity_id)
# turn off all lights
common.turn_off(self.hass)
self.hass.block_till_done()
assert not light.is_on(self.hass, dev1.entity_id)
assert not light.is_on(self.hass, dev2.entity_id)
assert not light.is_on(self.hass, dev3.entity_id)
# toggle all lights
common.toggle(self.hass)
self.hass.block_till_done()
assert light.is_on(self.hass, dev1.entity_id)
assert light.is_on(self.hass, dev2.entity_id)
assert light.is_on(self.hass, dev3.entity_id)
# toggle all lights
common.toggle(self.hass)
self.hass.block_till_done()
assert not light.is_on(self.hass, dev1.entity_id)
assert not light.is_on(self.hass, dev2.entity_id)
assert not light.is_on(self.hass, dev3.entity_id)
# Ensure all attributes process correctly
common.turn_on(self.hass, dev1.entity_id,
transition=10, brightness=20, color_name='blue')
common.turn_on(
self.hass, dev2.entity_id, rgb_color=(255, 255, 255),
white_value=255)
common.turn_on(self.hass, dev3.entity_id, xy_color=(.4, .6))
self.hass.block_till_done()
_, data = dev1.last_call('turn_on')
assert {
light.ATTR_TRANSITION: 10,
light.ATTR_BRIGHTNESS: 20,
light.ATTR_HS_COLOR: (240, 100),
} == data
_, data = dev2.last_call('turn_on')
assert {
light.ATTR_HS_COLOR: (0, 0),
light.ATTR_WHITE_VALUE: 255,
} == data
_, data = dev3.last_call('turn_on')
assert {
light.ATTR_HS_COLOR: (71.059, 100),
} == data
# One of the light profiles
prof_name, prof_h, prof_s, prof_bri = 'relax', 35.932, 69.412, 144
# Test light profiles
common.turn_on(self.hass, dev1.entity_id, profile=prof_name)
# Specify a profile and a brightness attribute to overwrite it
common.turn_on(
self.hass, dev2.entity_id,
profile=prof_name, brightness=100)
self.hass.block_till_done()
_, data = dev1.last_call('turn_on')
assert {
light.ATTR_BRIGHTNESS: prof_bri,
light.ATTR_HS_COLOR: (prof_h, prof_s),
} == data
_, data = dev2.last_call('turn_on')
assert {
light.ATTR_BRIGHTNESS: 100,
light.ATTR_HS_COLOR: (prof_h, prof_s),
} == data
# Test bad data
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()
_, data = dev1.last_call('turn_on')
assert {} == data
_, data = dev2.last_call('turn_on')
assert {} == data
_, data = dev3.last_call('turn_on')
assert {} == data
# faulty attributes will not trigger a service call
common.turn_on(
self.hass, dev1.entity_id,
profile=prof_name, brightness='bright')
common.turn_on(
self.hass, dev1.entity_id,
rgb_color='yellowish')
common.turn_on(
self.hass, dev2.entity_id,
white_value='high')
self.hass.block_till_done()
_, data = dev1.last_call('turn_on')
assert {} == data
_, data = dev2.last_call('turn_on')
assert {} == data
def test_methods(self):
"""Test if methods call the services as expected."""
# Test is_on
self.hass.states.set("light.test", STATE_ON)
assert light.is_on(self.hass, "light.test")
self.hass.states.set("light.test", STATE_OFF)
assert not light.is_on(self.hass, "light.test")
self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_ON)
assert light.is_on(self.hass)
self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_OFF)
assert not light.is_on(self.hass)
# Test turn_on
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
common.turn_on(
self.hass,
entity_id="entity_id_val",
transition="transition_val",
brightness="brightness_val",
rgb_color="rgb_color_val",
xy_color="xy_color_val",
profile="profile_val",
color_name="color_name_val",
white_value="white_val",
)
self.hass.block_till_done()
assert 1 == len(turn_on_calls)
call = turn_on_calls[-1]
assert light.DOMAIN == call.domain
assert SERVICE_TURN_ON == call.service
assert "entity_id_val" == call.data.get(ATTR_ENTITY_ID)
assert "transition_val" == call.data.get(light.ATTR_TRANSITION)
assert "brightness_val" == call.data.get(light.ATTR_BRIGHTNESS)
assert "rgb_color_val" == call.data.get(light.ATTR_RGB_COLOR)
assert "xy_color_val" == call.data.get(light.ATTR_XY_COLOR)
assert "profile_val" == call.data.get(light.ATTR_PROFILE)
assert "color_name_val" == call.data.get(light.ATTR_COLOR_NAME)
assert "white_val" == call.data.get(light.ATTR_WHITE_VALUE)
# Test turn_off
turn_off_calls = mock_service(self.hass, light.DOMAIN,
SERVICE_TURN_OFF)
common.turn_off(self.hass,
entity_id="entity_id_val",
transition="transition_val")
self.hass.block_till_done()
assert 1 == len(turn_off_calls)
call = turn_off_calls[-1]
assert light.DOMAIN == call.domain
assert SERVICE_TURN_OFF == call.service
assert "entity_id_val" == call.data[ATTR_ENTITY_ID]
assert "transition_val" == call.data[light.ATTR_TRANSITION]
# Test toggle
toggle_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TOGGLE)
common.toggle(self.hass,
entity_id="entity_id_val",
transition="transition_val")
self.hass.block_till_done()
assert 1 == len(toggle_calls)
call = toggle_calls[-1]
assert light.DOMAIN == call.domain
assert SERVICE_TOGGLE == call.service
assert "entity_id_val" == call.data[ATTR_ENTITY_ID]
assert "transition_val" == call.data[light.ATTR_TRANSITION]
def test_sending_mqtt_commands_and_optimistic(self):
"""Test the sending of command in optimistic mode."""
config = {light.DOMAIN: {
'platform': 'mqtt',
'name': 'test',
'command_topic': 'test_light_rgb/set',
'brightness_command_topic': 'test_light_rgb/brightness/set',
'rgb_command_topic': 'test_light_rgb/rgb/set',
'color_temp_command_topic': 'test_light_rgb/color_temp/set',
'effect_command_topic': 'test_light_rgb/effect/set',
'white_value_command_topic': 'test_light_rgb/white_value/set',
'xy_command_topic': 'test_light_rgb/xy/set',
'effect_list': ['colorloop', 'random'],
'qos': 2,
'payload_on': 'on',
'payload_off': 'off'
}}
fake_state = ha.State('light.test', 'on', {'brightness': 95,
'hs_color': [100, 100],
'effect': 'random',
'color_temp': 100,
'white_value': 50})
with patch('homeassistant.components.light.mqtt.async_get_last_state',
return_value=mock_coro(fake_state)):
with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, config)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(95, state.attributes.get('brightness'))
self.assertEqual((100, 100), state.attributes.get('hs_color'))
self.assertEqual('random', state.attributes.get('effect'))
self.assertEqual(100, state.attributes.get('color_temp'))
self.assertEqual(50, state.attributes.get('white_value'))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
common.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'on', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
common.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.mock_publish.async_publish.assert_called_once_with(
'test_light_rgb/set', 'off', 2, False)
self.mock_publish.async_publish.reset_mock()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.mock_publish.reset_mock()
common.turn_on(self.hass, 'light.test',
brightness=50, xy_color=[0.123, 0.123])
common.turn_on(self.hass, 'light.test', rgb_color=[255, 128, 0],
white_value=80)
self.hass.block_till_done()
self.mock_publish.async_publish.assert_has_calls([
mock.call('test_light_rgb/set', 'on', 2, False),
mock.call('test_light_rgb/rgb/set', '255,128,0', 2, False),
mock.call('test_light_rgb/brightness/set', 50, 2, False),
mock.call('test_light_rgb/white_value/set', 80, 2, False),
mock.call('test_light_rgb/xy/set', '0.14,0.131', 2, False),
], any_order=True)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((255, 128, 0), state.attributes['rgb_color'])
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual(80, state.attributes['white_value'])
self.assertEqual((0.611, 0.375), state.attributes['xy_color'])
