def test_platform_validator(): """Test platform validation.""" # Prepares loading get_test_home_assistant() schema = vol.Schema(cv.platform_validator('light')) with pytest.raises(vol.MultipleInvalid): schema('platform_that_does_not_exist') schema('hue')
def setup_method(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() setup_component( self.hass, http.DOMAIN, {http.DOMAIN: {http.CONF_SERVER_PORT: get_test_instance_port()}}) config = { ip.DOMAIN: { 'platform': 'demo' }, 'camera': { 'platform': 'demo' }, } with patch('homeassistant.components.image_processing.demo.' 'DemoImageProcessing.should_poll', new_callable=PropertyMock(return_value=False)): setup_component(self.hass, ip.DOMAIN, config) state = self.hass.states.get('camera.demo_camera') self.url = "{0}{1}".format( self.hass.config.api.base_url, state.attributes.get(ATTR_ENTITY_PICTURE))
def setup_method(self): """Setup things to be run when tests are started.""" self.url = "https://example.com/" self.config = { rc.DOMAIN: { 'get_test': { 'url': self.url, 'method': 'get', }, 'post_test': { 'url': self.url, 'method': 'post', }, 'put_test': { 'url': self.url, 'method': 'put', }, 'delete_test': { 'url': self.url, 'method': 'delete', }, } } self.hass = get_test_home_assistant()
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() with patch('homeassistant.core.Config.path', return_value=':memory:'): recorder.setup(self.hass, {}) self.hass.start() recorder._INSTANCE.block_till_done()
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.events = [] self.service1 = MagicMock() self.service2 = MagicMock() def mock_get_service(hass, config): if config['name'] == 'demo1': return self.service1 else: return self.service2 with assert_setup_component(2), \ patch.object(demo, 'get_service', mock_get_service): setup_component(self.hass, notify.DOMAIN, { 'notify': [{ 'name': 'demo1', 'platform': 'demo' }, { 'name': 'demo2', 'platform': 'demo' }] }) self.service = group.get_service(self.hass, {'services': [ {'service': 'demo1'}, {'service': 'demo2', 'data': {'target': 'unnamed device', 'data': {'test': 'message'}}}]}) assert self.service is not None
def setup_method(self): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() config = { ip.DOMAIN: { 'platform': 'demo' }, 'camera': { 'platform': 'demo' }, } with patch('homeassistant.components.image_processing.demo.' 'DemoImageProcessingFace.should_poll', new_callable=PropertyMock(return_value=False)): setup_component(self.hass, ip.DOMAIN, config) state = self.hass.states.get('camera.demo_camera') self.url = "{0}{1}".format( self.hass.config.api.base_url, state.attributes.get(ATTR_ENTITY_PICTURE)) self.face_events = [] @callback def mock_face_event(event): """Mock event.""" self.face_events.append(event) self.hass.bus.listen('image_processing.detect_face', mock_face_event)
def setUp(self): # pylint: disable=invalid-name self.hass = get_test_home_assistant() self.mock_mp_1 = MockMediaPlayer(self.hass, 'mock1') self.mock_mp_1.update_ha_state() self.mock_mp_2 = MockMediaPlayer(self.hass, 'mock2') self.mock_mp_2.update_ha_state() 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.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, 'state': self.mock_state_switch_id}}
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.events = [] self.assertTrue(setup_component(self.hass, notify.DOMAIN, { 'notify': [{ 'name': 'demo1', 'platform': 'demo' }, { 'name': 'demo2', 'platform': 'demo' }] })) self.service = group.get_service(self.hass, {'services': [ {'service': 'demo1'}, {'service': 'demo2', 'data': {'target': 'unnamed device', 'data': {'test': 'message'}}}]}) assert self.service is not None def record_event(event): """Record event to send notification.""" self.events.append(event) self.hass.bus.listen("notify", record_event)
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.hass.config.units = METRIC_SYSTEM self.assertTrue(run_coroutine_threadsafe( comps.async_setup(self.hass, {}), self.hass.loop ).result())
def setUp(self): # pylint: disable=invalid-name """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.mailer = MockSMTP('localhost', 25, 5, '*****@*****.**', 1, 'testuser', 'testpass', ['*****@*****.**', '*****@*****.**'], 'HomeAssistant', 0)
def setup_method(self, method): """Setup the test.""" if method == self.test_from_config_file: return self.hass = get_test_home_assistant() self.backup_cache = loader._COMPONENT_CACHE
def setup_method(self, method): """Setup things to be run when tests are started.""" self.entity = entity.Entity() self.entity.entity_id = 'test.overwrite_hidden_true' self.hass = self.entity.hass = get_test_home_assistant() self.entity.schedule_update_ha_state() self.hass.block_till_done()
def setUp(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() # Set our timezone to CST/Regina so we can check calculations # This keeps UTC-6 all year round dt_util.set_default_time_zone(dt_util.get_time_zone('America/Regina'))
def setup_method(self, method): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.rs = cmd_rs.CommandCover(self.hass, 'foo', 'command_open', 'command_close', 'command_stop', 'command_state', None)
def test_filling_the_cache(): """Test filling the cache from the DB.""" test_entity_id1 = 'input_boolean.b1' test_entity_id2 = 'input_boolean.b2' hass = get_test_home_assistant() hass.state = CoreState.starting init_recorder_component(hass) _add_data_in_last_run(hass, { test_entity_id1: 'on', test_entity_id2: 'off', }) hass.block_till_done() setup_component(hass, input_boolean.DOMAIN, { input_boolean.DOMAIN: { 'b1': None, 'b2': None, }}) hass.start() state = hass.states.get('input_boolean.b1') assert state assert state.state == 'on' state = hass.states.get('input_boolean.b2') assert state assert state.state == 'off' hass.stop()
def test_remove_lib_on_upgrade(self, mock_os, mock_shutil): """Test removal of library on upgrade.""" ha_version = '0.7.0' mock_os.path.isdir = mock.Mock(return_value=True) mock_open = mock.mock_open() with mock.patch('homeassistant.config.open', mock_open, create=True): opened_file = mock_open.return_value opened_file.readline.return_value = ha_version self.hass = get_test_home_assistant() self.hass.config.path = mock.Mock() config_util.process_ha_config_upgrade(self.hass) hass_path = self.hass.config.path.return_value self.assertEqual(mock_os.path.isdir.call_count, 1) self.assertEqual( mock_os.path.isdir.call_args, mock.call(hass_path) ) self.assertEqual(mock_shutil.rmtree.call_count, 1) self.assertEqual( mock_shutil.rmtree.call_args, mock.call(hass_path) )
def setUpModule(): # pylint: disable=invalid-name """Initialize a Home Assistant server for testing this module.""" global hass hass = get_test_home_assistant() bootstrap.setup_component( hass, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SERVER_PORT}}) hass.services.register('test', 'alexa', lambda call: calls.append(call)) bootstrap.setup_component(hass, alexa.DOMAIN, { 'alexa': { 'intents': { 'WhereAreWeIntent': { 'speech': { 'type': 'plaintext', 'text': """ {%- if is_state('device_tracker.paulus', 'home') and is_state('device_tracker.anne_therese', 'home') -%} You are both home, you silly {%- else -%} Anne Therese is at {{ states("device_tracker.anne_therese") }} and Paulus is at {{ states("device_tracker.paulus") }} {% endif %} """, } }, 'GetZodiacHoroscopeIntent': { 'speech': { 'type': 'plaintext', 'text': 'You told us your sign is {{ ZodiacSign }}.', } }, 'CallServiceIntent': { 'speech': { 'type': 'plaintext', 'text': 'Service called', }, 'action': { 'service': 'test.alexa', 'data_template': { 'hello': '{{ ZodiacSign }}' }, 'entity_id': 'switch.test', } } } } }) hass.start() time.sleep(0.05)
def setUp(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() controller_mock = mock.MagicMock() dev_dict = {'address': 'a1', 'name': 'fake_switch'} self.switch = mochad.MochadSwitch(self.hass, controller_mock, dev_dict)
def test_debounce(self): """Test add_timeout decorator function.""" def demo_func(*args): nonlocal arguments, counter counter += 1 arguments = args arguments = None counter = 0 hass = get_test_home_assistant() mock = Mock(hass=hass) debounce_demo = debounce(demo_func) self.assertEqual(debounce_demo.__name__, 'demo_func') now = datetime(2018, 1, 1, 20, 0, 0, tzinfo=dt_util.UTC) with patch('homeassistant.util.dt.utcnow', return_value=now): debounce_demo(mock, 'value') hass.bus.fire( EVENT_TIME_CHANGED, {ATTR_NOW: now + timedelta(seconds=3)}) hass.block_till_done() assert counter == 1 assert len(arguments) == 2 with patch('homeassistant.util.dt.utcnow', return_value=now): debounce_demo(mock, 'value') debounce_demo(mock, 'value') hass.bus.fire( EVENT_TIME_CHANGED, {ATTR_NOW: now + timedelta(seconds=3)}) hass.block_till_done() assert counter == 2 hass.stop()
def setUp(self): """Initialize unit test data.""" self.hass = get_test_home_assistant() self.assertTrue(fan.setup(self.hass, {'fan': { 'platform': 'demo', }})) self.hass.pool.block_till_done()
def setUpModule(): # pylint: disable=invalid-name """Initalization of a Home Assistant server and Slave instance.""" global hass, slave, master_api hass = get_test_home_assistant() hass.bus.listen('test_event', lambda _: _) hass.states.set('test.test', 'a_state') bootstrap.setup_component( hass, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: MASTER_PORT}}) bootstrap.setup_component(hass, 'api') hass.start() master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT) # Start slave slave = remote.HomeAssistant(master_api) bootstrap.setup_component( slave, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SLAVE_PORT}}) slave.start()
def test_home_accessory(self): """Test HomeAccessory class.""" hass = get_test_home_assistant() acc = HomeAccessory(hass, 'Home Accessory', 'homekit.accessory', 2, '') self.assertEqual(acc.hass, hass) self.assertEqual(acc.display_name, 'Home Accessory') self.assertEqual(acc.category, 1) # Category.OTHER self.assertEqual(len(acc.services), 1) serv = acc.services[0] # SERV_ACCESSORY_INFO self.assertEqual( serv.get_characteristic(CHAR_MODEL).value, 'homekit.accessory') hass.states.set('homekit.accessory', 'on') hass.block_till_done() acc.run() hass.states.set('homekit.accessory', 'off') hass.block_till_done() acc = HomeAccessory('hass', 'test_name', 'test_model', 2, '') self.assertEqual(acc.display_name, 'test_name') self.assertEqual(acc.aid, 2) self.assertEqual(len(acc.services), 1) serv = acc.services[0] # SERV_ACCESSORY_INFO self.assertEqual( serv.get_characteristic(CHAR_MODEL).value, 'test_model') hass.stop()
def setUpModule(): # pylint: disable=invalid-name """Initalization of a Home Assistant server and Slave instance.""" global hass, slave, master_api hass = get_test_home_assistant() hass.bus.listen("test_event", lambda _: _) hass.states.set("test.test", "a_state") bootstrap.setup_component( hass, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: MASTER_PORT}} ) bootstrap.setup_component(hass, "api") hass.start() time.sleep(0.05) master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT) # Start slave loop = asyncio.new_event_loop() # FIXME: should not be a daemon threading.Thread(name="SlaveThread", daemon=True, target=loop.run_forever).start() slave = remote.HomeAssistant(master_api, loop=loop) slave.config.config_dir = get_test_config_dir() slave.config.skip_pip = True bootstrap.setup_component( slave, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SLAVE_PORT}} ) with patch.object(ha, "_async_create_timer", return_value=None): slave.start()
def setUp(self): # pylint: disable=invalid-name """ Init needed objects. """ self.hass = get_test_home_assistant() loader.prepare(self.hass) self.known_dev_path = self.hass.config.path( device_tracker.KNOWN_DEVICES_FILE)
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.hass.states.set("light.Bowl", "on") self.hass.states.set("switch.AC", "off") event_decorators.HASS = self.hass
def setUp(self): # pylint: disable=invalid-name """ Init needed objects. """ self.hass = get_test_home_assistant() self.assertTrue(comps.setup(self.hass, {})) self.hass.states.set('light.Bowl', STATE_ON) self.hass.states.set('light.Ceiling', STATE_OFF)
def setUp(self): """Initialize values for this testcase class.""" self.hass = get_test_home_assistant() self.key = 'foo' self.lat = self.hass.config.latitude = 37.8267 self.lon = self.hass.config.longitude = -122.423 self.entities = []
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.hass.config.units = METRIC_SYSTEM self.assertTrue(hvac.setup(self.hass, {'hvac': { 'platform': 'demo', }}))
def setUp(self): # pylint: disable=invalid-name """Set up test variables.""" serial_number = "12345" temperature_unit = "F" thermostat = Mock( serial_number=serial_number, room="Master bathroom", online=True, heating=True, temperature=2222, celsius=22, fahrenheit=72, max_celsius=69, max_fahrenheit=157, min_celsius=5, min_fahrenheit=41, schedule_mode=SCHEDULE_RUN, target_celsius=22, target_fahrenheit=72) thermostat.get_data = Mock() thermostat.resume_schedule = Mock() self.api = Mock() self.api.get_thermostat.return_value = thermostat self.hass = get_test_home_assistant() self.thermostat = nuheat.NuHeatThermostat( self.api, serial_number, temperature_unit)
def setup_method(self, method): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.hass.config.latitude = 32.87336 self.hass.config.longitude = 117.22743 self.port = mock.MagicMock() self.switch = mfi.MfiSwitch(self.port)
def setUp(self): """Init needed objects.""" self.hass = get_test_home_assistant()
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.player = SyncMediaPlayer(self.hass)
def setUp(self): # pylint: disable=invalid-name self.hass = get_test_home_assistant()
def setup_class(cls): """Setup things to be run when tests are started.""" cls.hass = get_test_home_assistant()
def setUp(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant(0) self.hass.config.components = ['rfxtrx']
def setUp(self): # pylint: disable=invalid-name """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.mock_publish = mock_mqtt_component(self.hass)
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.entity = entity.Entity() self.entity.entity_id = 'test.overwrite_hidden_true' self.hass = self.entity.hass = get_test_home_assistant() self.entity.update_ha_state()
def setup_method(self, method): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.mock_storage = mock_storage() self.mock_storage.__enter__()
def setUp(self): """Set up things to run when tests begin.""" self.hass = get_test_home_assistant()
def setup_method(self, _): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() mock_component(self.hass, 'zone')
def setUp(self): """Setup things to be run when tests are started.""" super(TestMochadSwitchSetup, self).setUp() self.hass = get_test_home_assistant()
def setup_method(self, method): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant()
def setUp(self): # pylint: disable=invalid-name """Run when tests are started.""" self.hass = get_test_home_assistant() core_components.setup(self.hass, {})
def setUp(self): # pylint: disable=invalid-name """Initialize a test Home Assistant instance.""" self.hass = get_test_home_assistant()
def setUp(self): """Initialize values for this testcase class.""" self.hass = get_test_home_assistant() self.DEFAULT_TIME_ZONE = dt_util.DEFAULT_TIME_ZONE
def setUp(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant()
def setup_method(self, method): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() mock_http_component(self.hass, 'super_secret')
def setup_method(self, method): """Set up the test.""" self.hass = get_test_home_assistant()
def setUp(self): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.addCleanup(self.tear_down_cleanup)
def setUp(self): """Initialize values for this testcase class.""" self.hass = get_test_home_assistant() self.config = copy.deepcopy(VALID_CONFIG)
def setUp(self): """Initialize values for this testcase class.""" self.DEVICES = [] self.hass = get_test_home_assistant() self.hass.config.time_zone = "America/Los_Angeles" self.addCleanup(self.tear_down_cleanup)
def setUp(self): # pylint: disable=invalid-name """Setup the tests.""" self.hass = get_test_home_assistant()
def setup_method(self, method): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.hass.config.latitude = 32.87336 self.hass.config.longitude = 117.22743
def setUp(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.yaml_devices = self.hass.config.path(device_tracker.YAML_DEVICES)
def setup_method(self, _): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() mock_mqtt_component(self.hass) mock_component(self.hass, 'group') mock_component(self.hass, 'zone') patcher = patch('homeassistant.components.device_tracker.' 'DeviceTracker.async_update_config') patcher.start() self.addCleanup(patcher.stop) orig_context = owntracks.OwnTracksContext def store_context(*args): self.context = orig_context(*args) return self.context with patch('homeassistant.components.device_tracker.async_load_config', return_value=mock_coro([])), \ patch('homeassistant.components.device_tracker.' 'load_yaml_config_file', return_value=mock_coro({})), \ patch.object(owntracks, 'OwnTracksContext', store_context), \ assert_setup_component(1, device_tracker.DOMAIN): assert setup_component(self.hass, device_tracker.DOMAIN, { device_tracker.DOMAIN: { CONF_PLATFORM: 'owntracks', CONF_MAX_GPS_ACCURACY: 200, CONF_WAYPOINT_IMPORT: True, CONF_WAYPOINT_WHITELIST: ['jon', 'greg'] }}) self.hass.states.set( 'zone.inner', 'zoning', { 'name': 'zone', 'latitude': 2.1, 'longitude': 1.1, 'radius': 10 }) self.hass.states.set( 'zone.inner_2', 'zoning', { 'name': 'zone', 'latitude': 2.1, 'longitude': 1.1, 'radius': 10 }) self.hass.states.set( 'zone.outer', 'zoning', { 'name': 'zone', 'latitude': 2.0, 'longitude': 1.0, 'radius': 100000 }) # Clear state between teste self.hass.states.set(DEVICE_TRACKER_STATE, None)
def setUp(self): """Initialize values for this test case class.""" self.hass = get_test_home_assistant()
def setUp(self): # pylint: disable=invalid-name """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.skip_teardown_stop = False
def setUp(self): # pylint: disable=invalid-name """ Init needed objects. """ self.hass = get_test_home_assistant() self.known_dev_path = self.hass.config.path( device_tracker.KNOWN_DEVICES_FILE)
def setUp(self): # pylint: disable=invalid-name """Set up things to be run when tests are started.""" 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 = f"{input_number.DOMAIN}.volume_level" self.hass.states.set(self.mock_volume_id, 0) self.mock_source_list_id = f"{input_select.DOMAIN}.source_list" self.hass.states.set(self.mock_source_list_id, ["dvd", "htpc"]) self.mock_source_id = f"{input_select.DOMAIN}.source" self.hass.states.set(self.mock_source_id, "dvd") self.mock_sound_mode_list_id = f"{input_select.DOMAIN}.sound_mode_list" self.hass.states.set(self.mock_sound_mode_list_id, ["music", "movie"]) self.mock_sound_mode_id = f"{input_select.DOMAIN}.sound_mode" self.hass.states.set(self.mock_sound_mode_id, "music") self.mock_shuffle_switch_id = switch.ENTITY_ID_FORMAT.format("shuffle") self.hass.states.set(self.mock_shuffle_switch_id, STATE_OFF) self.mock_repeat_switch_id = switch.ENTITY_ID_FORMAT.format("repeat") self.hass.states.set(self.mock_repeat_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, "repeat": self.mock_repeat_switch_id, "sound_mode_list": self.mock_sound_mode_list_id, "sound_mode": self.mock_sound_mode_id, }, } self.addCleanup(self.tear_down_cleanup)
def setUp(self): # pylint: disable=invalid-name """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() mock_mqtt_client(self.hass) self.calls = []