desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test that all data from the service gets forwarded to service.'
| def test_method_forwards_correct_data(self):
| self._setup_notify()
notify.send_message(self.hass, 'my message', 'my title', {'hello': 'world'})
self.hass.block_till_done()
self.assertTrue((len(self.events) == 1))
data = self.events[0].data
assert ({'message': 'my message', 'title': 'my title', 'data': {'hello': 'world'}} == data)
|
'Test if we can call a notify from a script.'
| def test_calling_notify_from_script_loaded_from_yaml_without_title(self):
| self._setup_notify()
conf = {'service': 'notify.notify', 'data': {'data': {'push': {'sound': 'US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav'}}}, 'data_template': {'message': 'Test 123 {{ 2 + 2 }}\n'}}
script.call_from_config(self.hass, conf)
self.hass.block_till_done()
self.assertTrue((len(self.events) == 1))
assert ({'message': 'Test 123 4', 'data': {'push': {'sound': 'US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav'}}} == self.events[0].data)
|
'Test if we can call a notify from a script.'
| def test_calling_notify_from_script_loaded_from_yaml_with_title(self):
| self._setup_notify()
conf = {'service': 'notify.notify', 'data': {'data': {'push': {'sound': 'US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav'}}}, 'data_template': {'message': 'Test 123 {{ 2 + 2 }}\n', 'title': 'Test'}}
script.call_from_config(self.hass, conf)
self.hass.block_till_done()
self.assertTrue((len(self.events) == 1))
assert ({'message': 'Test 123 4', 'title': 'Test', 'data': {'push': {'sound': 'US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav'}}} == self.events[0].data)
|
'Test that all targets are exposed as individual services.'
| def test_targets_are_services(self):
| self._setup_notify()
self.assertIsNotNone(self.hass.services.has_service('notify', 'demo'))
service = 'demo_test_target_name'
self.assertIsNotNone(self.hass.services.has_service('notify', service))
|
'Test message routing to specific target services.'
| def test_messages_to_targets_route(self):
| self._setup_notify()
self.hass.bus.listen_once('notify', self.record_calls)
self.hass.services.call('notify', 'demo_test_target_name', {'message': 'my message', 'title': 'my title', 'data': {'hello': 'world'}})
self.hass.block_till_done()
data = self.calls[0][0].data
assert ({'message': 'my message', 'target': ['test target id'], 'title': 'my title', 'data': {'hello': 'world'}} == data)
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
|
'Stop down everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test setup.'
| def test_setup(self):
| with assert_setup_component(1) as handle_config:
assert setup_component(self.hass, 'notify', {'notify': {'name': 'test', 'platform': 'command_line', 'command': 'echo $(cat); exit 1'}})
assert handle_config[notify.DOMAIN]
|
'Test set up the platform with bad/missing configuration.'
| def test_bad_config(self):
| config = {notify.DOMAIN: {'name': 'test', 'platform': 'command_line'}}
with assert_setup_component(0) as handle_config:
assert setup_component(self.hass, notify.DOMAIN, config)
assert (not handle_config[notify.DOMAIN])
|
'Test the command line output.'
| def test_command_line_output(self):
| with tempfile.TemporaryDirectory() as tempdirname:
filename = os.path.join(tempdirname, 'message.txt')
message = 'one, two, testing, testing'
with assert_setup_component(1) as handle_config:
self.assertTrue(setup_component(self.hass, notify.DOMAIN, {'notify': {'name': 'test', 'platform': 'command_line', 'command': 'echo $(cat) > {}'.format(filename)}}))
assert handle_config[notify.DOMAIN]
self.assertTrue(self.hass.services.call('notify', 'test', {'message': message}, blocking=True))
with open(filename) as fil:
self.assertEqual(fil.read(), '{}\n'.format(message))
|
'Test if an error is logged for non zero exit codes.'
| @patch('homeassistant.components.notify.command_line._LOGGER.error')
def test_error_for_none_zero_exit_code(self, mock_error):
| with assert_setup_component(1) as handle_config:
self.assertTrue(setup_component(self.hass, notify.DOMAIN, {'notify': {'name': 'test', 'platform': 'command_line', 'command': 'echo $(cat); exit 1'}}))
assert handle_config[notify.DOMAIN]
self.assertTrue(self.hass.services.call('notify', 'test', {'message': 'error'}, blocking=True))
self.assertEqual(1, mock_error.call_count)
|
'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()
|
'Test setup component with no devices.'
| def test_setup_component_with_no_devices(self):
| self.hass.data[dyson.DYSON_DEVICES] = []
add_devices = mock.MagicMock()
dyson.setup_platform(self.hass, {}, add_devices)
add_devices.assert_called_with([])
|
'Test setup component with devices.'
| def test_setup_component(self):
| def _add_device(devices):
assert (len(devices) == 1)
assert (devices[0].name == 'Device_Vacuum')
device_vacuum = _get_vacuum_device_cleaning()
device_non_vacuum = _get_non_vacuum_device()
self.hass.data[dyson.DYSON_DEVICES] = [device_vacuum, device_non_vacuum]
dyson.setup_platform(self.hass, {}, _add_device)
|
'Test when message is received.'
| def test_on_message(self):
| device = _get_vacuum_device_cleaning()
component = Dyson360EyeDevice(device)
component.entity_id = 'entity_id'
component.schedule_update_ha_state = mock.Mock()
component.on_message(mock.Mock())
self.assertTrue(component.schedule_update_ha_state.called)
|
'Test polling is disable.'
| def test_should_poll(self):
| device = _get_vacuum_device_cleaning()
component = Dyson360EyeDevice(device)
self.assertFalse(component.should_poll)
|
'Test component properties.'
| def test_properties(self):
| device1 = _get_vacuum_device_cleaning()
device2 = _get_vacuum_device_unknown_state()
device3 = _get_vacuum_device_charging()
component = Dyson360EyeDevice(device1)
component2 = Dyson360EyeDevice(device2)
component3 = Dyson360EyeDevice(device3)
self.assertEqual(component.name, 'Device_Vacuum')
self.assertTrue(component.is_on)
self.assertEqual(component.icon, 'mdi:roomba')
self.assertEqual(component.status, 'Cleaning')
self.assertEqual(component2.status, 'Unknown')
self.assertEqual(component.battery_level, 85)
self.assertEqual(component.fan_speed, 'Quiet')
self.assertEqual(component.fan_speed_list, ['Quiet', 'Max'])
self.assertEqual(component.device_state_attributes['position'], '(0, 0)')
self.assertTrue(component.available)
self.assertEqual(component.supported_features, 255)
self.assertEqual(component.battery_icon, 'mdi:battery-80')
self.assertEqual(component3.battery_icon, 'mdi:battery-charging-40')
|
'Test turn on vacuum.'
| def test_turn_on(self):
| device1 = _get_vacuum_device_charging()
component1 = Dyson360EyeDevice(device1)
component1.turn_on()
self.assertTrue(device1.start.called)
device2 = _get_vacuum_device_pause()
component2 = Dyson360EyeDevice(device2)
component2.turn_on()
self.assertTrue(device2.resume.called)
|
'Test turn off vacuum.'
| def test_turn_off(self):
| device1 = _get_vacuum_device_cleaning()
component1 = Dyson360EyeDevice(device1)
component1.turn_off()
self.assertTrue(device1.pause.called)
|
'Test stop vacuum.'
| def test_stop(self):
| device1 = _get_vacuum_device_cleaning()
component1 = Dyson360EyeDevice(device1)
component1.stop()
self.assertTrue(device1.pause.called)
|
'Test set fan speed vacuum.'
| def test_set_fan_speed(self):
| device1 = _get_vacuum_device_cleaning()
component1 = Dyson360EyeDevice(device1)
component1.set_fan_speed('Max')
device1.set_power_mode.assert_called_with(PowerMode.MAX)
|
'Test start/pause.'
| def test_start_pause(self):
| device1 = _get_vacuum_device_charging()
component1 = Dyson360EyeDevice(device1)
component1.start_pause()
self.assertTrue(device1.start.called)
device2 = _get_vacuum_device_pause()
component2 = Dyson360EyeDevice(device2)
component2.start_pause()
self.assertTrue(device2.resume.called)
device3 = _get_vacuum_device_cleaning()
component3 = Dyson360EyeDevice(device3)
component3.start_pause()
self.assertTrue(device3.pause.called)
|
'Test return to base.'
| def test_return_to_base(self):
| device = _get_vacuum_device_pause()
component = Dyson360EyeDevice(device)
component.return_to_base()
self.assertTrue(device.abort.called)
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.assertTrue(setup_component(self.hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: 'demo'}}))
|
'Stop down everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test vacuum supported features.'
| def test_supported_features(self):
| state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertEqual(2047, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual('Charging', state.attributes.get(ATTR_STATUS))
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual('medium', state.attributes.get(ATTR_FAN_SPEED))
self.assertListEqual(FAN_SPEEDS, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
state = self.hass.states.get(ENTITY_VACUUM_MOST)
self.assertEqual(219, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual('Charging', state.attributes.get(ATTR_STATUS))
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
self.assertEqual(195, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual('Charging', state.attributes.get(ATTR_STATUS))
self.assertEqual(100, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
state = self.hass.states.get(ENTITY_VACUUM_MINIMAL)
self.assertEqual(3, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual(None, state.attributes.get(ATTR_STATUS))
self.assertEqual(None, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
state = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertEqual(0, state.attributes.get(ATTR_SUPPORTED_FEATURES))
self.assertEqual(None, state.attributes.get(ATTR_STATUS))
self.assertEqual(None, state.attributes.get(ATTR_BATTERY_LEVEL))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED))
self.assertEqual(None, state.attributes.get(ATTR_FAN_SPEED_LIST))
self.assertEqual(STATE_OFF, state.state)
|
'Test if methods call the services as expected.'
| def test_methods(self):
| self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_ON)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC))
self.hass.states.set(ENTITY_VACUUM_BASIC, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_BASIC))
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_ON)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass))
self.hass.states.set(ENTITY_ID_ALL_VACUUMS, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass))
vacuum.turn_on(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.turn_off(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.toggle(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.start_pause(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
vacuum.stop(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_COMPLETE))
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertLess(state.attributes.get(ATTR_BATTERY_LEVEL), 100)
self.assertNotEqual('Charging', state.attributes.get(ATTR_STATUS))
vacuum.locate(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertIn("I'm over here", state.attributes.get(ATTR_STATUS))
vacuum.return_to_base(self.hass, ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertIn('Returning home', state.attributes.get(ATTR_STATUS))
vacuum.set_fan_speed(self.hass, FAN_SPEEDS[(-1)], entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertEqual(FAN_SPEEDS[(-1)], state.attributes.get(ATTR_FAN_SPEED))
vacuum.clean_spot(self.hass, entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertIn('spot', state.attributes.get(ATTR_STATUS))
self.assertEqual(STATE_ON, state.state)
|
'Test service calls for unsupported vacuums.'
| def test_unsupported_methods(self):
| self.hass.states.set(ENTITY_VACUUM_NONE, STATE_ON)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.turn_off(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.stop(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertTrue(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
self.hass.states.set(ENTITY_VACUUM_NONE, STATE_OFF)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.turn_on(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.toggle(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.start_pause(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
self.assertFalse(vacuum.is_on(self.hass, ENTITY_VACUUM_NONE))
vacuum.locate(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertIsNone(state.attributes.get(ATTR_STATUS))
vacuum.return_to_base(self.hass, ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertIsNone(state.attributes.get(ATTR_STATUS))
vacuum.set_fan_speed(self.hass, FAN_SPEEDS[(-1)], entity_id=ENTITY_VACUUM_NONE)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_NONE)
self.assertNotEqual(FAN_SPEEDS[(-1)], state.attributes.get(ATTR_FAN_SPEED))
vacuum.clean_spot(self.hass, entity_id=ENTITY_VACUUM_BASIC)
self.hass.block_till_done()
state = self.hass.states.get(ENTITY_VACUUM_BASIC)
self.assertNotIn('spot', state.attributes.get(ATTR_STATUS))
self.assertEqual(STATE_OFF, state.state)
|
'Test vacuum services.'
| def test_services(self):
| send_command_calls = mock_service(self.hass, DOMAIN, SERVICE_SEND_COMMAND)
params = {'rotate': 150, 'speed': 20}
vacuum.send_command(self.hass, 'test_command', entity_id=ENTITY_VACUUM_BASIC, params=params)
self.hass.block_till_done()
self.assertEqual(1, len(send_command_calls))
call = send_command_calls[(-1)]
self.assertEqual(DOMAIN, call.domain)
self.assertEqual(SERVICE_SEND_COMMAND, call.service)
self.assertEqual(ENTITY_VACUUM_BASIC, call.data[ATTR_ENTITY_ID])
self.assertEqual('test_command', call.data[ATTR_COMMAND])
self.assertEqual(params, call.data[ATTR_PARAMS])
set_fan_speed_calls = mock_service(self.hass, DOMAIN, SERVICE_SET_FAN_SPEED)
vacuum.set_fan_speed(self.hass, FAN_SPEEDS[0], entity_id=ENTITY_VACUUM_COMPLETE)
self.hass.block_till_done()
self.assertEqual(1, len(set_fan_speed_calls))
call = set_fan_speed_calls[(-1)]
self.assertEqual(DOMAIN, call.domain)
self.assertEqual(SERVICE_SET_FAN_SPEED, call.service)
self.assertEqual(ENTITY_VACUUM_COMPLETE, call.data[ATTR_ENTITY_ID])
self.assertEqual(FAN_SPEEDS[0], call.data[ATTR_FAN_SPEED])
|
'Test vacuum service to set the fan speed.'
| def test_set_fan_speed(self):
| group_vacuums = ','.join([ENTITY_VACUUM_BASIC, ENTITY_VACUUM_COMPLETE])
old_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
old_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
vacuum.set_fan_speed(self.hass, FAN_SPEEDS[0], entity_id=group_vacuums)
self.hass.block_till_done()
new_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
new_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertEqual(old_state_basic, new_state_basic)
self.assertNotIn(ATTR_FAN_SPEED, new_state_basic.attributes)
self.assertNotEqual(old_state_complete, new_state_complete)
self.assertEqual(FAN_SPEEDS[1], old_state_complete.attributes[ATTR_FAN_SPEED])
self.assertEqual(FAN_SPEEDS[0], new_state_complete.attributes[ATTR_FAN_SPEED])
|
'Test vacuum service to send a command.'
| def test_send_command(self):
| group_vacuums = ','.join([ENTITY_VACUUM_BASIC, ENTITY_VACUUM_COMPLETE])
old_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
old_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
vacuum.send_command(self.hass, 'test_command', params={'p1': 3}, entity_id=group_vacuums)
self.hass.block_till_done()
new_state_basic = self.hass.states.get(ENTITY_VACUUM_BASIC)
new_state_complete = self.hass.states.get(ENTITY_VACUUM_COMPLETE)
self.assertEqual(old_state_basic, new_state_basic)
self.assertNotEqual(old_state_complete, new_state_complete)
self.assertEqual(STATE_ON, new_state_complete.state)
self.assertEqual("Executing test_command({'p1': 3})", new_state_complete.attributes[ATTR_STATUS])
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
dt_util.set_default_time_zone(dt_util.get_time_zone('America/Regina'))
|
'Stop everything that was started.'
| def tearDown(self):
| dt_util.set_default_time_zone(dt_util.get_time_zone('UTC'))
self.hass.stop()
|
'Test that we can create an event trigger on device.'
| @patch('homeassistant.components.calendar.google.GoogleCalendarData')
def test_all_day_event(self, mock_next_event):
| week_from_today = (dt_util.dt.date.today() + dt_util.dt.timedelta(days=7))
event = {'summary': 'Test All Day Event', 'start': {'date': week_from_today.isoformat()}, 'end': {'date': (week_from_today + dt_util.dt.timedelta(days=1)).isoformat()}, 'location': 'Test Cases', 'description': "We're just testing that all day events get setup correctly", 'kind': 'calendar#event', 'created': '2016-06-23T16:37:57.000Z', 'transparency': 'transparent', 'updated': '2016-06-24T01:57:21.045Z', 'reminders': {'useDefault': True}, 'organizer': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'sequence': 0, 'creator': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'id': '_c8rinwq863h45qnucyoi43ny8', 'etag': '"2933466882090000"', 'htmlLink': 'https://www.google.com/calendar/event?eid=*******', 'iCalUID': '[email protected]', 'status': 'confirmed'}
mock_next_event.return_value.event = event
device_name = 'Test All Day'
cal = calendar.GoogleCalendarEventDevice(self.hass, None, '', {'name': device_name})
self.assertEqual(cal.name, device_name)
self.assertEqual(cal.state, STATE_OFF)
self.assertFalse(cal.offset_reached())
self.assertEqual(cal.device_state_attributes, {'message': event['summary'], 'all_day': True, 'offset_reached': False, 'start_time': '{} 00:00:00'.format(event['start']['date']), 'end_time': '{} 00:00:00'.format(event['end']['date']), 'location': event['location'], 'description': event['description']})
|
'Test that we can create an event trigger on device.'
| @patch('homeassistant.components.calendar.google.GoogleCalendarData')
def test_future_event(self, mock_next_event):
| one_hour_from_now = (dt_util.now() + dt_util.dt.timedelta(minutes=30))
event = {'start': {'dateTime': one_hour_from_now.isoformat()}, 'end': {'dateTime': (one_hour_from_now + dt_util.dt.timedelta(minutes=60)).isoformat()}, 'summary': 'Test Event in 30 minutes', 'reminders': {'useDefault': True}, 'id': 'aioehgni435lihje', 'status': 'confirmed', 'updated': '2016-11-05T15:52:07.329Z', 'organizer': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'created': '2016-11-05T15:52:07.000Z', 'iCalUID': '[email protected]', 'sequence': 0, 'creator': {'email': '[email protected]', 'displayName': 'Organizer Name'}, 'etag': '"2956722254658000"', 'kind': 'calendar#event', 'htmlLink': 'https://www.google.com/calendar/event?eid=*******'}
mock_next_event.return_value.event = event
device_name = 'Test Future Event'
device_id = 'test_future_event'
cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id, {'name': device_name})
self.assertEqual(cal.name, device_name)
self.assertEqual(cal.state, STATE_OFF)
self.assertFalse(cal.offset_reached())
self.assertEqual(cal.device_state_attributes, {'message': event['summary'], 'all_day': False, 'offset_reached': False, 'start_time': one_hour_from_now.strftime(DATE_STR_FORMAT), 'end_time': (one_hour_from_now + dt_util.dt.timedelta(minutes=60)).strftime(DATE_STR_FORMAT), 'location': '', 'description': ''})
|
'Test that we can create an event trigger on device.'
| @patch('homeassistant.components.calendar.google.GoogleCalendarData')
def test_in_progress_event(self, mock_next_event):
| middle_of_event = (dt_util.now() - dt_util.dt.timedelta(minutes=30))
event = {'start': {'dateTime': middle_of_event.isoformat()}, 'end': {'dateTime': (middle_of_event + dt_util.dt.timedelta(minutes=60)).isoformat()}, 'summary': 'Test Event in Progress', 'reminders': {'useDefault': True}, 'id': 'aioehgni435lihje', 'status': 'confirmed', 'updated': '2016-11-05T15:52:07.329Z', 'organizer': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'created': '2016-11-05T15:52:07.000Z', 'iCalUID': '[email protected]', 'sequence': 0, 'creator': {'email': '[email protected]', 'displayName': 'Organizer Name'}, 'etag': '"2956722254658000"', 'kind': 'calendar#event', 'htmlLink': 'https://www.google.com/calendar/event?eid=*******'}
mock_next_event.return_value.event = event
device_name = 'Test Event in Progress'
device_id = 'test_event_in_progress'
cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id, {'name': device_name})
self.assertEqual(cal.name, device_name)
self.assertEqual(cal.state, STATE_ON)
self.assertFalse(cal.offset_reached())
self.assertEqual(cal.device_state_attributes, {'message': event['summary'], 'all_day': False, 'offset_reached': False, 'start_time': middle_of_event.strftime(DATE_STR_FORMAT), 'end_time': (middle_of_event + dt_util.dt.timedelta(minutes=60)).strftime(DATE_STR_FORMAT), 'location': '', 'description': ''})
|
'Test that we can create an event trigger on device.'
| @patch('homeassistant.components.calendar.google.GoogleCalendarData')
def test_offset_in_progress_event(self, mock_next_event):
| middle_of_event = (dt_util.now() + dt_util.dt.timedelta(minutes=14))
event_summary = 'Test Event in Progress'
event = {'start': {'dateTime': middle_of_event.isoformat()}, 'end': {'dateTime': (middle_of_event + dt_util.dt.timedelta(minutes=60)).isoformat()}, 'summary': '{} !!-15'.format(event_summary), 'reminders': {'useDefault': True}, 'id': 'aioehgni435lihje', 'status': 'confirmed', 'updated': '2016-11-05T15:52:07.329Z', 'organizer': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'created': '2016-11-05T15:52:07.000Z', 'iCalUID': '[email protected]', 'sequence': 0, 'creator': {'email': '[email protected]', 'displayName': 'Organizer Name'}, 'etag': '"2956722254658000"', 'kind': 'calendar#event', 'htmlLink': 'https://www.google.com/calendar/event?eid=*******'}
mock_next_event.return_value.event = event
device_name = 'Test Event in Progress'
device_id = 'test_event_in_progress'
cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id, {'name': device_name})
self.assertEqual(cal.name, device_name)
self.assertEqual(cal.state, STATE_OFF)
self.assertTrue(cal.offset_reached())
self.assertEqual(cal.device_state_attributes, {'message': event_summary, 'all_day': False, 'offset_reached': True, 'start_time': middle_of_event.strftime(DATE_STR_FORMAT), 'end_time': (middle_of_event + dt_util.dt.timedelta(minutes=60)).strftime(DATE_STR_FORMAT), 'location': '', 'description': ''})
|
'Test that we can create an event trigger on device.'
| @pytest.mark.skip
@patch('homeassistant.components.calendar.google.GoogleCalendarData')
def test_all_day_offset_in_progress_event(self, mock_next_event):
| tomorrow = (dt_util.dt.date.today() + dt_util.dt.timedelta(days=1))
event_summary = 'Test All Day Event Offset In Progress'
event = {'summary': '{} !!-25:0'.format(event_summary), 'start': {'date': tomorrow.isoformat()}, 'end': {'date': (tomorrow + dt_util.dt.timedelta(days=1)).isoformat()}, 'location': 'Test Cases', 'description': "We're just testing that all day events get setup correctly", 'kind': 'calendar#event', 'created': '2016-06-23T16:37:57.000Z', 'transparency': 'transparent', 'updated': '2016-06-24T01:57:21.045Z', 'reminders': {'useDefault': True}, 'organizer': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'sequence': 0, 'creator': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'id': '_c8rinwq863h45qnucyoi43ny8', 'etag': '"2933466882090000"', 'htmlLink': 'https://www.google.com/calendar/event?eid=*******', 'iCalUID': '[email protected]', 'status': 'confirmed'}
mock_next_event.return_value.event = event
device_name = 'Test All Day Offset In Progress'
device_id = 'test_all_day_offset_in_progress'
cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id, {'name': device_name})
self.assertEqual(cal.name, device_name)
self.assertEqual(cal.state, STATE_OFF)
self.assertTrue(cal.offset_reached())
self.assertEqual(cal.device_state_attributes, {'message': event_summary, 'all_day': True, 'offset_reached': True, 'start_time': '{} 06:00:00'.format(event['start']['date']), 'end_time': '{} 06:00:00'.format(event['end']['date']), 'location': event['location'], 'description': event['description']})
|
'Test that we can create an event trigger on device.'
| @patch('homeassistant.components.calendar.google.GoogleCalendarData')
def test_all_day_offset_event(self, mock_next_event):
| tomorrow = (dt_util.dt.date.today() + dt_util.dt.timedelta(days=2))
offset_hours = (1 + dt_util.now().hour)
event_summary = 'Test All Day Event Offset'
event = {'summary': '{} !!-{}:0'.format(event_summary, offset_hours), 'start': {'date': tomorrow.isoformat()}, 'end': {'date': (tomorrow + dt_util.dt.timedelta(days=1)).isoformat()}, 'location': 'Test Cases', 'description': "We're just testing that all day events get setup correctly", 'kind': 'calendar#event', 'created': '2016-06-23T16:37:57.000Z', 'transparency': 'transparent', 'updated': '2016-06-24T01:57:21.045Z', 'reminders': {'useDefault': True}, 'organizer': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'sequence': 0, 'creator': {'email': '[email protected]', 'displayName': 'Organizer Name', 'self': True}, 'id': '_c8rinwq863h45qnucyoi43ny8', 'etag': '"2933466882090000"', 'htmlLink': 'https://www.google.com/calendar/event?eid=*******', 'iCalUID': '[email protected]', 'status': 'confirmed'}
mock_next_event.return_value.event = event
device_name = 'Test All Day Offset'
device_id = 'test_all_day_offset'
cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id, {'name': device_name})
self.assertEqual(cal.name, device_name)
self.assertEqual(cal.state, STATE_OFF)
self.assertFalse(cal.offset_reached())
self.assertEqual(cal.device_state_attributes, {'message': event_summary, 'all_day': True, 'offset_reached': False, 'start_time': '{} 00:00:00'.format(event['start']['date']), 'end_time': '{} 00:00:00'.format(event['end']['date']), 'location': event['location'], 'description': event['description']})
|
'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 the controlling state via topic.'
| def test_controlling_state_via_topic(self):
| assert setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'state-topic', 'command_topic': 'command-topic', 'payload_on': 1, 'payload_off': 0}})
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'state-topic', '1')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
fire_mqtt_message(self.hass, 'state-topic', '0')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
|
'Test the sending MQTT commands in optimistic mode.'
| def test_sending_mqtt_commands_and_optimistic(self):
| assert setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': '2'}})
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))
switch.turn_on(self.hass, 'switch.test')
self.hass.block_till_done()
self.assertEqual(('command-topic', 'beer on', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
switch.turn_off(self.hass, 'switch.test')
self.hass.block_till_done()
self.assertEqual(('command-topic', 'beer off', 2, False), self.mock_publish.mock_calls[(-2)][1])
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
|
'Test the controlling state via topic and JSON message.'
| def test_controlling_state_via_topic_and_json_message(self):
| assert setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'state-topic', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'value_template': '{{ value_json.val }}'}})
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
fire_mqtt_message(self.hass, 'state-topic', '{"val":"beer on"}')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
fire_mqtt_message(self.hass, 'state-topic', '{"val":"beer off"}')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
|
'Test the controlling state via topic.'
| def test_controlling_availability(self):
| assert setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'state-topic', 'command_topic': 'command-topic', 'availability_topic': 'availability_topic', 'payload_on': 1, 'payload_off': 0}})
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_UNAVAILABLE, state.state)
fire_mqtt_message(self.hass, 'availability_topic', '1')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_OFF, state.state)
self.assertFalse(state.attributes.get(ATTR_ASSUMED_STATE))
fire_mqtt_message(self.hass, 'availability_topic', '0')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_UNAVAILABLE, state.state)
fire_mqtt_message(self.hass, 'state-topic', '1')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_UNAVAILABLE, state.state)
fire_mqtt_message(self.hass, 'availability_topic', '1')
self.hass.block_till_done()
state = self.hass.states.get('switch.test')
self.assertEqual(STATE_ON, state.state)
|
'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.switch_pressed_callbacks = {}
self.switch_released_callbacks = {}
def get_switch_name(number):
return ('Mock Switch #' + str(number))
def on_switch_pressed(number, callback):
self.switch_pressed_callbacks[number] = callback
def on_switch_released(number, callback):
self.switch_released_callbacks[number] = callback
self.mock_lj = mock_pylitejet.return_value
self.mock_lj.loads.return_value = range(0)
self.mock_lj.button_switches.return_value = range(1, 3)
self.mock_lj.all_switches.return_value = range(1, 6)
self.mock_lj.scenes.return_value = range(0)
self.mock_lj.get_switch_name.side_effect = get_switch_name
self.mock_lj.on_switch_pressed.side_effect = on_switch_pressed
self.mock_lj.on_switch_released.side_effect = on_switch_released
config = {'litejet': {'port': '/tmp/this_will_be_mocked'}}
if (method == self.test_include_switches_False):
config['litejet']['include_switches'] = False
elif (method != self.test_include_switches_unspecified):
config['litejet']['include_switches'] = True
assert setup.setup_component(self.hass, litejet.DOMAIN, config)
self.hass.block_till_done()
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Return the switch state.'
| def switch(self):
| return self.hass.states.get(ENTITY_SWITCH)
|
'Return the other switch state.'
| def other_switch(self):
| return self.hass.states.get(ENTITY_OTHER_SWITCH)
|
'Test that switches are ignored by default.'
| def test_include_switches_unspecified(self):
| self.mock_lj.button_switches.assert_not_called()
self.mock_lj.all_switches.assert_not_called()
|
'Test that switches can be explicitly ignored.'
| def test_include_switches_False(self):
| self.mock_lj.button_switches.assert_not_called()
self.mock_lj.all_switches.assert_not_called()
|
'Test turning the switch on and off.'
| def test_on_off(self):
| assert (self.switch().state == 'off')
assert (self.other_switch().state == 'off')
assert (not switch.is_on(self.hass, ENTITY_SWITCH))
switch.turn_on(self.hass, ENTITY_SWITCH)
self.hass.block_till_done()
self.mock_lj.press_switch.assert_called_with(ENTITY_SWITCH_NUMBER)
switch.turn_off(self.hass, ENTITY_SWITCH)
self.hass.block_till_done()
self.mock_lj.release_switch.assert_called_with(ENTITY_SWITCH_NUMBER)
|
'Test handling an event from LiteJet.'
| def test_pressed_event(self):
| _LOGGER.info(self.switch_pressed_callbacks[ENTITY_SWITCH_NUMBER])
self.switch_pressed_callbacks[ENTITY_SWITCH_NUMBER]()
self.hass.block_till_done()
assert switch.is_on(self.hass, ENTITY_SWITCH)
assert (not switch.is_on(self.hass, ENTITY_OTHER_SWITCH))
assert (self.switch().state == 'on')
assert (self.other_switch().state == 'off')
self.switch_pressed_callbacks[ENTITY_OTHER_SWITCH_NUMBER]()
self.hass.block_till_done()
assert switch.is_on(self.hass, ENTITY_OTHER_SWITCH)
assert switch.is_on(self.hass, ENTITY_SWITCH)
assert (self.other_switch().state == 'on')
assert (self.switch().state == 'on')
|
'Test handling an event from LiteJet.'
| def test_released_event(self):
| self.switch_pressed_callbacks[ENTITY_OTHER_SWITCH_NUMBER]()
self.hass.block_till_done()
assert switch.is_on(self.hass, ENTITY_OTHER_SWITCH)
self.switch_released_callbacks[ENTITY_OTHER_SWITCH_NUMBER]()
self.hass.block_till_done()
assert (not switch.is_on(self.hass, ENTITY_OTHER_SWITCH))
assert (not switch.is_on(self.hass, ENTITY_SWITCH))
assert (self.other_switch().state == 'off')
assert (self.switch().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, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {'0b1100cd0213c7f210010f51': {'name': 'Test', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
|
'Test configuration.'
| def test_valid_config_int_device_id(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {710000141010170: {'name': 'Test', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
|
'Test invalid configuration.'
| def test_invalid_config1(self):
| self.assertFalse(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {'2FF7f216': {'name': 'Test', 'packetid': '0b1100cd0213c7f210010f51', 'signal_repetitions': 3}}}}))
|
'Test invalid configuration.'
| def test_invalid_config2(self):
| self.assertFalse(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, 'invalid_key': 'afda', 'devices': {'213c7f216': {'name': 'Test', 'packetid': '0b1100cd0213c7f210010f51', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
|
'Test invalid configuration.'
| def test_invalid_config3(self):
| self.assertFalse(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {'213c7f216': {'name': 'Test', 'packetid': 'AA1100cd0213c7f210010f51', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
|
'Test configuration.'
| def test_invalid_config4(self):
| self.assertFalse(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {'213c7f216': {'name': 'Test', rfxtrx_core.ATTR_FIREEVENT: True}}}}))
|
'Test with 0 switches.'
| def test_default_config(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'devices': {}}}))
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
|
'Test with 1 switch.'
| def test_old_config(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'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)
entity.turn_off()
self.assertFalse(entity.is_on)
|
'Test with 1 switch.'
| def test_one_switch(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'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)
entity.turn_off()
self.assertFalse(entity.is_on)
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)
|
'Test with 3 switches.'
| def test_several_switches(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'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 switches.'
| def test_discover_switch(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': True, '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)
entity = rfxtrx_core.RFX_DEVICES['118cdea2']
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual('<Entity 0b1100100118cdea01010f70: on>', entity.__str__())
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100100118cdeb02010f70')
event.data = bytearray([11, 17, 0, 18, 1, 24, 205, 234, 2, 0, 0, 112])
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
entity = rfxtrx_core.RFX_DEVICES['118cdeb2']
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual('<Entity 0b1100120118cdea02000070: 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, 17, 16, 1, 24, 205, 234, 1, 2, 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 discovery of switch when auto add is False.'
| def test_discover_switch_noautoadd(self):
| self.assertTrue(setup_component(self.hass, 'switch', {'switch': {'platform': 'rfxtrx', 'automatic_add': False, '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))
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0b1100100118cdeb02010f70')
event.data = bytearray([11, 17, 0, 18, 1, 24, 205, 234, 2, 0, 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, 17, 16, 1, 24, 205, 234, 1, 2, 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()
platform = loader.get_component('switch.test')
platform.init()
(self.switch_1, self.switch_2, self.switch_3) = platform.DEVICES
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test is_on, turn_on, turn_off methods.'
| def test_methods(self):
| self.assertTrue(setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: {CONF_PLATFORM: 'test'}}))
self.assertTrue(switch.is_on(self.hass))
self.assertEqual(STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state)
self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id))
self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id))
self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id))
switch.turn_off(self.hass, self.switch_1.entity_id)
switch.turn_on(self.hass, self.switch_2.entity_id)
self.hass.block_till_done()
self.assertTrue(switch.is_on(self.hass))
self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id))
self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id))
switch.turn_off(self.hass)
self.hass.block_till_done()
self.assertFalse(switch.is_on(self.hass))
self.assertEqual(STATE_OFF, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state)
self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id))
self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id))
self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id))
switch.turn_on(self.hass)
self.hass.block_till_done()
self.assertTrue(switch.is_on(self.hass))
self.assertEqual(STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state)
self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id))
self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id))
self.assertTrue(switch.is_on(self.hass, self.switch_3.entity_id))
|
'Test with bad configuration.'
| def test_setup_two_platforms(self):
| test_platform = loader.get_component('switch.test')
test_platform.init(True)
loader.set_component('switch.test2', test_platform)
test_platform.init(False)
self.assertTrue(setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: {CONF_PLATFORM: 'test'}, '{} 2'.format(switch.DOMAIN): {CONF_PLATFORM: 'test2'}}))
|
'Test if setup adds devices.'
| @mock.patch('mficlient.client.MFiClient')
@mock.patch('homeassistant.components.switch.mfi.MfiSwitch')
def test_setup_adds_proper_devices(self, mock_switch, mock_client):
| ports = {i: mock.MagicMock(model=model) for (i, model) in enumerate(mfi.SWITCH_MODELS)}
ports['bad'] = mock.MagicMock(model='notaswitch')
print ports['bad'].model
mock_client.return_value.get_devices.return_value = [mock.MagicMock(ports=ports)]
assert setup_component(self.hass, switch.DOMAIN, self.GOOD_CONFIG)
for (ident, port) in ports.items():
if (ident != 'bad'):
mock_switch.assert_any_call(port)
assert (mock.call(ports['bad'], self.hass) not in mock_switch.mock_calls)
|
'Setup things to be run when tests are started.'
| def setup_method(self, method):
| self.hass = get_test_home_assistant()
self.port = mock.MagicMock()
self.switch = mfi.MfiSwitch(self.port)
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Test the name.'
| def test_name(self):
| self.assertEqual(self.port.label, self.switch.name)
|
'Test update.'
| def test_update(self):
| self.switch.update()
self.assertEqual(self.port.refresh.call_count, 1)
self.assertEqual(self.port.refresh.call_args, mock.call())
|
'Test update with target state.'
| def test_update_with_target_state(self):
| self.switch._target_state = True
self.port.data = {}
self.port.data['output'] = 'stale'
self.switch.update()
self.assertEqual(1.0, self.port.data['output'])
self.assertEqual(None, self.switch._target_state)
self.port.data['output'] = 'untouched'
self.switch.update()
self.assertEqual('untouched', self.port.data['output'])
|
'Test turn_on.'
| def test_turn_on(self):
| self.switch.turn_on()
self.assertEqual(self.port.control.call_count, 1)
self.assertEqual(self.port.control.call_args, mock.call(True))
self.assertTrue(self.switch._target_state)
|
'Test turn_off.'
| def test_turn_off(self):
| self.switch.turn_off()
self.assertEqual(self.port.control.call_count, 1)
self.assertEqual(self.port.control.call_args, mock.call(False))
self.assertFalse(self.switch._target_state)
|
'Test current power.'
| def test_current_power_w(self):
| self.port.data = {'active_pwr': 10}
self.assertEqual(10, self.switch.current_power_w)
|
'Test current power if there is no data.'
| def test_current_power_w_no_data(self):
| self.port.data = {'notpower': 123}
self.assertEqual(0, self.switch.current_power_w)
|
'Test the state attributes.'
| def test_device_state_attributes(self):
| self.port.data = {'v_rms': 1.25, 'i_rms': 2.75}
self.assertEqual({'volts': 1.2, 'amps': 2.8}, self.switch.device_state_attributes)
|
'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()
|
'Test configuration.'
| def test_valid_config(self):
| assert setup_component(self.hass, 'switch', {'switch': {'platform': 'flux', 'name': 'flux', 'lights': ['light.desk', 'light.lamp']}})
|
'Test configuration.'
| def test_valid_config_with_info(self):
| assert setup_component(self.hass, 'switch', {'switch': {'platform': 'flux', 'name': 'flux', 'lights': ['light.desk', 'light.lamp'], 'stop_time': '22:59', 'start_time': '7:22', 'start_colortemp': '1000', 'sunset_colortemp': '2000', 'stop_colortemp': '4000'}})
|
'Test configuration.'
| def test_valid_config_no_name(self):
| with assert_setup_component(1, 'switch'):
assert setup_component(self.hass, 'switch', {'switch': {'platform': 'flux', 'lights': ['light.desk', 'light.lamp']}})
|
'Test configuration.'
| def test_invalid_config_no_lights(self):
| with assert_setup_component(0, 'switch'):
assert setup_component(self.hass, 'switch', {'switch': {'platform': 'flux', 'name': 'flux'}})
|
'Test the flux switch when it is off.'
| def test_flux_when_switch_is_off(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=10, minute=30, 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'):
return sunrise_time
else:
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]}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
fire_time_changed(self.hass, test_time)
self.hass.block_till_done()
self.assertEqual(0, len(turn_on_calls))
|
'Test the flux switch before sunrise.'
| def test_flux_before_sunrise(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=2, minute=30, 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'):
return sunrise_time
else:
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]}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 119)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.591, 0.395])
|
'Test the flux switch after sunrise and before sunset.'
| def test_flux_after_sunrise_before_sunset(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=8, minute=30, 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'):
return sunrise_time
else:
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]}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 180)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.431, 0.38])
|
'Test the flux switch after sunset and before stop.'
| def test_flux_after_sunset_before_stop(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=17, minute=30, 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'):
return sunrise_time
else:
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]}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 153)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.496, 0.397])
|
'Test the flux switch after stop and before sunrise.'
| def test_flux_after_stop_before_sunrise(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=23, minute=30, 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'):
return sunrise_time
else:
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]}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 119)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.591, 0.395])
|
'Test the flux with custom start and stop times.'
| def test_flux_with_custom_start_stop_times(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=17, minute=30, 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'):
return sunrise_time
else:
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], 'start_time': '6:00', 'stop_time': '23:30'}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 154)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.494, 0.397])
|
'Test the flux with custom start and stop colortemps.'
| def test_flux_with_custom_colortemps(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=17, minute=30, 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'):
return sunrise_time
else:
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], 'start_colortemp': '1000', 'stop_colortemp': '6000'}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 167)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.461, 0.389])
|
'Test the flux with custom start and stop colortemps.'
| def test_flux_with_custom_brightness(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
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'))
test_time = dt_util.now().replace(hour=17, minute=30, 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'):
return sunrise_time
else:
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], 'brightness': 255}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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], 255)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.496, 0.397])
|
'Test the flux switch with multiple light entities.'
| def test_flux_with_multiple_lights(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
light.turn_on(self.hass, entity_id=dev2.entity_id)
self.hass.block_till_done()
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
else:
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)
switch.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], 171)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386])
call = turn_on_calls[(-2)]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386])
call = turn_on_calls[(-3)]
self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171)
self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386])
|
'Test the flux switchÂŽs mode mired.'
| def test_flux_with_mired(self):
| platform = loader.get_component('light.test')
platform.init()
self.assertTrue(setup_component(self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: 'test'}}))
dev1 = platform.DEVICES[0]
state = self.hass.states.get(dev1.entity_id)
self.assertEqual(STATE_ON, state.state)
self.assertIsNone(state.attributes.get('color_temp'))
test_time = dt_util.now().replace(hour=8, minute=30, 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'):
return sunrise_time
else:
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], 'mode': 'mired'}})
turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)
switch.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_COLOR_TEMP], 269)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.