desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Mock turn_on function.'
| def turn_on(self):
| self._state = STATE_UNKNOWN
|
'Mock turn_off function.'
| def turn_off(self):
| self._state = STATE_OFF
|
'Mock mute function.'
| def mute_volume(self):
| self._is_volume_muted = (~ self._is_volume_muted)
|
'Mock set volume level.'
| def set_volume_level(self, volume):
| self._volume_level = volume
|
'Mock play.'
| def media_play(self):
| self._state = STATE_PLAYING
|
'Mock pause.'
| def media_pause(self):
| self._state = STATE_PAUSED
|
'Set the input source.'
| def select_source(self, source):
| self._state = source
|
'Clear players playlist.'
| def clear_playlist(self):
| self._tracks = 0
|
'Clear players playlist.'
| def set_shuffle(self, shuffle):
| self._shuffle = shuffle
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.mock_mp_1 = MockMediaPlayer(self.hass, 'mock1')
self.mock_mp_1.schedule_update_ha_state()
self.mock_mp_2 = MockMediaPlayer(self.hass, 'mock2')
self.mock_mp_2.schedule_update_ha_state()
self.hass.block_till_done()
self.mock_mute_switch_id = switch.ENTITY_ID_FORMAT.format('mute')
self.hass.states.set(self.mock_mute_switch_id, STATE_OFF)
self.mock_state_switch_id = switch.ENTITY_ID_FORMAT.format('state')
self.hass.states.set(self.mock_state_switch_id, STATE_OFF)
self.mock_volume_id = input_slider.ENTITY_ID_FORMAT.format('volume_level')
self.hass.states.set(self.mock_volume_id, 0)
self.mock_source_list_id = input_select.ENTITY_ID_FORMAT.format('source_list')
self.hass.states.set(self.mock_source_list_id, ['dvd', 'htpc'])
self.mock_source_id = input_select.ENTITY_ID_FORMAT.format('source')
self.hass.states.set(self.mock_source_id, 'dvd')
self.mock_shuffle_switch_id = switch.ENTITY_ID_FORMAT.format('shuffle')
self.hass.states.set(self.mock_shuffle_switch_id, STATE_OFF)
self.config_children_only = {'name': 'test', 'platform': 'universal', 'children': [media_player.ENTITY_ID_FORMAT.format('mock1'), media_player.ENTITY_ID_FORMAT.format('mock2')]}
self.config_children_and_attr = {'name': 'test', 'platform': 'universal', 'children': [media_player.ENTITY_ID_FORMAT.format('mock1'), media_player.ENTITY_ID_FORMAT.format('mock2')], 'attributes': {'is_volume_muted': self.mock_mute_switch_id, 'volume_level': self.mock_volume_id, 'source': self.mock_source_id, 'source_list': self.mock_source_list_id, 'state': self.mock_state_switch_id, 'shuffle': self.mock_shuffle_switch_id}}
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Check config with only children.'
| def test_config_children_only(self):
| config_start = copy(self.config_children_only)
del config_start['platform']
config_start['commands'] = {}
config_start['attributes'] = {}
response = universal.validate_config(self.config_children_only)
self.assertTrue(response)
self.assertEqual(config_start, self.config_children_only)
|
'Check config with children and attributes.'
| def test_config_children_and_attr(self):
| config_start = copy(self.config_children_and_attr)
del config_start['platform']
config_start['commands'] = {}
response = universal.validate_config(self.config_children_and_attr)
self.assertTrue(response)
self.assertEqual(config_start, self.config_children_and_attr)
|
'Check config with no Name entry.'
| def test_config_no_name(self):
| response = universal.validate_config({'platform': 'universal'})
self.assertFalse(response)
|
'Check config with bad children entry.'
| def test_config_bad_children(self):
| config_no_children = {'name': 'test', 'platform': 'universal'}
config_bad_children = {'name': 'test', 'children': {}, 'platform': 'universal'}
response = universal.validate_config(config_no_children)
self.assertTrue(response)
self.assertEqual([], config_no_children['children'])
response = universal.validate_config(config_bad_children)
self.assertTrue(response)
self.assertEqual([], config_bad_children['children'])
|
'Check config with bad commands entry.'
| def test_config_bad_commands(self):
| config = {'name': 'test', 'commands': [], 'platform': 'universal'}
response = universal.validate_config(config)
self.assertTrue(response)
self.assertEqual({}, config['commands'])
|
'Check config with bad attributes.'
| def test_config_bad_attributes(self):
| config = {'name': 'test', 'attributes': [], 'platform': 'universal'}
response = universal.validate_config(config)
self.assertTrue(response)
self.assertEqual({}, config['attributes'])
|
'Check config with bad key.'
| def test_config_bad_key(self):
| config = {'name': 'test', 'asdf': 5, 'platform': 'universal'}
response = universal.validate_config(config)
self.assertTrue(response)
self.assertFalse(('asdf' in config))
|
'Test platform setup.'
| def test_platform_setup(self):
| config = {'name': 'test', 'platform': 'universal'}
bad_config = {'platform': 'universal'}
entities = []
def add_devices(new_entities):
'Add devices to list.'
for dev in new_entities:
entities.append(dev)
run_coroutine_threadsafe(universal.async_setup_platform(self.hass, bad_config, add_devices), self.hass.loop).result()
self.assertEqual(0, len(entities))
run_coroutine_threadsafe(universal.async_setup_platform(self.hass, config, add_devices), self.hass.loop).result()
self.assertEqual(1, len(entities))
self.assertEqual('test', entities[0].name)
|
'Test master state property.'
| def test_master_state(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual(None, ump.master_state)
|
'Test master state property.'
| def test_master_state_with_attrs(self):
| config = self.config_children_and_attr
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual(STATE_OFF, ump.master_state)
self.hass.states.set(self.mock_state_switch_id, STATE_ON)
self.assertEqual(STATE_ON, ump.master_state)
|
'Test master state property.'
| def test_master_state_with_bad_attrs(self):
| config = self.config_children_and_attr
config['attributes']['state'] = 'bad.entity_id'
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual(STATE_OFF, ump.master_state)
|
'Test active child state property.'
| def test_active_child_state(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(None, ump._child_state)
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(self.mock_mp_1.entity_id, ump._child_state.entity_id)
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(self.mock_mp_1.entity_id, ump._child_state.entity_id)
self.mock_mp_1._state = STATE_OFF
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(self.mock_mp_2.entity_id, ump._child_state.entity_id)
|
'Test name property.'
| def test_name(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual(config['name'], ump.name)
|
'Test should_poll property.'
| def test_polling(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual(False, ump.should_poll)
|
'Test media player state with only children.'
| def test_state_children_only(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertTrue(ump.state, STATE_OFF)
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(STATE_PLAYING, ump.state)
|
'Test media player with children and master state.'
| def test_state_with_children_and_attrs(self):
| config = self.config_children_and_attr
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(STATE_OFF, ump.state)
self.hass.states.set(self.mock_state_switch_id, STATE_ON)
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(STATE_ON, ump.state)
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(STATE_PLAYING, ump.state)
self.hass.states.set(self.mock_state_switch_id, STATE_OFF)
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(STATE_OFF, ump.state)
|
'Test volume level property.'
| def test_volume_level(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(None, ump.volume_level)
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(0, ump.volume_level)
self.mock_mp_1._volume_level = 1
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(1, ump.volume_level)
|
'Test media_image_url property.'
| def test_media_image_url(self):
| TEST_URL = 'test_url'
config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(None, ump.media_image_url)
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1._media_image_url = TEST_URL
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(self.mock_mp_1.entity_picture, ump.entity_picture)
|
'Test is volume muted property w/ children only.'
| def test_is_volume_muted_children_only(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertFalse(ump.is_volume_muted)
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertFalse(ump.is_volume_muted)
self.mock_mp_1._is_volume_muted = True
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertTrue(ump.is_volume_muted)
|
'Test source list property w/ children and attrs.'
| def test_source_list_children_and_attr(self):
| config = self.config_children_and_attr
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual("['dvd', 'htpc']", ump.source_list)
self.hass.states.set(self.mock_source_list_id, ['dvd', 'htpc', 'game'])
self.assertEqual("['dvd', 'htpc', 'game']", ump.source_list)
|
'Test source property w/ children and attrs.'
| def test_source_children_and_attr(self):
| config = self.config_children_and_attr
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual('dvd', ump.source)
self.hass.states.set(self.mock_source_id, 'htpc')
self.assertEqual('htpc', ump.source)
|
'Test volume level property w/ children and attrs.'
| def test_volume_level_children_and_attr(self):
| config = self.config_children_and_attr
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertEqual('0', ump.volume_level)
self.hass.states.set(self.mock_volume_id, 100)
self.assertEqual('100', ump.volume_level)
|
'Test is volume muted property w/ children and attrs.'
| def test_is_volume_muted_children_and_attr(self):
| config = self.config_children_and_attr
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
self.assertFalse(ump.is_volume_muted)
self.hass.states.set(self.mock_mute_switch_id, STATE_ON)
self.assertTrue(ump.is_volume_muted)
|
'Test supported media commands with only children.'
| def test_supported_features_children_only(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(0, ump.supported_features)
self.mock_mp_1._supported_features = 512
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.assertEqual(512, ump.supported_features)
|
'Test supported media commands with children and attrs.'
| def test_supported_features_children_and_cmds(self):
| config = self.config_children_and_attr
universal.validate_config(config)
config['commands']['turn_on'] = 'test'
config['commands']['turn_off'] = 'test'
config['commands']['volume_up'] = 'test'
config['commands']['volume_down'] = 'test'
config['commands']['volume_mute'] = 'test'
config['commands']['volume_set'] = 'test'
config['commands']['select_source'] = 'test'
config['commands']['shuffle_set'] = 'test'
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
check_flags = (((((universal.SUPPORT_TURN_ON | universal.SUPPORT_TURN_OFF) | universal.SUPPORT_VOLUME_STEP) | universal.SUPPORT_VOLUME_MUTE) | universal.SUPPORT_SELECT_SOURCE) | universal.SUPPORT_SHUFFLE_SET)
self.assertEqual(check_flags, ump.supported_features)
|
'Test a service call to children with no active child.'
| def test_service_call_no_active_child(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.mock_mp_1._state = STATE_OFF
self.mock_mp_1.schedule_update_ha_state()
self.mock_mp_2._state = STATE_OFF
self.mock_mp_2.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
run_coroutine_threadsafe(ump.async_turn_off(), self.hass.loop).result()
self.assertEqual(0, len(self.mock_mp_1.service_calls['turn_off']))
self.assertEqual(0, len(self.mock_mp_2.service_calls['turn_off']))
|
'Test service calls that should be routed to a child.'
| def test_service_call_to_child(self):
| config = self.config_children_only
universal.validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
run_coroutine_threadsafe(ump.async_turn_off(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['turn_off']))
run_coroutine_threadsafe(ump.async_turn_on(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['turn_on']))
run_coroutine_threadsafe(ump.async_mute_volume(True), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['mute_volume']))
run_coroutine_threadsafe(ump.async_set_volume_level(0.5), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['set_volume_level']))
run_coroutine_threadsafe(ump.async_media_play(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['media_play']))
run_coroutine_threadsafe(ump.async_media_pause(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['media_pause']))
run_coroutine_threadsafe(ump.async_media_previous_track(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['media_previous_track']))
run_coroutine_threadsafe(ump.async_media_next_track(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['media_next_track']))
run_coroutine_threadsafe(ump.async_media_seek(100), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['media_seek']))
run_coroutine_threadsafe(ump.async_play_media('movie', 'batman'), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['play_media']))
run_coroutine_threadsafe(ump.async_volume_up(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['volume_up']))
run_coroutine_threadsafe(ump.async_volume_down(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['volume_down']))
run_coroutine_threadsafe(ump.async_media_play_pause(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['media_play_pause']))
run_coroutine_threadsafe(ump.async_select_source('dvd'), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['select_source']))
run_coroutine_threadsafe(ump.async_clear_playlist(), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['clear_playlist']))
run_coroutine_threadsafe(ump.async_set_shuffle(True), self.hass.loop).result()
self.assertEqual(1, len(self.mock_mp_2.service_calls['shuffle_set']))
|
'Test service call to command.'
| def test_service_call_to_command(self):
| config = self.config_children_only
config['commands'] = {'turn_off': {'service': 'test.turn_off', 'data': {}}}
universal.validate_config(config)
service = mock_service(self.hass, 'test', 'turn_off')
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config['name'])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
run_coroutine_threadsafe(ump.async_turn_off(), self.hass.loop).result()
self.assertEqual(1, len(service))
|
'Return tuple of soco.SoCo objects representing found speakers.'
| def discover(interface_addr):
| return {SoCoMock('192.0.2.1')}
|
'Initialize ethe Transport mock.'
| def __init__(self):
| pass
|
'Get the media details.'
| def GetMediaInfo(self, _):
| return {'CurrentURI': '', 'CurrentURIMetaData': ''}
|
'Initialize soco object.'
| def __init__(self, ip):
| self.ip_address = ip
self.is_visible = True
self.avTransport = AvTransportMock()
|
'Get favorites list from sonos.'
| def get_sonos_favorites(self):
| return {'favorites': []}
|
'Return a dict with various data points about the speaker.'
| def get_speaker_info(self, force):
| return {'serial_number': 'B8-E9-37-BO-OC-BA:2', 'software_version': '32.11-30071', 'uid': 'RINCON_B8E937BOOCBA02500', 'zone_icon': 'x-rincon-roomicon:kitchen', 'mac_address': 'B8:E9:37:BO:OC:BA', 'zone_name': 'Kitchen', 'hardware_version': '1.8.1.2-1'}
|
'Return a dict with the current state of the speaker.'
| def get_current_transport_info(self):
| return {'current_transport_speed': '1', 'current_transport_state': 'STOPPED', 'current_transport_status': 'OK'}
|
'Return a dict with the current track information.'
| def get_current_track_info(self):
| return {'album': '', 'uri': '', 'title': '', 'artist': '', 'duration': '0:00:00', 'album_art': '', 'position': '0:00:00', 'playlist_position': '0', 'metadata': ''}
|
'Return true if coordinator.'
| def is_coordinator(self):
| return True
|
'Join speaker to a group.'
| def join(self, master):
| return
|
'Set the sleep timer.'
| def set_sleep_timer(self, sleep_time_seconds):
| return
|
'Cause the speaker to separate itself from other speakers.'
| def unjoin(self):
| return
|
'Return a player uid.'
| def uid(self):
| return 'RINCON_XXXXXXXXXXXXXXXXX'
|
'Return all group data of this player.'
| def group(self):
| return
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
def monkey_available(self):
'Make a monkey available.'
return True
self.real_available = sonos.SonosDevice.available
sonos.SonosDevice.available = monkey_available
|
'Stop everything that was started.'
| def tearDown(self):
| sonos.SonosDevice.available = self.real_available
self.hass.stop()
|
'Test a single device using the autodiscovery provided by HASS.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
def test_ensure_setup_discovery(self, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 1)
self.assertEqual(self.hass.data[sonos.DATA_SONOS][0].name, 'Kitchen')
|
'Test a interface address config\'d by the HASS config file.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch('soco.discover')
def test_ensure_setup_config_interface_addr(self, discover_mock, *args):
| discover_mock.return_value = {SoCoMock('192.0.2.1')}
config = {DOMAIN: {CONF_PLATFORM: 'sonos', CONF_INTERFACE_ADDR: '192.0.1.1'}}
assert setup_component(self.hass, DOMAIN, config)
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 1)
self.assertEqual(discover_mock.call_count, 1)
|
'Test a advertise address config\'d by the HASS config file.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch('soco.discover')
def test_ensure_setup_config_advertise_addr(self, discover_mock, *args):
| discover_mock.return_value = {SoCoMock('192.0.2.1')}
config = {DOMAIN: {CONF_PLATFORM: 'sonos', CONF_ADVERTISE_ADDR: '192.0.1.1'}}
assert setup_component(self.hass, DOMAIN, config)
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 1)
self.assertEqual(discover_mock.call_count, 1)
self.assertEqual(soco.config.EVENT_ADVERTISE_IP, '192.0.1.1')
|
'Test a single address config\'d by the HASS config file.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
def test_ensure_setup_config_hosts_string_single(self, *args):
| config = {DOMAIN: {CONF_PLATFORM: 'sonos', CONF_HOSTS: ['192.0.2.1']}}
assert setup_component(self.hass, DOMAIN, config)
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 1)
self.assertEqual(self.hass.data[sonos.DATA_SONOS][0].name, 'Kitchen')
|
'Test multiple address string config\'d by the HASS config file.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
def test_ensure_setup_config_hosts_string_multiple(self, *args):
| config = {DOMAIN: {CONF_PLATFORM: 'sonos', CONF_HOSTS: ['192.0.2.1,192.168.2.2']}}
assert setup_component(self.hass, DOMAIN, config)
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 2)
self.assertEqual(self.hass.data[sonos.DATA_SONOS][0].name, 'Kitchen')
|
'Test a multiple address list config\'d by the HASS config file.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
def test_ensure_setup_config_hosts_list(self, *args):
| config = {DOMAIN: {CONF_PLATFORM: 'sonos', CONF_HOSTS: ['192.0.2.1', '192.168.2.2']}}
assert setup_component(self.hass, DOMAIN, config)
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 2)
self.assertEqual(self.hass.data[sonos.DATA_SONOS][0].name, 'Kitchen')
|
'Test a single device using the autodiscovery provided by Sonos.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch.object(soco, 'discover', new=socoDiscoverMock.discover)
@mock.patch('socket.create_connection', side_effect=socket.error())
def test_ensure_setup_sonos_discovery(self, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device)
self.assertEqual(len(self.hass.data[sonos.DATA_SONOS]), 1)
self.assertEqual(self.hass.data[sonos.DATA_SONOS][0].name, 'Kitchen')
|
'Ensuring soco methods called for sonos_group_players service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch.object(SoCoMock, 'join')
def test_sonos_group_players(self, join_mock, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
device_master = mock.MagicMock()
device_master.entity_id = 'media_player.test'
device_master.soco_device = mock.MagicMock()
self.hass.data[sonos.DATA_SONOS].append(device_master)
join_mock.return_value = True
device.join('media_player.test')
self.assertEqual(join_mock.call_count, 1)
|
'Ensuring soco methods called for sonos_unjoin service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch.object(SoCoMock, 'unjoin')
def test_sonos_unjoin(self, unjoinMock, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
unjoinMock.return_value = True
device.unjoin()
self.assertEqual(unjoinMock.call_count, 1)
self.assertEqual(unjoinMock.call_args, mock.call())
|
'Ensuring soco methods called for sonos_set_sleep_timer service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch.object(SoCoMock, 'set_sleep_timer')
def test_sonos_set_sleep_timer(self, set_sleep_timerMock, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
device.set_sleep_timer(30)
set_sleep_timerMock.assert_called_once_with(30)
|
'Ensuring soco methods called for sonos_clear_sleep_timer service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch.object(SoCoMock, 'set_sleep_timer')
def test_sonos_clear_sleep_timer(self, set_sleep_timerMock, *args):
| sonos.setup_platform(self.hass, {}, mock.MagicMock(), {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
device.set_sleep_timer(None)
set_sleep_timerMock.assert_called_once_with(None)
|
'Ensuring soco methods called for sonos_set_sleep_timer service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('soco.alarms.Alarm')
@mock.patch('socket.create_connection', side_effect=socket.error())
def test_update_alarm(self, soco_mock, alarm_mock, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
alarm1 = alarms.Alarm(soco_mock)
alarm1.configure_mock(_alarm_id='1', start_time=None, enabled=False, include_linked_zones=False, volume=100)
with mock.patch('soco.alarms.get_alarms', return_value=[alarm1]):
attrs = {'time': datetime.time(12, 0), 'enabled': True, 'include_linked_zones': True, 'volume': 0.3}
device.update_alarm(alarm_id=2)
alarm1.save.assert_not_called()
device.update_alarm(alarm_id=1, **attrs)
self.assertEqual(alarm1.enabled, attrs['enabled'])
self.assertEqual(alarm1.start_time, attrs['time'])
self.assertEqual(alarm1.include_linked_zones, attrs['include_linked_zones'])
self.assertEqual(alarm1.volume, 30)
alarm1.save.assert_called_once_with()
|
'Ensuring soco methods called for sonos_snapshot service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch.object(soco.snapshot.Snapshot, 'snapshot')
def test_sonos_snapshot(self, snapshotMock, *args):
| sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
snapshotMock.return_value = True
device.snapshot()
self.assertEqual(snapshotMock.call_count, 1)
self.assertEqual(snapshotMock.call_args, mock.call())
|
'Ensuring soco methods called for sonos_restor service.'
| @mock.patch('soco.SoCo', new=SoCoMock)
@mock.patch('socket.create_connection', side_effect=socket.error())
@mock.patch.object(soco.snapshot.Snapshot, 'restore')
def test_sonos_restore(self, restoreMock, *args):
| from soco.snapshot import Snapshot
sonos.setup_platform(self.hass, {}, fake_add_device, {'host': '192.0.2.1'})
device = self.hass.data[sonos.DATA_SONOS][(-1)]
device.hass = self.hass
restoreMock.return_value = True
device._snapshot_coordinator = mock.MagicMock()
device._snapshot_coordinator.soco_device = SoCoMock('192.0.2.17')
device._soco_snapshot = Snapshot(device._player)
device.restore()
self.assertEqual(restoreMock.call_count, 1)
self.assertEqual(restoreMock.call_args, mock.call(False))
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
|
'Shut down test instance.'
| def tearDown(self):
| self.hass.stop()
|
'Test the input source service.'
| def test_source_select(self):
| entity_id = 'media_player.lounge_room'
assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
state = self.hass.states.get(entity_id)
assert ('dvd' == state.attributes.get('source'))
mp.select_source(self.hass, None, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert ('dvd' == state.attributes.get('source'))
mp.select_source(self.hass, 'xbox', entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert ('xbox' == state.attributes.get('source'))
|
'Test clear playlist.'
| def test_clear_playlist(self):
| assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
assert self.hass.states.is_state(entity_id, 'playing')
mp.clear_playlist(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'off')
|
'Test the volume service.'
| def test_volume_services(self):
| assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
state = self.hass.states.get(entity_id)
assert (1.0 == state.attributes.get('volume_level'))
mp.set_volume_level(self.hass, None, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (1.0 == state.attributes.get('volume_level'))
mp.set_volume_level(self.hass, 0.5, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (0.5 == state.attributes.get('volume_level'))
mp.volume_down(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (0.4 == state.attributes.get('volume_level'))
mp.volume_up(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (0.5 == state.attributes.get('volume_level'))
assert (False is state.attributes.get('is_volume_muted'))
mp.mute_volume(self.hass, None, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (False is state.attributes.get('is_volume_muted'))
mp.mute_volume(self.hass, True, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (True is state.attributes.get('is_volume_muted'))
|
'Test turn_on and turn_off.'
| def test_turning_off_and_on(self):
| assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
assert self.hass.states.is_state(entity_id, 'playing')
mp.turn_off(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'off')
assert (not mp.is_on(self.hass, entity_id))
mp.turn_on(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'playing')
mp.toggle(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'off')
assert (not mp.is_on(self.hass, entity_id))
|
'Test media_pause.'
| def test_playing_pausing(self):
| assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
assert self.hass.states.is_state(entity_id, 'playing')
mp.media_pause(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'paused')
mp.media_play_pause(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'playing')
mp.media_play_pause(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'paused')
mp.media_play(self.hass, entity_id)
self.hass.block_till_done()
assert self.hass.states.is_state(entity_id, 'playing')
|
'Test media_next_track and media_previous_track .'
| def test_prev_next_track(self):
| assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
state = self.hass.states.get(entity_id)
assert (1 == state.attributes.get('media_track'))
assert (0 == (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
mp.media_next_track(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (2 == state.attributes.get('media_track'))
assert (0 < (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
mp.media_next_track(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (3 == state.attributes.get('media_track'))
assert (0 < (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
mp.media_previous_track(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert (2 == state.attributes.get('media_track'))
assert (0 < (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
ent_id = 'media_player.lounge_room'
state = self.hass.states.get(ent_id)
assert (1 == state.attributes.get('media_episode'))
assert (0 == (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
mp.media_next_track(self.hass, ent_id)
self.hass.block_till_done()
state = self.hass.states.get(ent_id)
assert (2 == state.attributes.get('media_episode'))
assert (0 < (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
mp.media_previous_track(self.hass, ent_id)
self.hass.block_till_done()
state = self.hass.states.get(ent_id)
assert (1 == state.attributes.get('media_episode'))
assert (0 == (mp.SUPPORT_PREVIOUS_TRACK & state.attributes.get('supported_features')))
|
'Test play_media .'
| @patch('homeassistant.components.media_player.demo.DemoYoutubePlayer.media_seek', autospec=True)
def test_play_media(self, mock_seek):
| assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
ent_id = 'media_player.living_room'
state = self.hass.states.get(ent_id)
assert (0 < (mp.SUPPORT_PLAY_MEDIA & state.attributes.get('supported_features')))
assert (state.attributes.get('media_content_id') is not None)
mp.play_media(self.hass, None, 'some_id', ent_id)
self.hass.block_till_done()
state = self.hass.states.get(ent_id)
assert (0 < (mp.SUPPORT_PLAY_MEDIA & state.attributes.get('supported_features')))
assert (not ('some_id' == state.attributes.get('media_content_id')))
mp.play_media(self.hass, 'youtube', 'some_id', ent_id)
self.hass.block_till_done()
state = self.hass.states.get(ent_id)
assert (0 < (mp.SUPPORT_PLAY_MEDIA & state.attributes.get('supported_features')))
assert ('some_id' == state.attributes.get('media_content_id'))
assert (not mock_seek.called)
mp.media_seek(self.hass, None, ent_id)
self.hass.block_till_done()
assert (not mock_seek.called)
mp.media_seek(self.hass, 100, ent_id)
self.hass.block_till_done()
assert mock_seek.called
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
assert setup_component(self.hass, http.DOMAIN, {http.DOMAIN: {http.CONF_SERVER_PORT: SERVER_PORT, http.CONF_API_PASSWORD: API_PASSWORD}})
assert setup_component(self.hass, mp.DOMAIN, {'media_player': {'platform': 'demo'}})
self.hass.start()
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test the media server image proxy server .'
| def test_media_image_proxy(self):
| fake_picture_data = 'test.test'
class MockResponse:
def __init__(self):
self.status = 200
self.headers = {'Content-Type': 'sometype'}
@asyncio.coroutine
def read(self):
return fake_picture_data.encode('ascii')
@asyncio.coroutine
def release(self):
pass
class MockWebsession:
@asyncio.coroutine
def get(self, url):
return MockResponse()
def detach(self):
pass
self.hass.data[DATA_CLIENTSESSION] = MockWebsession()
assert self.hass.states.is_state(entity_id, 'playing')
state = self.hass.states.get(entity_id)
req = requests.get((HTTP_BASE_URL + state.attributes.get('entity_picture')))
assert (req.status_code == 200)
assert (req.text == fake_picture_data)
|
'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 if able to call a configured service.'
| def test_executing_service(self):
| with tempfile.TemporaryDirectory() as tempdirname:
path = os.path.join(tempdirname, 'called.txt')
assert setup_component(self.hass, shell_command.DOMAIN, {shell_command.DOMAIN: {'test_service': 'date > {}'.format(path)}})
self.hass.services.call('shell_command', 'test_service', blocking=True)
self.hass.block_till_done()
self.assertTrue(os.path.isfile(path))
|
'Test if config is not a dict.'
| def test_config_not_dict(self):
| assert (not setup_component(self.hass, shell_command.DOMAIN, {shell_command.DOMAIN: ['some', 'weird', 'list']}))
|
'Test if config contains invalid service names.'
| def test_config_not_valid_service_names(self):
| assert (not setup_component(self.hass, shell_command.DOMAIN, {shell_command.DOMAIN: {'this is invalid because space': 'touch bla.txt'}}))
|
'Ensure shell_commands without templates get rendered properly.'
| @patch('homeassistant.components.shell_command.subprocess.call')
def test_template_render_no_template(self, mock_call):
| assert setup_component(self.hass, shell_command.DOMAIN, {shell_command.DOMAIN: {'test_service': 'ls /bin'}})
self.hass.services.call('shell_command', 'test_service', blocking=True)
cmd = mock_call.mock_calls[0][1][0]
shell = mock_call.mock_calls[0][2]['shell']
assert ('ls /bin' == cmd)
assert shell
|
'Ensure shell_commands without templates get rendered properly.'
| @patch('homeassistant.components.shell_command.subprocess.call')
def test_template_render(self, mock_call):
| self.hass.states.set('sensor.test_state', 'Works')
assert setup_component(self.hass, shell_command.DOMAIN, {shell_command.DOMAIN: {'test_service': 'ls /bin {{ states.sensor.test_state.state }}'}})
self.hass.services.call('shell_command', 'test_service', blocking=True)
cmd = mock_call.mock_calls[0][1][0]
shell = mock_call.mock_calls[0][2]['shell']
assert (['ls', '/bin', 'Works'] == cmd)
assert (not shell)
|
'Test subprocess.'
| @patch('homeassistant.components.shell_command.subprocess.call', side_effect=SubprocessError)
@patch('homeassistant.components.shell_command._LOGGER.error')
def test_subprocess_raising_error(self, mock_call, mock_error):
| with tempfile.TemporaryDirectory() as tempdirname:
path = os.path.join(tempdirname, 'called.txt')
assert setup_component(self.hass, shell_command.DOMAIN, {shell_command.DOMAIN: {'test_service': 'touch {}'.format(path)}})
self.hass.services.call('shell_command', 'test_service', blocking=True)
self.assertFalse(os.path.isfile(path))
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 down everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test if no config is passed in we still get the home zone.'
| def test_setup_no_zones_still_adds_home_zone(self):
| assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': None})
assert (len(self.hass.states.entity_ids('zone')) == 1)
state = self.hass.states.get('zone.home')
assert (self.hass.config.location_name == state.name)
assert (self.hass.config.latitude == state.attributes['latitude'])
assert (self.hass.config.longitude == state.attributes['longitude'])
assert (not state.attributes.get('passive', False))
|
'Test setup.'
| def test_setup(self):
| info = {'name': 'Test Zone', 'latitude': 32.880837, 'longitude': (-117.237561), 'radius': 250, 'passive': True}
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': info})
state = self.hass.states.get('zone.test_zone')
assert (info['name'] == state.name)
assert (info['latitude'] == state.attributes['latitude'])
assert (info['longitude'] == state.attributes['longitude'])
assert (info['radius'] == state.attributes['radius'])
assert (info['passive'] == state.attributes['passive'])
|
'Test active and passive zones.'
| def test_active_zone_skips_passive_zones(self):
| assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': [{'name': 'Passive Zone', 'latitude': 32.8806, 'longitude': (-117.237561), 'radius': 250, 'passive': True}]})
self.hass.block_till_done()
active = zone.active_zone(self.hass, 32.8806, (-117.237561))
assert (active is None)
|
'Test active and passive zones.'
| def test_active_zone_skips_passive_zones_2(self):
| assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': [{'name': 'Active Zone', 'latitude': 32.8808, 'longitude': (-117.237561), 'radius': 500}]})
self.hass.block_till_done()
active = zone.active_zone(self.hass, 32.8807, (-117.237561))
assert ('zone.active_zone' == active.entity_id)
|
'Test zone size preferences.'
| def test_active_zone_prefers_smaller_zone_if_same_distance(self):
| latitude = 32.8806
longitude = (-117.237561)
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': [{'name': 'Small Zone', 'latitude': latitude, 'longitude': longitude, 'radius': 250}, {'name': 'Big Zone', 'latitude': latitude, 'longitude': longitude, 'radius': 500}]})
active = zone.active_zone(self.hass, latitude, longitude)
assert ('zone.small_zone' == active.entity_id)
|
'Test zone size preferences.'
| def test_active_zone_prefers_smaller_zone_if_same_distance_2(self):
| latitude = 32.8806
longitude = (-117.237561)
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': [{'name': 'Smallest Zone', 'latitude': latitude, 'longitude': longitude, 'radius': 50}]})
active = zone.active_zone(self.hass, latitude, longitude)
assert ('zone.smallest_zone' == active.entity_id)
|
'Test working in passive zones.'
| def test_in_zone_works_for_passive_zones(self):
| latitude = 32.8806
longitude = (-117.237561)
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': [{'name': 'Passive Zone', 'latitude': latitude, 'longitude': longitude, 'radius': 250, 'passive': True}]})
assert zone.in_zone(self.hass.states.get('zone.passive_zone'), latitude, longitude)
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
mock_http_component(self.hass)
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.