def test_get_image_without_exists_camera(self): """Try to get image without exists camera.""" self.hass.states.remove('camera.demo_camera') with pytest.raises(HomeAssistantError): run_coroutine_threadsafe(camera.async_get_image( self.hass, 'camera.demo_camera'), self.hass.loop).result()
def test_async_add_job_pending_tasks_callback(self): """Run a callback in pending tasks.""" call_count = [] @ha.callback def test_callback(): """Test callback.""" call_count.append('call') @asyncio.coroutine def wait_finish_callback(): """Wait until all stuff is scheduled.""" yield from asyncio.sleep(0, loop=self.hass.loop) yield from asyncio.sleep(0, loop=self.hass.loop) for i in range(2): self.hass.add_job(test_callback) run_coroutine_threadsafe( wait_finish_callback(), self.hass.loop).result() self.hass.block_till_done() assert len(self.hass._pending_tasks) == 0 assert len(call_count) == 2
def test_scan_devices_parse_error(self, aioclient_mock): """Setup a upc platform and scan device with parse error.""" aioclient_mock.get( "http://{}/common_page/login.html".format(self.host), cookies={'sessionToken': '654321'} ) aioclient_mock.post( "http://{}/xml/getter.xml".format(self.host), content=b'successful', cookies={'sessionToken': '654321'} ) scanner = run_coroutine_threadsafe(platform.async_get_scanner( self.hass, {DOMAIN: { CONF_PLATFORM: 'upc_connect', CONF_HOST: self.host }} ), self.hass.loop).result() assert len(aioclient_mock.mock_calls) == 1 aioclient_mock.clear_requests() aioclient_mock.post( "http://{}/xml/getter.xml".format(self.host), text="Blablebla blabalble", cookies={'sessionToken': '1235678'} ) mac_list = run_coroutine_threadsafe( scanner.async_scan_devices(), self.hass.loop).result() assert len(aioclient_mock.mock_calls) == 1 assert aioclient_mock.mock_calls[0][2] == 'token=654321&fun=123' assert scanner.token is None assert mac_list == []
def test_scan_devices(self, aioclient_mock): """Setup a upc platform and scan device.""" aioclient_mock.get( "http://{}/common_page/login.html".format(self.host), cookies={'sessionToken': '654321'} ) aioclient_mock.post( "http://{}/xml/getter.xml".format(self.host), content=b'successful', cookies={'sessionToken': '654321'} ) scanner = run_coroutine_threadsafe(platform.async_get_scanner( self.hass, {DOMAIN: { CONF_PLATFORM: 'upc_connect', CONF_HOST: self.host }} ), self.hass.loop).result() assert len(aioclient_mock.mock_calls) == 1 aioclient_mock.clear_requests() aioclient_mock.post( "http://{}/xml/getter.xml".format(self.host), text=load_fixture('upc_connect.xml'), cookies={'sessionToken': '1235678'} ) mac_list = run_coroutine_threadsafe( scanner.async_scan_devices(), self.hass.loop).result() assert len(aioclient_mock.mock_calls) == 1 assert aioclient_mock.mock_calls[0][2] == 'token=654321&fun=123' assert mac_list == ['30:D3:2D:0:69:21', '5C:AA:FD:25:32:02', '70:EE:50:27:A1:38']
def test_update_when_off(self, aioclient_mock): """Test update when switch is off.""" aioclient_mock.get(self.resource, text=self.body_off.template) run_coroutine_threadsafe( self.switch.async_update(), self.hass.loop).result() assert not self.switch.is_on
def start(hass, server_config): """Initialize MQTT Server.""" from hbmqtt.broker import Broker, BrokerException try: passwd = tempfile.NamedTemporaryFile() if server_config is None: server_config, client_config = generate_config(hass, passwd) else: client_config = None broker = Broker(server_config, hass.loop) run_coroutine_threadsafe(broker.start(), hass.loop).result() except BrokerException: logging.getLogger(__name__).exception('Error initializing MQTT server') return False, None finally: passwd.close() @callback def shutdown_mqtt_server(event): """Shut down the MQTT server.""" hass.async_add_job(broker.shutdown()) hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, shutdown_mqtt_server) return True, client_config
def test_supported_features_children_and_cmds(self): """Test supported media commands with children and attrs.""" 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)
def test_turn_on_timeout(self, aioclient_mock): """Test turn_on when timeout occurs.""" aioclient_mock.post(self.resource, status=500) run_coroutine_threadsafe( self.switch.async_turn_on(), self.hass.loop).result() assert self.switch.is_on is None
def test_platform_setup(self): """Test platform setup.""" 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) setup_ok = True try: run_coroutine_threadsafe( universal.async_setup_platform( self.hass, validate_config(bad_config), add_devices), self.hass.loop).result() except MultipleInvalid: setup_ok = False self.assertFalse(setup_ok) self.assertEqual(0, len(entities)) run_coroutine_threadsafe( universal.async_setup_platform( self.hass, validate_config(config), add_devices), self.hass.loop).result() self.assertEqual(1, len(entities)) self.assertEqual('test', entities[0].name)
def test_loading_configuration_from_packages(self): """Test loading packages config onto hass object config.""" self.hass.config = mock.Mock() run_coroutine_threadsafe( config_util.async_process_ha_core_config(self.hass, { 'latitude': 39, 'longitude': -1, 'elevation': 500, 'name': 'Huis', CONF_TEMPERATURE_UNIT: 'C', 'time_zone': 'Europe/Madrid', 'packages': { 'package_1': {'wake_on_lan': None}, 'package_2': {'light': {'platform': 'hue'}, 'media_extractor': None, 'sun': None}}, }), self.hass.loop).result() # Empty packages not allowed with pytest.raises(MultipleInvalid): run_coroutine_threadsafe( config_util.async_process_ha_core_config(self.hass, { 'latitude': 39, 'longitude': -1, 'elevation': 500, 'name': 'Huis', CONF_TEMPERATURE_UNIT: 'C', 'time_zone': 'Europe/Madrid', 'packages': {'empty_package': None}, }), self.hass.loop).result()
def test_update_when_unknown(self, aioclient_mock): """Test update when unknown status returned.""" aioclient_mock.get(self.resource, text='unknown status') run_coroutine_threadsafe( self.switch.async_update(), self.hass.loop).result() assert self.switch.is_on is None
def test_update_timeout(self, aioclient_mock): """Test update when timeout occurs.""" aioclient_mock.get(self.resource, exc=asyncio.TimeoutError()) run_coroutine_threadsafe( self.switch.async_update(), self.hass.loop).result() assert self.switch.is_on is None
def test_volume_down(self): """Test the volume_down helper function.""" self.assertEqual(self.player.volume_level, 0) self.player.set_volume_level(0.5) self.assertEqual(self.player.volume_level, 0.5) run_coroutine_threadsafe( self.player.async_volume_down(), self.hass.loop).result() self.assertEqual(self.player.volume_level, 0.3)
def test_get_image_with_timeout(self, aioclient_mock): """Try to get image with timeout.""" aioclient_mock.get(self.url, exc=asyncio.TimeoutError()) with pytest.raises(HomeAssistantError): run_coroutine_threadsafe(camera.async_get_image( self.hass, 'camera.demo_camera'), self.hass.loop).result() assert len(aioclient_mock.mock_calls) == 1
def add_entities(self, new_entities, update_before_add=False): """Add entities for a single platform.""" if update_before_add: for entity in new_entities: entity.update() run_coroutine_threadsafe( self.async_add_entities(list(new_entities), False), self.component.hass.loop).result()
def test_get_image_with_bad_http_state(self, aioclient_mock): """Try to get image with bad http status.""" aioclient_mock.get(self.url, status=400) with pytest.raises(HomeAssistantError): run_coroutine_threadsafe(camera.async_get_image( self.hass, 'camera.demo_camera'), self.hass.loop).result() assert len(aioclient_mock.mock_calls) == 1
def setup(self, config): """Set up a full entity component. Loads the platforms from the config and will listen for supported discovered platforms. """ run_coroutine_threadsafe( self.async_setup(config), self.hass.loop ).result()
def test_turn_off_success(self, aioclient_mock): """Test turn_off.""" aioclient_mock.post(self.resource, status=200) run_coroutine_threadsafe( self.switch.async_turn_off(), self.hass.loop).result() assert self.body_off.template == \ aioclient_mock.mock_calls[-1][2].decode() assert not self.switch.is_on
def test_turn_off_status_not_ok(self, aioclient_mock): """Test turn_off when error status returned.""" aioclient_mock.post(self.resource, status=500) run_coroutine_threadsafe( self.switch.async_turn_off(), self.hass.loop).result() assert self.body_off.template == \ aioclient_mock.mock_calls[-1][2].decode() assert self.switch.is_on is None
def test_circular_import(self): """Test we don't break doing circular import. This test will have test_component discover the switch.test_circular component while setting up. The supplied config will load test_component and will load switch.test_circular. That means that after startup, we will have test_component and switch setup. The test_circular platform has been loaded twice. """ component_calls = [] platform_calls = [] def component_setup(hass, config): """Setup mock component.""" discovery.load_platform(hass, 'switch', 'test_circular', 'disc', config) component_calls.append(1) return True def setup_platform(hass, config, add_devices_callback, discovery_info=None): """Setup mock platform.""" platform_calls.append('disc' if discovery_info else 'component') loader.set_component( 'test_component', MockModule('test_component', setup=component_setup)) loader.set_component( 'switch.test_circular', MockPlatform(setup_platform, dependencies=['test_component'])) bootstrap.setup_component(self.hass, 'test_component', { 'test_component': None, 'switch': [{ 'platform': 'test_circular', }], }) # We wait for the setup_lock to finish run_coroutine_threadsafe( self.hass.data['setup_lock'].acquire(), self.hass.loop).result() self.hass.block_till_done() # test_component will only be setup once assert len(component_calls) == 1 # The platform will be setup once via the config in `setup_component` # and once via the discovery inside test_component. assert len(platform_calls) == 2 assert 'test_component' in self.hass.config.components assert 'switch' in self.hass.config.components
def add_entities(self, new_entities, update_before_add=False): """Add entities for a single platform.""" # That avoid deadlocks if update_before_add: self.component.logger.warning( "Call 'add_entities' with update_before_add=True " "only inside tests or you can run into a deadlock!") run_coroutine_threadsafe( self.async_add_entities(list(new_entities), update_before_add), self.component.hass.loop).result()
def update_ha_state(self, force_refresh=False): """Update Home Assistant with current state of entity. If force_refresh == True will update entity before setting state. """ # We're already in a thread, do the force refresh here. if force_refresh and not hasattr(self, "async_update"): self.update() force_refresh = False run_coroutine_threadsafe(self.async_update_ha_state(force_refresh), self.hass.loop).result()
def update(self): """Retrieve latest state. When not implemented, will forward call to async version if available. """ async_update = getattr(self, 'async_update', None) if async_update is None: return run_coroutine_threadsafe(async_update(), self.hass.loop).result()
def _compute_state(self, config): run_coroutine_threadsafe( config_util.async_process_ha_core_config(self.hass, config), self.hass.loop).result() entity = Entity() entity.entity_id = 'test.test' entity.hass = self.hass entity.schedule_update_ha_state() self.hass.block_till_done() return self.hass.states.get('test.test')
def test_active_child_state(self): """Test active child state property.""" 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)
def test_check_ha_config_file_wrong(self, mock_create): """Check that restart with a bad config doesn't propagate to stop.""" process_mock = mock.MagicMock() attrs = { 'communicate.return_value': mock_generator((r'\033[hellom'.encode('utf-8'), 'error')), 'wait.return_value': mock_generator(1)} process_mock.configure_mock(**attrs) mock_create.return_value = mock_generator(process_mock) with self.assertRaises(HomeAssistantError): run_coroutine_threadsafe( config_util.async_check_ha_config_file(self.hass), self.hass.loop ).result()
def test_mac_vendor_lookup_unknown(self): """Prevent another mac vendor lookup if was not found first time.""" mac = 'B8:27:EB:00:00:00' device = device_tracker.Device( self.hass, timedelta(seconds=180), True, 'test', mac, 'Test name') with mock_aiohttp_client() as aioclient_mock: aioclient_mock.get('http://api.macvendors.com/b8:27:eb', status=404) run_coroutine_threadsafe(device.set_vendor_for_mac(), self.hass.loop).result() self.assertEqual(device.vendor, 'unknown')
def test_state_children_only(self): """Test media player state with only children.""" config = validate_config(self.config_children_only) 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)
def test_mac_vendor_lookup_exception(self): """Prevent another lookup if exception during API call.""" mac = 'B8:27:EB:00:00:00' device = device_tracker.Device( self.hass, timedelta(seconds=180), True, 'test', mac, 'Test name') with mock_aiohttp_client() as aioclient_mock: aioclient_mock.get('http://api.macvendors.com/b8:27:eb', exc=asyncio.TimeoutError()) run_coroutine_threadsafe(device.set_vendor_for_mac(), self.hass.loop).result() self.assertEqual(device.vendor, 'unknown')
def create_group(hass, name, entity_ids=None, user_defined=True, icon=None, view=False, control=None, object_id=None): """Initialize a group.""" return run_coroutine_threadsafe( Group.async_create_group(hass, name, entity_ids, user_defined, icon, view, control, object_id), hass.loop).result()
def run(self, variables=None): """Run script.""" run_coroutine_threadsafe(self.async_run(variables), self.hass.loop).result()
def turn_off(self, **kwargs) -> None: """Turn the entity off.""" run_coroutine_threadsafe(self.async_turn_off(**kwargs), self.hass.loop).result()
def setUpClass(cls): """Setup the class.""" cls.hass = hass = get_test_home_assistant() # We need to do this to get access to homeassistant/turn_(on,off) run_coroutine_threadsafe( core_components.async_setup(hass, {core.DOMAIN: {}}), hass.loop).result() bootstrap.setup_component( hass, http.DOMAIN, {http.DOMAIN: { http.CONF_SERVER_PORT: HTTP_SERVER_PORT }}) with patch('homeassistant.components' '.emulated_hue.UPNPResponderThread'): bootstrap.setup_component( hass, emulated_hue.DOMAIN, { emulated_hue.DOMAIN: { emulated_hue.CONF_LISTEN_PORT: BRIDGE_SERVER_PORT, emulated_hue.CONF_EXPOSE_BY_DEFAULT: True } }) bootstrap.setup_component(cls.hass, light.DOMAIN, {'light': [{ 'platform': 'demo', }]}) bootstrap.setup_component( cls.hass, script.DOMAIN, { 'script': { 'set_kitchen_light': { 'sequence': [{ 'service_template': "light.turn_{{ requested_state }}", 'data_template': { 'entity_id': 'light.kitchen_lights', 'brightness': "{{ requested_level }}" } }] } } }) bootstrap.setup_component(cls.hass, media_player.DOMAIN, {'media_player': [{ 'platform': 'demo', }]}) cls.hass.start() # Kitchen light is explicitly excluded from being exposed kitchen_light_entity = cls.hass.states.get('light.kitchen_lights') attrs = dict(kitchen_light_entity.attributes) attrs[emulated_hue.ATTR_EMULATED_HUE] = False cls.hass.states.set(kitchen_light_entity.entity_id, kitchen_light_entity.state, attributes=attrs) # Expose the script script_entity = cls.hass.states.get('script.set_kitchen_light') attrs = dict(script_entity.attributes) attrs[emulated_hue.ATTR_EMULATED_HUE] = True cls.hass.states.set(script_entity.entity_id, script_entity.state, attributes=attrs)
def test_service_call_to_child(self): """Test service calls that should be routed to a child.""" config = validate_config(self.config_children_only) 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']))
def add_entity(self, entity, platform=None, update_before_add=False): """Add entity to component.""" return run_coroutine_threadsafe( self.async_add_entity(entity, platform, update_before_add), self.hass.loop ).result()
def stop(self) -> None: """Stop Home Assistant and shuts down all threads.""" run_coroutine_threadsafe(self.async_stop(), self.loop)
def update_tracked_entity_ids(self, entity_ids): """Update the member entity IDs.""" run_coroutine_threadsafe( self.async_update_tracked_entity_ids(entity_ids), self.hass.loop).result()
def stop(self): """Unregister the group from Home Assistant.""" run_coroutine_threadsafe(self.async_stop(), self.hass.loop).result()
def camera_image(self): """Return bytes of camera image.""" return run_coroutine_threadsafe(self.async_camera_image(), self.hass.loop).result()
def preload_media_image_url(self, url): """Preload and cache a media image for future use.""" run_coroutine_threadsafe(_async_fetch_image(self.hass, url), self.hass.loop).result()
def load_config(path: str, hass: HomeAssistantType, consider_home: timedelta): """Load devices from YAML configuration file.""" return run_coroutine_threadsafe( async_load_config(path, hass, consider_home), hass.loop).result()
def call_from_config(hass, config, blocking=False, variables=None, validate_config=True): """Call a service based on a config hash.""" run_coroutine_threadsafe( async_call_from_config(hass, config, blocking, variables, validate_config), hass.loop).result()
def reset(self): """Remove entities and reset the entity component to initial values.""" run_coroutine_threadsafe(self.async_reset(), self.hass.loop).result()
def test_setup_missing_config(self): """Test setup with configuration missing required entries.""" assert not run_coroutine_threadsafe( rest.async_setup_platform(self.hass, {'platform': 'rest'}, None), self.hass.loop).result()
def threadsafe(*args, **kwargs): """Call func threadsafe.""" hass = args[0] return run_coroutine_threadsafe(func(*args, **kwargs), hass.loop).result()
def start_hass(*mocks): """Helper to start hass.""" run_coroutine_threadsafe(hass.async_start(), loop=hass.loop).result()
def reproduce_state(hass, states, blocking=False): """Reproduce given state.""" return run_coroutine_threadsafe( async_reproduce_state(hass, states, blocking), hass.loop).result()
def setup_component(hass: core.HomeAssistant, domain: str, config: Optional[Dict]=None) -> bool: """Set up a component and all its dependencies.""" return run_coroutine_threadsafe( async_setup_component(hass, domain, config), loop=hass.loop).result()
def prepare_setup_component(hass: core.HomeAssistant, config: dict, domain: str): """Prepare setup of a component and return processed config.""" return run_coroutine_threadsafe( async_prepare_setup_component(hass, config, domain), loop=hass.loop ).result()
def block_till_done(self) -> None: """Block till all pending work is done.""" run_coroutine_threadsafe(self.async_block_till_done(), loop=self.loop).result()
def prepare_setup_platform(hass: core.HomeAssistant, config, domain: str, platform_name: str) -> Optional[ModuleType]: """Load a platform and makes sure dependencies are setup.""" return run_coroutine_threadsafe(async_prepare_setup_platform( hass, config, domain, platform_name), loop=hass.loop).result()
def prepare_reload(self): """Prepare reloading this entity component.""" return run_coroutine_threadsafe( self.async_prepare_reload(), loop=self.hass.loop).result()
def remove(self) -> None: """Remove entity from HASS.""" run_coroutine_threadsafe(self.async_remove(), self.hass.loop).result()
def setUp(self): # pylint: disable=invalid-name """Run when tests are started.""" self.hass = get_test_home_assistant() run_coroutine_threadsafe(core_components.async_setup( self.hass, {}), self.hass.loop).result()