def mock_lj(opp): """Initialize components.""" with mock.patch("openpeerpower.components.litejet.LiteJet") as mock_pylitejet: mock_lj = mock_pylitejet.return_value mock_lj.switch_pressed_callbacks = {} mock_lj.switch_released_callbacks = {} def on_switch_pressed(number, callback): mock_lj.switch_pressed_callbacks[number] = callback def on_switch_released(number, callback): mock_lj.switch_released_callbacks[number] = callback mock_lj.loads.return_value = range(0) mock_lj.button_switches.return_value = range(1, 3) mock_lj.all_switches.return_value = range(1, 6) mock_lj.scenes.return_value = range(0) mock_lj.get_switch_name.side_effect = get_switch_name mock_lj.on_switch_pressed.side_effect = on_switch_pressed mock_lj.on_switch_released.side_effect = on_switch_released config = {"litejet": {"port": "/dev/serial/by-id/mock-litejet"}} assert opp.loop.run_until_complete( setup.async_setup_component(opp, litejet.DOMAIN, config) ) mock_lj.start_time = dt_util.utcnow() mock_lj.last_delta = timedelta(0) return mock_lj
def test_invalid_credentials( mock_open, mock_isfile, mock_makedirs, mock_json_dump, mock_json_load, mock_create_session, opp, ): """Test with invalid credentials.""" opp.loop.run_until_complete(async_setup_component(opp, "http", {})) mock_json_load.return_value = {"refresh_token": "bad_token"} async def get_session(*args, **kwargs): """Return the test session.""" raise aioautomatic.exceptions.BadRequestError("err_invalid_refresh_token") mock_create_session.side_effect = get_session config = { "platform": "automatic", "client_id": "client_id", "secret": "client_secret", "devices": None, } opp.loop.run_until_complete(async_setup_scanner(opp, config, None)) assert mock_create_session.called assert len(mock_create_session.mock_calls) == 1 assert mock_create_session.mock_calls[0][1][0] == "bad_token"
def setup_comp(opp): """Initialize components.""" mock_component(opp, "group") opp.config.set_time_zone(opp.config.time_zone) opp.loop.run_until_complete( async_setup_component(opp, sun.DOMAIN, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) )
def demo_camera(opp): """Initialize a demo camera platform.""" opp.loop.run_until_complete( async_setup_component(opp, "camera", {camera.DOMAIN: { "platform": "demo" }})) return opp.data["camera"].get_entity("camera.demo_camera")
def scanner(opp, enable_custom_integrations): """Initialize components.""" scanner = getattr(opp.components, "test.device_tracker").get_scanner(None, None) scanner.reset() scanner.come_home("DEV1") getattr(opp.components, "test.light").init() with patch( "openpeerpower.components.device_tracker.legacy.load_yaml_config_file", return_value={ "device_1": { "mac": "DEV1", "name": "Unnamed Device", "picture": "http://example.com/dev1.jpg", "track": True, "vendor": None, }, "device_2": { "mac": "DEV2", "name": "Unnamed Device", "picture": "http://example.com/dev2.jpg", "track": True, "vendor": None, }, }, ): assert opp.loop.run_until_complete( async_setup_component( opp, device_tracker.DOMAIN, {device_tracker.DOMAIN: { CONF_PLATFORM: "test" }}, )) assert opp.loop.run_until_complete( async_setup_component(opp, light.DOMAIN, {light.DOMAIN: { CONF_PLATFORM: "test" }})) return scanner
def setUp(self): """Set up things to be run when tests are started.""" self.opp = get_test_open_peer_power() assert asyncio.run_coroutine_threadsafe( async_setup_component(self.opp, "openpeerpower", {}), self.opp.loop).result() self.opp.states.set("light.Bowl", STATE_ON) self.opp.states.set("light.Ceiling", STATE_OFF)
async def async_from_config_dict( config: ConfigType, opp: core.OpenPeerPower) -> core.OpenPeerPower | None: """Try to configure Open Peer Power from a configuration dictionary. Dynamically loads required components and its dependencies. This method is a coroutine. """ start = monotonic() opp.config_entries = config_entries.ConfigEntries(opp, config) await opp.config_entries.async_initialize() # Set up core. _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS) if not all(await asyncio.gather(*(async_setup_component(opp, domain, config) for domain in CORE_INTEGRATIONS))): _LOGGER.error("Open Peer Power core failed to initialize. ") return None _LOGGER.debug("Open Peer Power core initialized") core_config = config.get(core.DOMAIN, {}) try: await conf_util.async_process_op_core_config(opp, core_config) except vol.Invalid as config_err: conf_util.async_log_exception(config_err, "openpeerpower", core_config, opp) return None except OpenPeerPowerError: _LOGGER.error("Open Peer Power core failed to initialize. " "Further initialization aborted") return None await _async_set_up_integrations(opp, config) stop = monotonic() _LOGGER.info("Open Peer Power initialized in %.2fs", stop - start) if REQUIRED_NEXT_PYTHON_DATE and sys.version_info[: 3] < REQUIRED_NEXT_PYTHON_VER: msg = ( "Support for the running Python version " f"{'.'.join(str(x) for x in sys.version_info[:3])} is deprecated and will " f"be removed in the first release after {REQUIRED_NEXT_PYTHON_DATE}. " "Please upgrade Python to " f"{'.'.join(str(x) for x in REQUIRED_NEXT_PYTHON_VER)} or " "higher.") _LOGGER.warning(msg) opp.components.persistent_notification.async_create( msg, "Python version", "python_version") return opp
def mock_client(opp, aiohttp_client): """Start the Open Peer Power HTTP component.""" mock_component(opp, "group") mock_component(opp, "zone") mock_component(opp, "device_tracker") MockConfigEntry(domain="owntracks", data={ "webhook_id": "owntracks_test", "secret": "abcd" }).add_to_opp(opp) opp.loop.run_until_complete(async_setup_component(opp, "owntracks", {})) return opp.loop.run_until_complete(aiohttp_client(opp.http.app))
def no_auth_websocket_client(opp, loop, aiohttp_client): """Websocket connection that requires authentication.""" assert loop.run_until_complete(async_setup_component(opp, "websocket_api", {})) client = loop.run_until_complete(aiohttp_client(opp.http.app)) ws = loop.run_until_complete(client.ws_connect(URL)) auth_ok = loop.run_until_complete(ws.receive_json()) assert auth_ok["type"] == TYPE_AUTH_REQUIRED yield ws if not ws.closed: loop.run_until_complete(ws.close())
def setup_zone(opp): """Create test zone.""" opp.loop.run_until_complete( async_setup_component( opp, zone.DOMAIN, { "zone": { "name": "test", "latitude": HOME_LATITUDE, "longitude": HOME_LONGITUDE, "radius": 250, } }, ))
def storage_setup(opp, opp_storage, opp_admin_user): """Storage setup.""" opp_storage[DOMAIN] = { "key": DOMAIN, "version": 1, "data": { "persons": [{ "id": "1234", "name": "tracked person", "user_id": opp_admin_user.id, "device_trackers": [DEVICE_TRACKER], }] }, } assert opp.loop.run_until_complete(async_setup_component(opp, DOMAIN, {}))
def setup_comp(opp): """Initialize components.""" mock_component(opp, "group") opp.loop.run_until_complete( async_setup_component( opp, zone.DOMAIN, { "zone": { "name": "test", "latitude": 32.880837, "longitude": -117.237561, "radius": 250, } }, ))
def setup_duckdns(opp, aioclient_mock): """Fixture that sets up DuckDNS.""" aioclient_mock.get(duckdns.UPDATE_URL, params={ "domains": DOMAIN, "token": TOKEN }, text="OK") opp.loop.run_until_complete( async_setup_component( opp, duckdns.DOMAIN, {"duckdns": { "domain": DOMAIN, "access_token": TOKEN }}))
def mock_client(opp, opp_client): """Start the Open Peer Power HTTP component.""" with patch("openpeerpower.components.spaceapi", return_value=mock_coro(True)): opp.loop.run_until_complete(async_setup_component(opp, "spaceapi", CONFIG)) opp.states.async_set( "test.temp1", 25, attributes={ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} ) opp.states.async_set( "test.temp2", 23, attributes={ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} ) opp.states.async_set( "test.hum1", 88, attributes={ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} ) return opp.loop.run_until_complete(opp_client())
def oppio_stubs(oppio_env, opp, opp_client, aioclient_mock): """Create mock oppio http client.""" with patch( "openpeerpower.components.oppio.OppIO.update_opp_api", return_value={"result": "ok"}, ) as opp_api, patch( "openpeerpower.components.oppio.OppIO.update_opp_timezone", return_value={"result": "ok"}, ), patch( "openpeerpower.components.oppio.OppIO.get_info", side_effect=OppioAPIError(), ): opp.state = CoreState.starting opp.loop.run_until_complete(async_setup_component(opp, "oppio", {})) return opp_api.call_args[0][1]
def setup_no_ip(opp, aioclient_mock): """Fixture that sets up NO-IP.""" aioclient_mock.get(UPDATE_URL, params={"hostname": DOMAIN}, text="good 0.0.0.0") opp.loop.run_until_complete( async_setup_component( opp, no_ip.DOMAIN, { no_ip.DOMAIN: { "domain": DOMAIN, "username": USERNAME, "password": PASSWORD, } }, ) )
def mock_google_setup(opp, test_calendar): """Mock the google set up functions.""" opp.loop.run_until_complete( async_setup_component(opp, "group", {"group": {}})) calendar = get_calendar_info(test_calendar) calendars = {calendar[CONF_CAL_ID]: calendar} patch_google_auth = patch( "openpeerpower.components.google.do_authentication", side_effect=do_setup) patch_google_load = patch("openpeerpower.components.google.load_config", return_value=calendars) patch_google_services = patch( "openpeerpower.components.google.setup_services") async_mock_service(opp, "google", SERVICE_SCAN_CALENDARS) with patch_google_auth, patch_google_load, patch_google_services: yield
def camera_client_fixture(opp, opp_client): """Fixture to fetch camera streams.""" assert opp.loop.run_until_complete( async_setup_component( opp, "camera", { "camera": { "name": "config_test", "platform": "mjpeg", "mjpeg_url": "http://example.com/mjpeg_stream", } }, )) opp.loop.run_until_complete(opp.async_block_till_done()) yield opp.loop.run_until_complete(opp_client())
def setup_google_domains(opp, aioclient_mock): """Fixture that sets up NamecheapDNS.""" aioclient_mock.get(UPDATE_URL, params={"hostname": DOMAIN}, text="ok 0.0.0.0") opp.loop.run_until_complete( async_setup_component( opp, google_domains.DOMAIN, { "google_domains": { "domain": DOMAIN, "username": USERNAME, "password": PASSWORD, } }, ))
def mock_http_client(loop, opp, opp_client): """Set up test fixture.""" config = { "rss_feed_template": { "testfeed": { "title": "feed title is {{states.test.test1.state}}", "items": [{ "title": "item title is {{states.test.test2.state}}", "description": "desc {{states.test.test3.state}}", }], } } } loop.run_until_complete( async_setup_component(opp, "rss_feed_template", config)) return loop.run_until_complete(opp_client())
def setup_freedns(opp, aioclient_mock): """Fixture that sets up FreeDNS.""" params = {} params[ACCESS_TOKEN] = "" aioclient_mock.get( UPDATE_URL, params=params, text="Successfully updated 1 domains." ) opp.loop.run_until_complete( async_setup_component( opp, freedns.DOMAIN, { freedns.DOMAIN: { "access_token": ACCESS_TOKEN, "scan_interval": UPDATE_INTERVAL, } }, ) )
def assistant_client(loop, opp, aiohttp_client): """Create web client for the Google Assistant API.""" loop.run_until_complete( setup.async_setup_component( opp, "google_assistant", { "google_assistant": { "project_id": PROJECT_ID, "entity_config": { "light.ceiling_lights": { "aliases": ["top lights", "ceiling lights"], "name": "Roof Lights", } }, } }, )) return loop.run_until_complete(aiohttp_client(opp.http.app))
def test_all_work_done_before_start(self): """Test all init work done till start.""" call_order = [] async def component1_setup(opp, config): """Set up mock component.""" await discovery.async_discover(opp, "test_component2", {}, "test_component2", {}) await discovery.async_discover(opp, "test_component3", {}, "test_component3", {}) return True def component_track_setup(opp, config): """Set up mock component.""" call_order.append(1) return True mock_integration( self.opp, MockModule("test_component1", async_setup=component1_setup)) mock_integration( self.opp, MockModule("test_component2", setup=component_track_setup)) mock_integration( self.opp, MockModule("test_component3", setup=component_track_setup)) @callback def track_start(event): """Track start event.""" call_order.append(2) self.opp.bus.listen_once(EVENT_OPENPEERPOWER_START, track_start) self.opp.add_job( setup.async_setup_component(self.opp, "test_component1", {})) self.opp.block_till_done() self.opp.start() assert call_order == [1, 1, 2]
def alexa_client(loop, opp, opp_client): """Initialize a Open Peer Power server for testing this module.""" @callback def mock_service(call): calls.append(call) opp.services.async_register("test", "alexa", mock_service) assert loop.run_until_complete( async_setup_component( opp, alexa.DOMAIN, { # Key is here to verify we allow other keys in config too "openpeerpower": {}, "alexa": { "flash_briefings": { "password": "******", "weather": [ { "title": "Weekly forecast", "text": "This week it will be sunny.", }, { "title": "Current conditions", "text": "Currently it is 80 degrees fahrenheit.", }, ], "news_audio": { "title": "NPR", "audio": NPR_NEWS_MP3_URL, "display_url": "https://npr.org", "uid": "uuid", }, } }, }, ) ) return loop.run_until_complete(opp_client())
async def async_setup_multi_components( opp: core.OpenPeerPower, domains: set[str], config: dict[str, Any], ) -> None: """Set up multiple domains. Log on failure.""" futures = { domain: opp.async_create_task(async_setup_component(opp, domain, config)) for domain in domains } await asyncio.wait(futures.values()) errors = [domain for domain in domains if futures[domain].exception()] for domain in errors: exception = futures[domain].exception() assert exception is not None _LOGGER.error( "Error setting up integration %s - received exception", domain, exc_info=(type(exception), exception, exception.__traceback__), )
def opp_fixture(loop, opp): """Set up a Open Peer Power instance for these tests.""" # We need to do this to get access to openpeerpower/turn_(on,off) loop.run_until_complete(setup.async_setup_component(opp, core.DOMAIN, {})) loop.run_until_complete( setup.async_setup_component(opp, light.DOMAIN, {"light": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, switch.DOMAIN, {"switch": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, cover.DOMAIN, {"cover": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, media_player.DOMAIN, {"media_player": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, fan.DOMAIN, {"fan": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, climate.DOMAIN, {"climate": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, humidifier.DOMAIN, {"humidifier": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component(opp, lock.DOMAIN, {"lock": [{ "platform": "demo" }]})) loop.run_until_complete( setup.async_setup_component( opp, alarm_control_panel.DOMAIN, {"alarm_control_panel": [{ "platform": "demo" }]}, )) return opp
def setup_comp(opp): """Set up demo component.""" opp.loop.run_until_complete( async_setup_component(opp, light.DOMAIN, {"light": {"platform": "demo"}}) )
def alexa_client(loop, opp, opp_client): """Initialize a Open Peer Power server for testing this module.""" @callback def mock_service(call): calls.append(call) opp.services.async_register("test", "alexa", mock_service) assert loop.run_until_complete( async_setup_component( opp, alexa.DOMAIN, { # Key is here to verify we allow other keys in config too "openpeerpower": {}, "alexa": {}, }, )) assert loop.run_until_complete( async_setup_component( opp, "intent_script", { "intent_script": { "WhereAreWeIntent": { "speech": { "type": "plain", "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": "plain", "text": "You told us your sign is {{ ZodiacSign }}.", } }, "AMAZON.PlaybackAction<object@MusicCreativeWork>": { "speech": { "type": "plain", "text": "Playing {{ object_byArtist_name }}.", } }, "CallServiceIntent": { "speech": { "type": "plain", "text": "Service called for {{ ZodiacSign }}", }, "card": { "type": "simple", "title": "Card title for {{ ZodiacSign }}", "content": "Card content: {{ ZodiacSign }}", }, "action": { "service": "test.alexa", "data_template": { "hello": "{{ ZodiacSign }}" }, "entity_id": "switch.test", }, }, APPLICATION_ID: { "speech": { "type": "plain", "text": "LaunchRequest has been received.", } }, } }, )) return loop.run_until_complete(opp_client())
def test_valid_credentials( mock_open, mock_isfile, mock_makedirs, mock_json_dump, mock_json_load, mock_ws_connect, mock_create_session, opp, ): """Test with valid credentials.""" opp.loop.run_until_complete(async_setup_component(opp, "http", {})) mock_json_load.return_value = {"refresh_token": "good_token"} session = MagicMock() vehicle = MagicMock() trip = MagicMock() mock_see = MagicMock() vehicle.id = "mock_id" vehicle.display_name = "mock_display_name" vehicle.fuel_level_percent = 45.6 vehicle.latest_location = None vehicle.updated_at = datetime(2017, 8, 13, 1, 2, 3) trip.end_location.lat = 45.567 trip.end_location.lon = 34.345 trip.end_location.accuracy_m = 5.6 trip.ended_at = datetime(2017, 8, 13, 1, 2, 4) async def get_session(*args, **kwargs): """Return the test session.""" return session async def get_vehicles(*args, **kwargs): """Return list of test vehicles.""" return [vehicle] async def get_trips(*args, **kwargs): """Return list of test trips.""" return [trip] mock_create_session.side_effect = get_session session.ws_connect = MagicMock() session.get_vehicles.side_effect = get_vehicles session.get_trips.side_effect = get_trips session.refresh_token = "mock_refresh_token" config = { "platform": "automatic", "username": "******", "password": "******", "client_id": "client_id", "secret": "client_secret", "devices": None, } result = opp.loop.run_until_complete(async_setup_scanner(opp, config, mock_see)) assert result assert mock_ws_connect.called assert len(mock_ws_connect.mock_calls) == 2 assert mock_create_session.called assert len(mock_create_session.mock_calls) == 1 assert mock_create_session.mock_calls[0][1][0] == "good_token" assert mock_see.called assert len(mock_see.mock_calls) == 2 assert mock_see.mock_calls[0][2]["dev_id"] == "mock_id" assert mock_see.mock_calls[0][2]["mac"] == "mock_id" assert mock_see.mock_calls[0][2]["host_name"] == "mock_display_name" assert mock_see.mock_calls[0][2]["attributes"] == {"fuel_level": 45.6} assert mock_see.mock_calls[0][2]["gps"] == (45.567, 34.345) assert mock_see.mock_calls[0][2]["gps_accuracy"] == 5.6 assert mock_json_dump.called assert len(mock_json_dump.mock_calls) == 1 assert mock_json_dump.mock_calls[0][1][0] == {"refresh_token": "mock_refresh_token"}
async def _async_set_up_integrations( opp: core.OpenPeerPower, config: Dict[str, Any] ) -> None: """Set up all the integrations.""" domains = _get_domains(opp, config) # Start up debuggers. Start these first in case they want to wait. debuggers = domains & DEBUGGER_INTEGRATIONS if debuggers: _LOGGER.debug("Starting up debuggers %s", debuggers) await asyncio.gather( *(async_setup_component(opp, domain, config) for domain in debuggers) ) domains -= DEBUGGER_INTEGRATIONS # Resolve all dependencies of all components so we can find the logging # and integrations that need faster initialization. resolved_domains_task = asyncio.gather( *(loader.async_component_dependencies(opp, domain) for domain in domains), return_exceptions=True, ) # Finish resolving domains for dep_domains in await resolved_domains_task: # Result is either a set or an exception. We ignore exceptions # It will be properly handled during setup of the domain. if isinstance(dep_domains, set): domains.update(dep_domains) # setup components logging_domains = domains & LOGGING_INTEGRATIONS stage_1_domains = domains & STAGE_1_INTEGRATIONS stage_2_domains = domains - logging_domains - stage_1_domains if logging_domains: _LOGGER.info("Setting up %s", logging_domains) await asyncio.gather( *(async_setup_component(opp, domain, config) for domain in logging_domains) ) # Kick off loading the registries. They don't need to be awaited. asyncio.gather( opp.helpers.device_registry.async_get_registry(), opp.helpers.entity_registry.async_get_registry(), opp.helpers.area_registry.async_get_registry(), ) if stage_1_domains: await asyncio.gather( *(async_setup_component(opp, domain, config) for domain in stage_1_domains) ) # Load all integrations after_dependencies: Dict[str, Set[str]] = {} for int_or_exc in await asyncio.gather( *(loader.async_get_integration(opp, domain) for domain in stage_2_domains), return_exceptions=True, ): # Exceptions are handled in async_setup_component. if isinstance(int_or_exc, loader.Integration) and int_or_exc.after_dependencies: after_dependencies[int_or_exc.domain] = set(int_or_exc.after_dependencies) last_load = None while stage_2_domains: domains_to_load = set() for domain in stage_2_domains: after_deps = after_dependencies.get(domain) # Load if integration has no after_dependencies or they are # all loaded if not after_deps or not after_deps - opp.config.components: domains_to_load.add(domain) if not domains_to_load or domains_to_load == last_load: break _LOGGER.debug("Setting up %s", domains_to_load) await asyncio.gather( *(async_setup_component(opp, domain, config) for domain in domains_to_load) ) last_load = domains_to_load stage_2_domains -= domains_to_load # These are stage 2 domains that never have their after_dependencies # satisfied. if stage_2_domains: _LOGGER.debug("Final set up: %s", stage_2_domains) await asyncio.gather( *(async_setup_component(opp, domain, config) for domain in stage_2_domains) ) # Wrap up startup await opp.async_block_till_done()