desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test event listener.'
| @mock.patch('statsd.StatsClient')
def test_event_listener_attr_details(self, mock_client):
| config = {'statsd': {'host': 'host', 'log_attributes': True}}
config['statsd'][statsd.CONF_RATE] = statsd.DEFAULT_RATE
self.hass.bus.listen = mock.MagicMock()
setup_component(self.hass, statsd.DOMAIN, config)
self.assertTrue(self.hass.bus.listen.called)
handler_method = self.hass.bus.listen.call_args_list[0][0][1]
valid = {'1': 1, '1.0': 1.0, STATE_ON: 1, STATE_OFF: 0}
for (in_, out) in valid.items():
state = mock.MagicMock(state=in_, attributes={'attribute key': 3.2})
handler_method(mock.MagicMock(data={'new_state': state}))
mock_client.return_value.gauge.assert_has_calls([mock.call(('%s.state' % state.entity_id), out, statsd.DEFAULT_RATE), mock.call(('%s.attribute_key' % state.entity_id), 3.2, statsd.DEFAULT_RATE)])
mock_client.return_value.gauge.reset_mock()
self.assertEqual(mock_client.return_value.incr.call_count, 1)
self.assertEqual(mock_client.return_value.incr.call_args, mock.call(state.entity_id, rate=statsd.DEFAULT_RATE))
mock_client.return_value.incr.reset_mock()
for invalid in ('foo', '', object):
handler_method(mock.MagicMock(data={'new_state': ha.State('domain.test', invalid, {})}))
self.assertFalse(mock_client.return_value.gauge.called)
self.assertTrue(mock_client.return_value.incr.called)
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.hass.states.set('zone.home', 'zoning', {'name': 'home', 'latitude': 2.1, 'longitude': 1.1, 'radius': 10})
self.hass.states.set('zone.work', 'zoning', {'name': 'work', 'latitude': 2.3, 'longitude': 1.3, 'radius': 10})
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test a list of proximities.'
| def test_proximities(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'tolerance': '1'}, 'work': {'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
proximities = ['home', 'work']
for prox in proximities:
state = self.hass.states.get(('proximity.' + prox))
assert (state.state == 'not set')
assert (state.attributes.get('nearest') == 'not set')
assert (state.attributes.get('dir_of_travel') == 'not set')
self.hass.states.set(('proximity.' + prox), '0')
self.hass.block_till_done()
state = self.hass.states.get(('proximity.' + prox))
assert (state.state == '0')
|
'Test a list of proximities with missing devices.'
| def test_proximities_setup(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'tolerance': '1'}, 'work': {'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
|
'Test the proximity.'
| def test_proximity(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
state = self.hass.states.get('proximity.home')
assert (state.state == 'not set')
assert (state.attributes.get('nearest') == 'not set')
assert (state.attributes.get('dir_of_travel') == 'not set')
self.hass.states.set('proximity.home', '0')
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.state == '0')
|
'Test for tracker in zone.'
| def test_device_tracker_test1_in_zone(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'home', {'friendly_name': 'test1', 'latitude': 2.1, 'longitude': 1.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.state == '0')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'arrived')
|
'Test for trackers in zone.'
| def test_device_trackers_in_zone(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'home', {'friendly_name': 'test1', 'latitude': 2.1, 'longitude': 1.1})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'home', {'friendly_name': 'test2', 'latitude': 2.1, 'longitude': 1.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.state == '0')
assert ((state.attributes.get('nearest') == 'test1, test2') or (state.attributes.get('nearest') == 'test2, test1'))
assert (state.attributes.get('dir_of_travel') == 'arrived')
|
'Test for tracker state away.'
| def test_device_tracker_test1_away(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
|
'Test for tracker state away further.'
| def test_device_tracker_test1_awayfurther(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 40.1, 'longitude': 20.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'towards')
|
'Test for tracker state away closer.'
| def test_device_tracker_test1_awaycloser(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 40.1, 'longitude': 20.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'away_from')
|
'Test for tracker in ignored zone.'
| def test_all_device_trackers_in_ignored_zone(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'work', {'friendly_name': 'test1'})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.state == 'not set')
assert (state.attributes.get('nearest') == 'not set')
assert (state.attributes.get('dir_of_travel') == 'not set')
|
'Test for tracker with no coordinates.'
| def test_device_tracker_test1_no_coordinates(self):
| config = {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': '1'}}}
self.assertTrue(setup_component(self.hass, DOMAIN, config))
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1'})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'not set')
assert (state.attributes.get('dir_of_travel') == 'not set')
|
'Test for tracker ordering.'
| def test_device_tracker_test1_awayfurther_than_test2_first_test1(self):
| self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1'})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2'})
self.hass.block_till_done()
assert proximity.setup(self.hass, {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'tolerance': '1', 'zone': 'home'}}})
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2', 'latitude': 40.1, 'longitude': 20.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
|
'Test for tracker ordering.'
| def test_device_tracker_test1_awayfurther_than_test2_first_test2(self):
| self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1'})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2'})
self.hass.block_till_done()
assert proximity.setup(self.hass, {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'zone': 'home'}}})
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2', 'latitude': 40.1, 'longitude': 20.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test2')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
|
'Test for tracker states.'
| def test_device_tracker_test1_awayfurther_test2_in_ignored_zone(self):
| self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1'})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'work', {'friendly_name': 'test2'})
self.hass.block_till_done()
assert proximity.setup(self.hass, {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'zone': 'home'}}})
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
|
'Test for tracker state.'
| def test_device_tracker_test1_awayfurther_test2_first(self):
| self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1'})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2'})
self.hass.block_till_done()
assert proximity.setup(self.hass, {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'zone': 'home'}}})
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 10.1, 'longitude': 5.1})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 40.1, 'longitude': 20.1})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 35.1, 'longitude': 15.1})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test1', 'work', {'friendly_name': 'test1'})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test2')
assert (state.attributes.get('dir_of_travel') == 'unknown')
|
'Test for tracker states.'
| def test_device_tracker_test1_awayfurther_a_bit(self):
| assert proximity.setup(self.hass, {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1'], 'tolerance': 1000, 'zone': 'home'}}})
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1000001, 'longitude': 10.1000001})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1000002, 'longitude': 10.1000002})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'stationary')
|
'Test for tracker states.'
| def test_device_tracker_test1_nearest_after_test2_in_ignored_zone(self):
| self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1'})
self.hass.block_till_done()
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2'})
self.hass.block_till_done()
assert proximity.setup(self.hass, {'proximity': {'home': {'ignored_zones': ['work'], 'devices': ['device_tracker.test1', 'device_tracker.test2'], 'zone': 'home'}}})
self.hass.states.set('device_tracker.test1', 'not_home', {'friendly_name': 'test1', 'latitude': 20.1, 'longitude': 10.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test2', 'not_home', {'friendly_name': 'test2', 'latitude': 10.1, 'longitude': 5.1})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test2')
assert (state.attributes.get('dir_of_travel') == 'unknown')
self.hass.states.set('device_tracker.test2', 'work', {'friendly_name': 'test2', 'latitude': 12.6, 'longitude': 7.6})
self.hass.block_till_done()
state = self.hass.states.get('proximity.home')
assert (state.attributes.get('nearest') == 'test1')
assert (state.attributes.get('dir_of_travel') == 'unknown')
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.mock_publish = mock_mqtt_component(self.hass)
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test if command fails with command topic.'
| def test_fail_setup_if_no_command_topic(self):
| with assert_setup_component(0, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt', 'name': 'test'}})
self.assertIsNone(self.hass.states.get('light.test'))
|
'Test if there is no color and brightness if no topic.'
| def test_no_color_brightness_color_temp_white_xy_if_no_topics(self):
| with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('xy_color'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('xy_color'))
|
'Test the controlling of the state via topic.'
| def test_controlling_state_via_topic(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'color_temp_state_topic': 'test_light_rgb/color_temp/status', 'color_temp_command_topic': 'test_light_rgb/color_temp/set', 'effect_state_topic': 'test_light_rgb/effect/status', 'effect_command_topic': 'test_light_rgb/effect/set', 'white_value_state_topic': 'test_light_rgb/white_value/status', 'white_value_command_topic': 'test_light_rgb/white_value/set', 'xy_state_topic': 'test_light_rgb/xy/status', 'xy_command_topic': 'test_light_rgb/xy/set', 'qos': '0', 'payload_on': 1, 'payload_off': 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)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('effect'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('xy_color'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_light_rgb/status', '1')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
self.assertEqual(255, state.attributes.get('brightness'))
self.assertEqual(150, state.attributes.get('color_temp'))
self.assertEqual('none', state.attributes.get('effect'))
self.assertEqual(255, state.attributes.get('white_value'))
self.assertEqual([1, 1], state.attributes.get('xy_color'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', '0')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
fire_mqtt_message(self.hass, 'test_light_rgb/status', '1')
self.hass.block_till_done()
fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '100')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(100, light_state.attributes['brightness'])
fire_mqtt_message(self.hass, 'test_light_rgb/color_temp/status', '300')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(300, light_state.attributes['color_temp'])
fire_mqtt_message(self.hass, 'test_light_rgb/effect/status', 'rainbow')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual('rainbow', light_state.attributes['effect'])
fire_mqtt_message(self.hass, 'test_light_rgb/white_value/status', '100')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(100, light_state.attributes['white_value'])
fire_mqtt_message(self.hass, 'test_light_rgb/status', '1')
self.hass.block_till_done()
fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '125,125,125')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual([125, 125, 125], light_state.attributes.get('rgb_color'))
fire_mqtt_message(self.hass, 'test_light_rgb/xy/status', '0.675,0.322')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual([0.675, 0.322], light_state.attributes.get('xy_color'))
|
'Test the brightness controlling scale.'
| def test_brightness_controlling_scale(self):
| with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_scale/status', 'command_topic': 'test_scale/set', 'brightness_state_topic': 'test_scale/brightness/status', 'brightness_command_topic': 'test_scale/brightness/set', 'brightness_scale': '99', 'qos': 0, 'payload_on': 'on', 'payload_off': 'off'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertIsNone(state.attributes.get('brightness'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_scale/status', 'on')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('brightness'))
fire_mqtt_message(self.hass, 'test_scale/status', 'off')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
fire_mqtt_message(self.hass, 'test_scale/status', 'on')
self.hass.block_till_done()
fire_mqtt_message(self.hass, 'test_scale/brightness/status', '99')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(255, light_state.attributes['brightness'])
|
'Test the white_value controlling scale.'
| def test_white_value_controlling_scale(self):
| with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_scale/status', 'command_topic': 'test_scale/set', 'white_value_state_topic': 'test_scale/white_value/status', 'white_value_command_topic': 'test_scale/white_value/set', 'white_value_scale': '99', 'qos': 0, 'payload_on': 'on', 'payload_off': 'off'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertIsNone(state.attributes.get('white_value'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_scale/status', 'on')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('white_value'))
fire_mqtt_message(self.hass, 'test_scale/status', 'off')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
fire_mqtt_message(self.hass, 'test_scale/status', 'on')
self.hass.block_till_done()
fire_mqtt_message(self.hass, 'test_scale/white_value/status', '99')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(255, light_state.attributes['white_value'])
|
'Test the setting og the state with a template.'
| def test_controlling_state_via_topic_with_templates(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'color_temp_state_topic': 'test_light_rgb/color_temp/status', 'effect_state_topic': 'test_light_rgb/effect/status', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'white_value_state_topic': 'test_light_rgb/white_value/status', 'xy_state_topic': 'test_light_rgb/xy/status', 'state_value_template': '{{ value_json.hello }}', 'brightness_value_template': '{{ value_json.hello }}', 'color_temp_value_template': '{{ value_json.hello }}', 'effect_value_template': '{{ value_json.hello }}', 'rgb_value_template': '{{ value_json.hello | join(",") }}', 'white_value_template': '{{ value_json.hello }}', 'xy_value_template': '{{ value_json.hello | join(",") }}'}}
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)
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('rgb_color'))
fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '{"hello": [1, 2, 3]}')
fire_mqtt_message(self.hass, 'test_light_rgb/status', '{"hello": "ON"}')
fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '{"hello": "50"}')
fire_mqtt_message(self.hass, 'test_light_rgb/color_temp/status', '{"hello": "300"}')
fire_mqtt_message(self.hass, 'test_light_rgb/effect/status', '{"hello": "rainbow"}')
fire_mqtt_message(self.hass, 'test_light_rgb/white_value/status', '{"hello": "75"}')
fire_mqtt_message(self.hass, 'test_light_rgb/xy/status', '{"hello": [0.123,0.123]}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(50, state.attributes.get('brightness'))
self.assertEqual([1, 2, 3], state.attributes.get('rgb_color'))
self.assertEqual(300, state.attributes.get('color_temp'))
self.assertEqual('rainbow', state.attributes.get('effect'))
self.assertEqual(75, state.attributes.get('white_value'))
self.assertEqual([0.123, 0.123], state.attributes.get('xy_color'))
|
'Test the sending of command in optimistic mode.'
| def test_sending_mqtt_commands_and_optimistic(self):
| 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', 'qos': 2, 'payload_on': 'on', 'payload_off': 'off'}}
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)
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
light.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.assertEqual(('test_light_rgb/set', 'on', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
light.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.assertEqual(('test_light_rgb/set', 'off', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.mock_publish.reset_mock()
light.turn_on(self.hass, 'light.test', brightness=50, xy_color=[0.123, 0.123])
light.turn_on(self.hass, 'light.test', rgb_color=[75, 75, 75], 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', '75,75,75', 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.123,0.123', 2, False)], any_order=True)
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((75, 75, 75), state.attributes['rgb_color'])
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual(80, state.attributes['white_value'])
self.assertEqual((0.123, 0.123), state.attributes['xy_color'])
|
'Test the brightness if only a command topic is present.'
| def test_show_brightness_if_only_command_topic(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status'}}
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)
self.assertIsNone(state.attributes.get('brightness'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('brightness'))
|
'Test the color temp only if a command topic is present.'
| def test_show_color_temp_only_if_command_topic(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'color_temp_command_topic': 'test_light_rgb/brightness/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status'}}
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)
self.assertIsNone(state.attributes.get('color_temp'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(150, state.attributes.get('color_temp'))
|
'Test the color temp only if a command topic is present.'
| def test_show_effect_only_if_command_topic(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'effect_command_topic': 'test_light_rgb/effect/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status'}}
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)
self.assertIsNone(state.attributes.get('effect'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual('none', state.attributes.get('effect'))
|
'Test the white_value if only a command topic is present.'
| def test_show_white_value_if_only_command_topic(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'white_value_command_topic': 'test_light_rgb/white_value/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status'}}
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)
self.assertIsNone(state.attributes.get('white_value'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('white_value'))
|
'Test the xy if only a command topic is present.'
| def test_show_xy_if_only_command_topic(self):
| config = {light.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'xy_command_topic': 'test_light_rgb/xy/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status'}}
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)
self.assertIsNone(state.attributes.get('xy_color'))
fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual([1, 1], state.attributes.get('xy_color'))
|
'Setup things to be run when tests are started.'
| @mock.patch('pylitejet.LiteJet')
def setup_method(self, method, mock_pylitejet):
| self.hass = get_test_home_assistant()
self.hass.start()
self.load_activated_callbacks = {}
self.load_deactivated_callbacks = {}
def get_load_name(number):
return ('Mock Load #' + str(number))
def on_load_activated(number, callback):
self.load_activated_callbacks[number] = callback
def on_load_deactivated(number, callback):
self.load_deactivated_callbacks[number] = callback
self.mock_lj = mock_pylitejet.return_value
self.mock_lj.loads.return_value = range(1, 3)
self.mock_lj.button_switches.return_value = range(0)
self.mock_lj.all_switches.return_value = range(0)
self.mock_lj.scenes.return_value = range(0)
self.mock_lj.get_load_level.return_value = 0
self.mock_lj.get_load_name.side_effect = get_load_name
self.mock_lj.on_load_activated.side_effect = on_load_activated
self.mock_lj.on_load_deactivated.side_effect = on_load_deactivated
assert setup.setup_component(self.hass, litejet.DOMAIN, {'litejet': {'port': '/tmp/this_will_be_mocked'}})
self.hass.block_till_done()
self.mock_lj.get_load_level.reset_mock()
|
'Test for main light entity.'
| def light(self):
| return self.hass.states.get(ENTITY_LIGHT)
|
'Test the other light.'
| def other_light(self):
| return self.hass.states.get(ENTITY_OTHER_LIGHT)
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Test turning the light on with brightness.'
| def test_on_brightness(self):
| assert (self.light().state == 'off')
assert (self.other_light().state == 'off')
assert (not light.is_on(self.hass, ENTITY_LIGHT))
light.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)
|
'Test turning the light on and off.'
| def test_on_off(self):
| assert (self.light().state == 'off')
assert (self.other_light().state == 'off')
assert (not light.is_on(self.hass, ENTITY_LIGHT))
light.turn_on(self.hass, ENTITY_LIGHT)
self.hass.block_till_done()
self.mock_lj.activate_load.assert_called_with(ENTITY_LIGHT_NUMBER)
light.turn_off(self.hass, ENTITY_LIGHT)
self.hass.block_till_done()
self.mock_lj.deactivate_load.assert_called_with(ENTITY_LIGHT_NUMBER)
|
'Test handling an event from LiteJet.'
| def test_activated_event(self):
| self.mock_lj.get_load_level.return_value = 99
_LOGGER.info(self.load_activated_callbacks[ENTITY_LIGHT_NUMBER])
self.load_activated_callbacks[ENTITY_LIGHT_NUMBER]()
self.hass.block_till_done()
self.mock_lj.get_load_level.assert_called_once_with(ENTITY_LIGHT_NUMBER)
assert light.is_on(self.hass, ENTITY_LIGHT)
assert (not light.is_on(self.hass, ENTITY_OTHER_LIGHT))
assert (self.light().state == 'on')
assert (self.other_light().state == 'off')
assert (self.light().attributes.get(light.ATTR_BRIGHTNESS) == 255)
self.mock_lj.get_load_level.return_value = 40
self.mock_lj.get_load_level.reset_mock()
self.load_activated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
self.hass.block_till_done()
self.mock_lj.get_load_level.assert_called_once_with(ENTITY_OTHER_LIGHT_NUMBER)
assert light.is_on(self.hass, ENTITY_OTHER_LIGHT)
assert light.is_on(self.hass, ENTITY_LIGHT)
assert (self.light().state == 'on')
assert (self.other_light().state == 'on')
assert (int(self.other_light().attributes[light.ATTR_BRIGHTNESS]) == 103)
|
'Test handling an event from LiteJet.'
| def test_deactivated_event(self):
| self.mock_lj.get_load_level.return_value = 99
self.load_activated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
self.hass.block_till_done()
assert light.is_on(self.hass, ENTITY_OTHER_LIGHT)
self.mock_lj.get_load_level.reset_mock()
self.mock_lj.get_load_level.return_value = 0
self.load_deactivated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
self.hass.block_till_done()
self.mock_lj.get_load_level.assert_called_with(ENTITY_OTHER_LIGHT_NUMBER)
assert (not light.is_on(self.hass, ENTITY_OTHER_LIGHT))
assert (not light.is_on(self.hass, ENTITY_LIGHT))
assert (self.light().state == 'off')
assert (self.other_light().state == 'off')
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
mock_component(self.hass, 'rfxtrx')
|
'Stop everything that was started.'
| def tearDown(self):
| rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS = []
rfxtrx_core.RFX_DEVICES = {}
if rfxtrx_core.RFXOBJECT:
rfxtrx_core.RFXOBJECT.close_connection()
self.hass.stop()
|
'Test configuration.'
| def test_valid_config(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {'0b1100cd0213c7f210010f51': {'name': 'Test', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {'213c7f216': {'name': 'Test', 'packetid': '0b1100cd0213c7f210010f51', 'signal_repetitions': 3}}}}))
|
'Test configuration.'
| def test_invalid_config(self):
| self.assertFalse(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'automatic_add': True, 'invalid_key': 'afda', 'devices': {'213c7f216': {'name': 'Test', 'packetid': '0b1100cd0213c7f210010f51', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
|
'Test with 0 switches.'
| def test_default_config(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'devices': {}}}))
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
|
'Test with 1 light.'
| def test_old_config(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'devices': {'123efab1': {'name': 'Test', 'packetid': '0b1100cd0213c7f210010f51'}}}}))
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT = rfxtrxmod.Core('', transport_protocol=rfxtrxmod.DummyTransport)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['213c7f216']
self.assertEqual('Test', entity.name)
self.assertEqual('off', entity.state)
self.assertTrue(entity.assumed_state)
self.assertEqual(entity.signal_repetitions, 1)
self.assertFalse(entity.should_fire_event)
self.assertFalse(entity.should_poll)
self.assertFalse(entity.is_on)
entity.turn_on()
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 255)
entity.turn_off()
self.assertFalse(entity.is_on)
self.assertEqual(entity.brightness, 0)
entity.turn_on(brightness=100)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 100)
entity.turn_on(brightness=10)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 10)
entity.turn_on(brightness=255)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 255)
|
'Test with 1 light.'
| def test_one_light(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'devices': {'0b1100cd0213c7f210010f51': {'name': 'Test'}}}}))
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT = rfxtrxmod.Core('', transport_protocol=rfxtrxmod.DummyTransport)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['213c7f216']
self.assertEqual('Test', entity.name)
self.assertEqual('off', entity.state)
self.assertTrue(entity.assumed_state)
self.assertEqual(entity.signal_repetitions, 1)
self.assertFalse(entity.should_fire_event)
self.assertFalse(entity.should_poll)
self.assertFalse(entity.is_on)
entity.turn_on()
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 255)
entity.turn_off()
self.assertFalse(entity.is_on)
self.assertEqual(entity.brightness, 0)
entity.turn_on(brightness=100)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 100)
entity.turn_on(brightness=10)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 10)
entity.turn_on(brightness=255)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 255)
entity.turn_off()
entity_id = rfxtrx_core.RFX_DEVICES['213c7f216'].entity_id
entity_hass = self.hass.states.get(entity_id)
self.assertEqual('Test', entity_hass.name)
self.assertEqual('off', entity_hass.state)
entity.turn_on()
entity_hass = self.hass.states.get(entity_id)
self.assertEqual('on', entity_hass.state)
entity.turn_off()
entity_hass = self.hass.states.get(entity_id)
self.assertEqual('off', entity_hass.state)
entity.turn_on(brightness=100)
entity_hass = self.hass.states.get(entity_id)
self.assertEqual('on', entity_hass.state)
entity.turn_on(brightness=10)
entity_hass = self.hass.states.get(entity_id)
self.assertEqual('on', entity_hass.state)
entity.turn_on(brightness=255)
entity_hass = self.hass.states.get(entity_id)
self.assertEqual('on', entity_hass.state)
|
'Test with 3 lights.'
| def test_several_lights(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'signal_repetitions': 3, 'devices': {'0b1100cd0213c7f230010f71': {'name': 'Test'}, '0b1100100118cdea02010f70': {'name': 'Bath'}, '0b1100101118cdea02010f70': {'name': 'Living'}}}}))
self.assertEqual(3, len(rfxtrx_core.RFX_DEVICES))
device_num = 0
for id in rfxtrx_core.RFX_DEVICES:
entity = rfxtrx_core.RFX_DEVICES[id]
self.assertEqual(entity.signal_repetitions, 3)
if (entity.name == 'Living'):
device_num = (device_num + 1)
self.assertEqual('off', entity.state)
self.assertEqual('<Entity Living: off>', entity.__str__())
elif (entity.name == 'Bath'):
device_num = (device_num + 1)
self.assertEqual('off', entity.state)
self.assertEqual('<Entity Bath: off>', entity.__str__())
elif (entity.name == 'Test'):
device_num = (device_num + 1)
self.assertEqual('off', entity.state)
self.assertEqual('<Entity Test: off>', entity.__str__())
self.assertEqual(3, device_num)
|
'Test with discovery of lights.'
| def test_discover_light(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {}}}))
event = rfxtrx_core.get_rfx_object('0b11009e00e6116202020070')
event.data = bytearray('\x0b\x11\x00\x9e\x00\xe6\x11b\x02\x02\x00p')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
entity = rfxtrx_core.RFX_DEVICES['0e611622']
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual('<Entity 0b11009e00e6116202020070: on>', entity.__str__())
event = rfxtrx_core.get_rfx_object('0b11009e00e6116201010070')
event.data = bytearray('\x0b\x11\x00\x9e\x00\xe6\x11b\x01\x01\x00p')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100120118cdea02020070')
event.data = bytearray([11, 17, 0, 18, 1, 24, 205, 234, 2, 2, 0, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
entity = rfxtrx_core.RFX_DEVICES['118cdea2']
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual('<Entity 0b1100120118cdea02020070: on>', entity.__str__())
event = rfxtrx_core.get_rfx_object('0a52085e070100b31b0279')
event.data = bytearray('\nR\x08^\x07\x01\x00\xb3\x1b\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100100118cdea02010f70')
event.data = bytearray([11, 17, 0, 16, 1, 24, 205, 234, 1, 1, 15, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0a1400adf394ab020e0060')
event.data = bytearray([10, 20, 0, 173, 243, 148, 171, 2, 14, 0, 96])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
|
'Test with discover of light when auto add is False.'
| def test_discover_light_noautoadd(self):
| self.assertTrue(setup_component(self.hass, 'light', {'light': {'platform': 'rfxtrx', 'automatic_add': False, 'devices': {}}}))
event = rfxtrx_core.get_rfx_object('0b1100120118cdea02020070')
event.data = bytearray([11, 17, 0, 18, 1, 24, 205, 234, 2, 2, 0, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100120118cdea02010070')
event.data = bytearray([11, 17, 0, 18, 1, 24, 205, 234, 2, 1, 0, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100120118cdea02020070')
event.data = bytearray([11, 17, 0, 18, 1, 24, 205, 234, 2, 2, 0, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0a52085e070100b31b0279')
event.data = bytearray('\nR\x08^\x07\x01\x00\xb3\x1b\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100100118cdea02010f70')
event.data = bytearray([11, 17, 0, 16, 1, 24, 205, 234, 1, 1, 15, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0a1400adf394ab020e0060')
event.data = bytearray([10, 20, 0, 173, 243, 148, 171, 2, 14, 0, 96])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
if os.path.isfile(user_light_file):
os.remove(user_light_file)
|
'Test if methods call the services as expected.'
| def test_methods(self):
| 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))
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
light.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))
turn_off_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_OFF)
light.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])
toggle_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TOGGLE)
light.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])
|
'Test the provided services.'
| def test_services(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
(dev1, dev2, dev3) = platform.DEVICES
self.assertTrue(light.is_on(self.hass, dev1.entity_id))
self.assertFalse(light.is_on(self.hass, dev2.entity_id))
self.assertFalse(light.is_on(self.hass, dev3.entity_id))
light.turn_off(self.hass, entity_id=dev1.entity_id)
light.turn_on(self.hass, entity_id=dev2.entity_id)
self.hass.block_till_done()
self.assertFalse(light.is_on(self.hass, dev1.entity_id))
self.assertTrue(light.is_on(self.hass, dev2.entity_id))
light.turn_on(self.hass)
self.hass.block_till_done()
self.assertTrue(light.is_on(self.hass, dev1.entity_id))
self.assertTrue(light.is_on(self.hass, dev2.entity_id))
self.assertTrue(light.is_on(self.hass, dev3.entity_id))
light.turn_off(self.hass)
self.hass.block_till_done()
self.assertFalse(light.is_on(self.hass, dev1.entity_id))
self.assertFalse(light.is_on(self.hass, dev2.entity_id))
self.assertFalse(light.is_on(self.hass, dev3.entity_id))
light.toggle(self.hass)
self.hass.block_till_done()
self.assertTrue(light.is_on(self.hass, dev1.entity_id))
self.assertTrue(light.is_on(self.hass, dev2.entity_id))
self.assertTrue(light.is_on(self.hass, dev3.entity_id))
light.toggle(self.hass)
self.hass.block_till_done()
self.assertFalse(light.is_on(self.hass, dev1.entity_id))
self.assertFalse(light.is_on(self.hass, dev2.entity_id))
self.assertFalse(light.is_on(self.hass, dev3.entity_id))
light.turn_on(self.hass, dev1.entity_id, transition=10, brightness=20, color_name='blue')
light.turn_on(self.hass, dev2.entity_id, rgb_color=(255, 255, 255), white_value=255)
light.turn_on(self.hass, dev3.entity_id, xy_color=(0.4, 0.6))
self.hass.block_till_done()
(_, data) = dev1.last_call('turn_on')
self.assertEqual({light.ATTR_TRANSITION: 10, light.ATTR_BRIGHTNESS: 20, light.ATTR_RGB_COLOR: (0, 0, 255)}, data)
(_, data) = dev2.last_call('turn_on')
self.assertEqual({light.ATTR_RGB_COLOR: (255, 255, 255), light.ATTR_WHITE_VALUE: 255}, data)
(_, data) = dev3.last_call('turn_on')
self.assertEqual({light.ATTR_XY_COLOR: (0.4, 0.6)}, data)
(prof_name, prof_x, prof_y, prof_bri) = ('relax', 0.5119, 0.4147, 144)
light.turn_on(self.hass, dev1.entity_id, profile=prof_name)
light.turn_on(self.hass, dev2.entity_id, profile=prof_name, brightness=100)
self.hass.block_till_done()
(_, data) = dev1.last_call('turn_on')
self.assertEqual({light.ATTR_BRIGHTNESS: prof_bri, light.ATTR_XY_COLOR: (prof_x, prof_y)}, data)
(_, data) = dev2.last_call('turn_on')
self.assertEqual({light.ATTR_BRIGHTNESS: 100, light.ATTR_XY_COLOR: (0.5119, 0.4147)}, data)
light.turn_on(self.hass)
light.turn_on(self.hass, dev1.entity_id, profile='nonexisting')
light.turn_on(self.hass, dev2.entity_id, xy_color=['bla-di-bla', 5])
light.turn_on(self.hass, dev3.entity_id, rgb_color=[255, None, 2])
self.hass.block_till_done()
(_, data) = dev1.last_call('turn_on')
self.assertEqual({}, data)
(_, data) = dev2.last_call('turn_on')
self.assertEqual({}, data)
(_, data) = dev3.last_call('turn_on')
self.assertEqual({}, data)
light.turn_on(self.hass, dev1.entity_id, profile=prof_name, brightness='bright')
light.turn_on(self.hass, dev1.entity_id, rgb_color='yellowish')
light.turn_on(self.hass, dev2.entity_id, white_value='high')
self.hass.block_till_done()
(_, data) = dev1.last_call('turn_on')
self.assertEqual({}, data)
(_, data) = dev2.last_call('turn_on')
self.assertEqual({}, data)
|
'Test light profiles.'
| def test_broken_light_profiles(self):
| platform = loader.get_component('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('I,WILL,NOT,WORK\n')
self.assertFalse(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
|
'Test light profiles.'
| def test_light_profiles(self):
| platform = loader.get_component('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')
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
(dev1, _, _) = platform.DEVICES
light.turn_on(self.hass, dev1.entity_id, profile='test')
self.hass.block_till_done()
(_, data) = dev1.last_call('turn_on')
self.assertEqual({light.ATTR_XY_COLOR: (0.4, 0.6), light.ATTR_BRIGHTNESS: 100}, data)
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.mock_publish = mock_mqtt_component(self.hass)
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test that setup fails with missing required configuration items.'
| def test_setup_fails(self):
| with assert_setup_component(0, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt_template', 'name': 'test'}})
self.assertIsNone(self.hass.states.get('light.test'))
|
'Test state change via topic.'
| def test_state_change_via_topic(self):
| with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt_template', 'name': 'test', 'state_topic': 'test_light_rgb', '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', 'state_template': '{{ value.split(",")[0] }}'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('white_value'))
|
'Test state, bri, color, effect, color temp, white val change.'
| def test_state_brightness_color_effect_temp_white_change_via_topic(self):
| with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt_template', 'name': 'test', 'effect_list': ['rainbow', 'colorloop'], 'state_topic': 'test_light_rgb', 'command_topic': 'test_light_rgb/set', 'command_on_template': 'on,{{ brightness|d }},{{ color_temp|d }},{{ white_value|d }},{{ red|d }}-{{ green|d }}-{{ blue|d }},{{ effect|d }}', 'command_off_template': 'off', 'state_template': '{{ value.split(",")[0] }}', 'brightness_template': '{{ value.split(",")[1] }}', 'color_temp_template': '{{ value.split(",")[2] }}', 'white_value_template': '{{ value.split(",")[3] }}', 'red_template': '{{ value.split(",")[4].split("-")[0] }}', 'green_template': '{{ value.split(",")[4].split("-")[1] }}', 'blue_template': '{{ value.split(",")[4].split("-")[2] }}', 'effect_template': '{{ value.split(",")[5] }}'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('effect'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,255,145,123,255-255-255,')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
self.assertEqual(255, state.attributes.get('brightness'))
self.assertEqual(145, state.attributes.get('color_temp'))
self.assertEqual(123, state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('effect'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'off')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,100')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(100, light_state.attributes['brightness'])
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,,195')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(195, light_state.attributes['color_temp'])
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,,,,41-42-43')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual([41, 42, 43], light_state.attributes.get('rgb_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,,,134')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(134, light_state.attributes['white_value'])
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,,,,41-42-43,rainbow')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual('rainbow', light_state.attributes.get('effect'))
|
'Test optimistic mode.'
| def test_optimistic(self):
| 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', 'qos': 2}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
light.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.assertEqual(('test_light_rgb/set', 'on,,,,--', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
light.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.assertEqual(('test_light_rgb/set', 'off', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
light.turn_on(self.hass, 'light.test', brightness=50, rgb_color=[75, 75, 75])
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
payload = self.mock_publish.mock_calls[(-2)][1][1]
self.assertEqual('on,50,,,75-75-75', payload)
light.turn_on(self.hass, 'light.test', color_temp=200, white_value=139)
self.hass.block_till_done()
payload = self.mock_publish.mock_calls[(-2)][1][1]
self.assertEqual('on,,200,139,--', payload)
self.assertEqual(2, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual((75, 75, 75), state.attributes['rgb_color'])
self.assertEqual(50, state.attributes['brightness'])
self.assertEqual(200, state.attributes['color_temp'])
self.assertEqual(139, state.attributes['white_value'])
|
'Test flash.'
| def test_flash(self):
| 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)
light.turn_on(self.hass, 'light.test', flash='short')
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
payload = self.mock_publish.mock_calls[(-2)][1][1]
self.assertEqual('on,short', payload)
light.turn_on(self.hass, 'light.test', flash='long')
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
payload = self.mock_publish.mock_calls[(-2)][1][1]
self.assertEqual('on,long', payload)
|
'Test for transition time being sent when included.'
| def test_transition(self):
| 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)
light.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
payload = self.mock_publish.mock_calls[(-2)][1][1]
self.assertEqual('on,10', payload)
light.turn_off(self.hass, 'light.test', transition=4)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
payload = self.mock_publish.mock_calls[(-2)][1][1]
self.assertEqual('off,4', payload)
|
'Test that invalid values are ignored.'
| def test_invalid_values(self):
| with assert_setup_component(1, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt_template', 'name': 'test', 'effect_list': ['rainbow', 'colorloop'], 'state_topic': 'test_light_rgb', 'command_topic': 'test_light_rgb/set', 'command_on_template': 'on,{{ brightness|d }},{{ color_temp|d }},{{ red|d }}-{{ green|d }}-{{ blue|d }},{{ effect|d }}', 'command_off_template': 'off', 'state_template': '{{ value.split(",")[0] }}', 'brightness_template': '{{ value.split(",")[1] }}', 'color_temp_template': '{{ value.split(",")[2] }}', 'white_value_template': '{{ value.split(",")[3] }}', 'red_template': '{{ value.split(",")[4].split("-")[0] }}', 'green_template': '{{ value.split(",")[4].split("-")[1] }}', 'blue_template': '{{ value.split(",")[4].split("-")[2] }}', 'effect_template': '{{ value.split(",")[5] }}'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('effect'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,255,215,222,255-255-255,rainbow')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('brightness'))
self.assertEqual(215, state.attributes.get('color_temp'))
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
self.assertEqual(222, state.attributes.get('white_value'))
self.assertEqual('rainbow', state.attributes.get('effect'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'offf')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,off,255-255-255')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(255, state.attributes.get('brightness'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,,off,255-255-255')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(215, state.attributes.get('color_temp'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,255,a-b-c')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,,,off,255-255-255')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(222, state.attributes.get('white_value'))
fire_mqtt_message(self.hass, 'test_light_rgb', 'on,255,a-b-c,white')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual('rainbow', state.attributes.get('effect'))
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.mock_publish = mock_mqtt_component(self.hass)
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test if setup fails with no command topic.'
| def test_fail_setup_if_no_command_topic(self):
| with assert_setup_component(0, light.DOMAIN):
assert setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {'platform': 'mqtt_json', 'name': 'test'}})
self.assertIsNone(self.hass.states.get('light.test'))
|
'Test for no RGB, brightness, color temp, effect, white val or XY.'
| def test_no_color_brightness_color_temp_white_val_if_no_topics(self):
| 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'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(40, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('effect'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('xy_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON"}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('effect'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('xy_color'))
|
'Test the controlling of the state via topic.'
| def test_controlling_state_via_topic(self):
| 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', 'brightness': True, 'color_temp': True, 'effect': True, 'rgb': True, 'white_value': True, 'xy': True, 'qos': '0'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(255, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('color_temp'))
self.assertIsNone(state.attributes.get('effect'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertIsNone(state.attributes.get('xy_color'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","color":{"r":255,"g":255,"b":255,"x":0.123,"y":0.123},"brightness":255,"color_temp":155,"effect":"colorloop","white_value":150}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
self.assertEqual(255, state.attributes.get('brightness'))
self.assertEqual(155, state.attributes.get('color_temp'))
self.assertEqual('colorloop', state.attributes.get('effect'))
self.assertEqual(150, state.attributes.get('white_value'))
self.assertEqual([0.123, 0.123], state.attributes.get('xy_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"OFF"}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","brightness":100}')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.hass.block_till_done()
self.assertEqual(100, light_state.attributes['brightness'])
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","color":{"r":125,"g":125,"b":125}}')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual([125, 125, 125], light_state.attributes.get('rgb_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","color":{"x":0.135,"y":0.135}}')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual([0.135, 0.135], light_state.attributes.get('xy_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","color_temp":155}')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual(155, light_state.attributes.get('color_temp'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","effect":"colorloop"}')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual('colorloop', light_state.attributes.get('effect'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","white_value":155}')
self.hass.block_till_done()
light_state = self.hass.states.get('light.test')
self.assertEqual(155, light_state.attributes.get('white_value'))
|
'Test the sending of command in optimistic mode.'
| def test_sending_mqtt_commands_and_optimistic(self):
| 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_OFF, state.state)
self.assertEqual(191, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
light.turn_on(self.hass, 'light.test')
self.hass.block_till_done()
self.assertEqual(('test_light_rgb/set', '{"state": "ON"}', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
light.turn_off(self.hass, 'light.test')
self.hass.block_till_done()
self.assertEqual(('test_light_rgb/set', '{"state": "OFF"}', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
light.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.mock_calls[(-2)][1][0])
self.assertEqual(2, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
message_json = json.loads(self.mock_publish.mock_calls[(-2)][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 for flash length being sent when included.'
| def test_flash_short_and_long(self):
| 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))
light.turn_on(self.hass, 'light.test', flash='short')
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
message_json = json.loads(self.mock_publish.mock_calls[(-2)][1][1])
self.assertEqual(5, message_json['flash'])
self.assertEqual('ON', message_json['state'])
light.turn_on(self.hass, 'light.test', flash='long')
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
message_json = json.loads(self.mock_publish.mock_calls[(-2)][1][1])
self.assertEqual(15, message_json['flash'])
self.assertEqual('ON', message_json['state'])
|
'Test for transition time being sent when included.'
| def test_transition(self):
| 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))
light.turn_on(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
message_json = json.loads(self.mock_publish.mock_calls[(-2)][1][1])
self.assertEqual(10, message_json['transition'])
self.assertEqual('ON', message_json['state'])
light.turn_off(self.hass, 'light.test', transition=10)
self.hass.block_till_done()
self.assertEqual('test_light_rgb/set', self.mock_publish.mock_calls[(-2)][1][0])
self.assertEqual(0, self.mock_publish.mock_calls[(-2)][1][2])
self.assertEqual(False, self.mock_publish.mock_calls[(-2)][1][3])
message_json = json.loads(self.mock_publish.mock_calls[(-2)][1][1])
self.assertEqual(10, message_json['transition'])
self.assertEqual('OFF', message_json['state'])
|
'Test that invalid color/brightness/white values are ignored.'
| def test_invalid_color_brightness_and_white_values(self):
| 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', 'brightness': True, 'rgb': True, 'white_value': True, 'qos': '0'}})
state = self.hass.states.get('light.test')
self.assertEqual(STATE_OFF, state.state)
self.assertEqual(185, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertIsNone(state.attributes.get('rgb_color'))
self.assertIsNone(state.attributes.get('brightness'))
self.assertIsNone(state.attributes.get('white_value'))
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","color":{"r":255,"g":255,"b":255},"brightness": 255,"white_value": 255}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
self.assertEqual(255, state.attributes.get('brightness'))
self.assertEqual(255, state.attributes.get('white_value'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","color":{"r":"bad","g":"val","b":"test"}}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","brightness": "badValue"}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('brightness'))
fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON","white_value": "badValue"}')
self.hass.block_till_done()
state = self.hass.states.get('light.test')
self.assertEqual(STATE_ON, state.state)
self.assertEqual(255, state.attributes.get('white_value'))
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
|
'Stop everyhing that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test if setup adds devices.'
| @mock.patch('homeassistant.components.light.mochad.MochadLight')
def test_setup_adds_proper_devices(self, mock_light):
| good_config = {'mochad': {}, 'light': {'platform': 'mochad', 'devices': [{'name': 'Light1', 'address': 'a1'}]}}
self.assertTrue(setup_component(self.hass, light.DOMAIN, good_config))
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
controller_mock = mock.MagicMock()
dev_dict = {'address': 'a1', 'name': 'fake_light'}
self.light = mochad.MochadLight(self.hass, controller_mock, dev_dict)
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Test the name.'
| def test_name(self):
| self.assertEqual('fake_light', self.light.name)
|
'Test turn_on.'
| def test_turn_on_with_no_brightness(self):
| self.light.turn_on()
self.light.device.send_cmd.assert_called_once_with('xdim 255')
|
'Test turn_on.'
| def test_turn_on_with_brightness(self):
| self.light.turn_on(brightness=45)
self.light.device.send_cmd.assert_called_once_with('xdim 45')
|
'Test turn_off.'
| def test_turn_off(self):
| self.light.turn_off()
self.light.device.send_cmd.assert_called_once_with('off')
|
'Initialize the mock zwave values.'
| def __init__(self, **kwargs):
| self.dimming_duration = None
self.color = None
self.color_channels = None
super().__init__(**kwargs)
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
mock_component(self.hass, 'group')
self.calls = []
@callback
def record_call(service):
'Helper to record calls.'
self.calls.append(service)
self.hass.services.register('test', 'automation', record_call)
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test for firing if hour is matching.'
| def test_if_fires_when_hour_matches(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'hours': 0}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
automation.turn_off(self.hass)
self.hass.block_till_done()
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing if minutes are matching.'
| def test_if_fires_when_minute_matches(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'minutes': 0}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(minute=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing if seconds are matching.'
| def test_if_fires_when_second_matches(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'seconds': 0}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(second=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing if everything matches.'
| def test_if_fires_when_all_matches(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'hours': 1, 'minutes': 2, 'seconds': 3}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=1, minute=2, second=3))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing periodically every second.'
| def test_if_fires_periodic_seconds(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'seconds': '/2'}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=0, minute=0, second=2))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing periodically every minute.'
| def test_if_fires_periodic_minutes(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'minutes': '/2'}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=0, minute=2, second=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing periodically every hour.'
| def test_if_fires_periodic_hours(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'hours': '/2'}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=2, minute=0, second=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for firing at.'
| def test_if_fires_using_at(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'at': '5:00:00'}, 'action': {'service': 'test.automation', 'data_template': {'some': '{{ trigger.platform }} - {{ trigger.now.hour }}'}}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=5, minute=0, second=0))
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('time - 5', self.calls[0].data['some'])
|
'Test for failure if no configuration.'
| def test_if_not_working_if_no_values_in_conf_provided(self):
| with assert_setup_component(0):
assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time'}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=5, minute=0, second=0))
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
|
'YAML translates time values to total seconds.
This should break the before rule.'
| def test_if_not_fires_using_wrong_at(self):
| with assert_setup_component(0):
assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'time', 'at': 3605}, 'action': {'service': 'test.automation'}}})
fire_time_changed(self.hass, dt_util.utcnow().replace(hour=1, minute=0, second=5))
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
|
'Test for if action before.'
| def test_if_action_before(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'event', 'event_type': 'test_event'}, 'condition': {'condition': 'time', 'before': '10:00'}, 'action': {'service': 'test.automation'}}})
before_10 = dt_util.now().replace(hour=8)
after_10 = dt_util.now().replace(hour=14)
with patch('homeassistant.helpers.condition.dt_util.now', return_value=before_10):
self.hass.bus.fire('test_event')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
with patch('homeassistant.helpers.condition.dt_util.now', return_value=after_10):
self.hass.bus.fire('test_event')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for if action after.'
| def test_if_action_after(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'event', 'event_type': 'test_event'}, 'condition': {'condition': 'time', 'after': '10:00'}, 'action': {'service': 'test.automation'}}})
before_10 = dt_util.now().replace(hour=8)
after_10 = dt_util.now().replace(hour=14)
with patch('homeassistant.helpers.condition.dt_util.now', return_value=before_10):
self.hass.bus.fire('test_event')
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
with patch('homeassistant.helpers.condition.dt_util.now', return_value=after_10):
self.hass.bus.fire('test_event')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
'Test for if action with one weekday.'
| def test_if_action_one_weekday(self):
| assert setup_component(self.hass, automation.DOMAIN, {automation.DOMAIN: {'trigger': {'platform': 'event', 'event_type': 'test_event'}, 'condition': {'condition': 'time', 'weekday': 'mon'}, 'action': {'service': 'test.automation'}}})
days_past_monday = dt_util.now().weekday()
monday = (dt_util.now() - timedelta(days=days_past_monday))
tuesday = (monday + timedelta(days=1))
with patch('homeassistant.helpers.condition.dt_util.now', return_value=monday):
self.hass.bus.fire('test_event')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
with patch('homeassistant.helpers.condition.dt_util.now', return_value=tuesday):
self.hass.bus.fire('test_event')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.