async def test_abort_if_oauth_error( hass, flow_handler, local_impl, hass_client_no_auth, aioclient_mock, current_request_with_host, ): """Check bad oauth token.""" flow_handler.async_register_implementation(hass, local_impl) config_entry_oauth2_flow.async_register_implementation( hass, TEST_DOMAIN, MockOAuth2Implementation()) result = await hass.config_entries.flow.async_init( TEST_DOMAIN, context={"source": config_entries.SOURCE_USER}) assert result["type"] == data_entry_flow.RESULT_TYPE_FORM assert result["step_id"] == "pick_implementation" # Pick implementation result = await hass.config_entries.flow.async_configure( result["flow_id"], user_input={"implementation": TEST_DOMAIN}) state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) assert result["type"] == data_entry_flow.RESULT_TYPE_EXTERNAL_STEP assert result["url"] == ( f"{AUTHORIZE_URL}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope=read+write") client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( TOKEN_URL, json={ "refresh_token": REFRESH_TOKEN, "access_token": ACCESS_TOKEN_1, "type": "bearer", "expires_in": "badnumber", }, ) result = await hass.config_entries.flow.async_configure(result["flow_id"]) assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result["reason"] == "oauth_error"
async def test_full_flow(hass, aiohttp_client, aioclient_mock): """Check full flow.""" assert await setup.async_setup_component( hass, DOMAIN, { DOMAIN: { "type": "oauth2", CONF_CLIENT_ID: CLIENT_ID_VALUE, CONF_CLIENT_SECRET: CLIENT_SECRET_VALUE, }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, {"flow_id": result["flow_id"]}) assert result["type"] == data_entry_flow.RESULT_TYPE_EXTERNAL_STEP assert result["url"] == ( "https://almond.stanford.edu/me/api/oauth2/authorize" f"?response_type=code&client_id={CLIENT_ID_VALUE}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope=profile+user-read+user-read-results+user-exec-command" ) client = await aiohttp_client(hass.http.app) resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( "https://almond.stanford.edu/me/api/oauth2/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.almond.async_setup_entry", return_value=True) as mock_setup: result = await hass.config_entries.flow.async_configure( result["flow_id"]) assert len(mock_setup.mock_calls) == 1 assert len(hass.config_entries.async_entries(DOMAIN)) == 1 entry = hass.config_entries.async_entries(DOMAIN)[0] assert entry.data["type"] == "oauth2" assert entry.data["host"] == "https://almond.stanford.edu/me"
async def test_full_flow(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Check full flow.""" assert await setup.async_setup_component( hass, "home_connect", { "home_connect": { CONF_CLIENT_ID: CLIENT_ID, CONF_CLIENT_SECRET: CLIENT_SECRET, }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( "home_connect", context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) assert result["type"] == data_entry_flow.RESULT_TYPE_EXTERNAL_STEP assert result["url"] == ( f"{OAUTH2_AUTHORIZE}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}") client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.home_connect.async_setup_entry", return_value=True) as mock_setup_entry: result = await hass.config_entries.flow.async_configure( result["flow_id"]) await hass.async_block_till_done() assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup_entry.mock_calls) == 1
async def test_reauthentication_flow(hass, hass_client_no_auth, aioclient_mock, current_request_with_host, mock_impl): """Test reauthentication flow.""" old_entry = MockConfigEntry( domain=DOMAIN, unique_id=DOMAIN, version=1, data={ "id": "timmo", "auth_implementation": DOMAIN }, ) old_entry.add_to_hass(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_REAUTH}, data=old_entry.data) flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 result = await hass.config_entries.flow.async_configure( flows[0]["flow_id"], {}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) client = await hass_client_no_auth() await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.lyric.api.ConfigEntryLyricClient"): with patch("homeassistant.components.lyric.async_setup_entry", return_value=True) as mock_setup: result = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result["type"] == data_entry_flow.FlowResultType.ABORT assert result["reason"] == "reauth_successful" assert len(mock_setup.mock_calls) == 1
async def test_full_flow(hass, hass_client_no_auth, aioclient_mock, current_request_with_host, mock_impl): """Check full flow.""" result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) assert result["type"] == data_entry_flow.FlowResultType.EXTERNAL_STEP assert result["url"] == ( f"{OAUTH2_AUTHORIZE}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}") client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.lyric.api.ConfigEntryLyricClient" ), patch("homeassistant.components.lyric.async_setup_entry", return_value=True) as mock_setup: result = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result["data"]["auth_implementation"] == "cred" result["data"]["token"].pop("expires_at") assert result["data"]["token"] == { "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, } assert DOMAIN in hass.config.components entry = hass.config_entries.async_entries(DOMAIN)[0] assert entry.state is config_entries.ConfigEntryState.LOADED assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup.mock_calls) == 1
async def test_full_flow(hass, aiohttp_client, aioclient_mock): """Check full flow.""" assert await setup.async_setup_component( hass, "netatmo", { "netatmo": {"client_id": CLIENT_ID, "client_secret": CLIENT_SECRET}, "http": {"base_url": "https://example.com"}, }, ) result = await hass.config_entries.flow.async_init( "netatmo", context={"source": config_entries.SOURCE_USER} ) state = config_entry_oauth2_flow._encode_jwt(hass, {"flow_id": result["flow_id"]}) scope = "+".join( [ "read_station", "read_camera", "access_camera", "write_camera", "read_presence", "access_presence", "read_homecoach", "read_smokedetector", "read_thermostat", "write_thermostat", ] ) assert result["url"] == ( f"{OAUTH2_AUTHORIZE}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope={scope}" ) client = await aiohttp_client(hass.http.app) resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) result = await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1
async def test_reauthentication(hass, aiohttp_client, aioclient_mock, current_request): """Test Spotify reauthentication.""" await setup.async_setup_component( hass, DOMAIN, { DOMAIN: {CONF_CLIENT_ID: "client", CONF_CLIENT_SECRET: "secret"}, "http": {"base_url": "https://example.com"}, }, ) old_entry = MockConfigEntry( domain=DOMAIN, unique_id=123, version=1, data={"id": "frenck", "auth_implementation": DOMAIN}, ) old_entry.add_to_hass(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": "reauth"}, data=old_entry.data ) flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 result = await hass.config_entries.flow.async_configure(flows[0]["flow_id"], {}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt(hass, {"flow_id": result["flow_id"]}) client = await aiohttp_client(hass.http.app) await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://accounts.spotify.com/api/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.spotify.config_flow.Spotify") as spotify_mock: spotify_mock.return_value.current_user.return_value = {"id": "frenck"} result = await hass.config_entries.flow.async_configure(result["flow_id"]) assert result["data"]["auth_implementation"] == DOMAIN result["data"]["token"].pop("expires_at") assert result["data"]["token"] == { "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }
async def test_full_flow_implementation(hass, aiohttp_client, aioclient_mock, current_request): """Test registering an integration and finishing flow works.""" await setup_component(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) assert result["type"] == data_entry_flow.RESULT_TYPE_FORM assert result["step_id"] == "pick_implementation" # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, {"flow_id": result["flow_id"]}) result2 = await hass.config_entries.flow.async_configure( result["flow_id"], {"implementation": "eneco"}) assert result2["type"] == data_entry_flow.RESULT_TYPE_EXTERNAL_STEP assert result2["url"] == ( "https://api.toon.eu/authorize" "?response_type=code&client_id=client" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}" "&tenant_id=eneco&issuer=identity.toon.eu") client = await aiohttp_client(hass.http.app) resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( "https://api.toon.eu/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("toonapi.Toon.agreements", return_value=[Agreement(agreement_id=123)]): result3 = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result3["data"]["auth_implementation"] == "eneco" assert result3["data"]["agreement_id"] == 123 result3["data"]["token"].pop("expires_at") assert result3["data"]["token"] == { "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }
async def test_full_flow(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Check full flow.""" assert await setup.async_setup_component( hass, "xbox", { "xbox": { "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( "xbox", context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) scope = "+".join(["Xboxlive.signin", "Xboxlive.offline_access"]) assert result["url"] == ( f"{OAUTH2_AUTHORIZE}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope={scope}") client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.xbox.async_setup_entry", return_value=True) as mock_setup: await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup.mock_calls) == 1
async def test_abort_if_invalid_token( hass, hass_client_no_auth, aioclient_mock, current_request_with_host ): """Check flow abort when the token has an invalid value.""" assert await setup.async_setup_component( hass, "home_plus_control", { "home_plus_control": { CONF_CLIENT_ID: CLIENT_ID, CONF_CLIENT_SECRET: CLIENT_SECRET, CONF_SUBSCRIPTION_KEY: SUBSCRIPTION_KEY, }, }, ) result = await hass.config_entries.flow.async_init( "home_plus_control", context={"source": config_entries.SOURCE_USER} ) state = config_entry_oauth2_flow._encode_jwt( # pylint: disable=protected-access hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) assert result["type"] == data_entry_flow.FlowResultType.EXTERNAL_STEP assert result["step_id"] == "auth" assert result["url"] == ( f"{OAUTH2_AUTHORIZE}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}" ) client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": "non-integer", }, ) result = await hass.config_entries.flow.async_configure(result["flow_id"]) assert result["type"] == data_entry_flow.FlowResultType.ABORT assert result["reason"] == "oauth_error"
async def test_full_flow(hass, aiohttp_client, aioclient_mock, current_request): """Check full flow.""" assert await setup.async_setup_component( hass, DOMAIN, { DOMAIN: { "project_id": PROJECT_ID, "subscriber_id": SUBSCRIBER_ID, CONF_CLIENT_ID: CLIENT_ID, CONF_CLIENT_SECRET: CLIENT_SECRET, }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, {"flow_id": result["flow_id"]}) oauth_authorize = OAUTH2_AUTHORIZE.format(project_id=PROJECT_ID) assert result["url"] == ( f"{oauth_authorize}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope=https://www.googleapis.com/auth/sdm.service" "+https://www.googleapis.com/auth/pubsub" "&access_type=offline&prompt=consent") client = await aiohttp_client(hass.http.app) resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.nest.async_setup_entry", return_value=True) as mock_setup: await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup.mock_calls) == 1
async def test_full_user_flow(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Check full flow.""" assert await setup.async_setup_component( hass, DOMAIN, { DOMAIN: { CONF_CLIENT_ID: CLIENT_ID, CONF_CLIENT_SECRET: CLIENT_SECRET }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}, ) result = await hass.config_entries.flow.async_configure( result["flow_id"], {"environment": ENV_CLOUD}) state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( TOKEN_URL["PRODUCTION"], json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.smappee.async_setup_entry", return_value=True) as mock_setup: await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup.mock_calls) == 1
async def test_abort_if_spotify_error(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Check Spotify errors causes flow to abort.""" await setup.async_setup_component( hass, DOMAIN, { DOMAIN: { CONF_CLIENT_ID: "client", CONF_CLIENT_SECRET: "secret" }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) client = await hass_client_no_auth() await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://accounts.spotify.com/api/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch( "homeassistant.components.spotify.config_flow.Spotify.current_user", side_effect=SpotifyException(400, -1, "message"), ): result = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result["reason"] == "connection_error"
async def test_reauthentication( hass: HomeAssistant, hass_client_no_auth: Callable[[], Awaitable[TestClient]], aioclient_mock: AiohttpClientMocker, current_request_with_host: None, mock_geocaching_config_flow: MagicMock, mock_setup_entry: MagicMock, mock_config_entry: MockConfigEntry, ) -> None: """Test Geocaching reauthentication.""" mock_config_entry.add_to_hass(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_REAUTH}) flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert "flow_id" in flows[0] result = await hass.config_entries.flow.async_configure( flows[0]["flow_id"], {}) assert "flow_id" in result # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( CURRENT_ENVIRONMENT_URLS["token_url"], json={ "access_token": "mock-access-token", "token_type": "bearer", "expires_in": 3599, "refresh_token": "mock-refresh_token", }, ) await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup_entry.mock_calls) == 1
async def test_full_flow( hass: HomeAssistant, hass_client_no_auth, aioclient_mock, current_request_with_host, ) -> None: """Check full flow.""" await async_setup_component(hass, DOMAIN, {}) await hass.async_block_till_done() await async_import_client_credential( hass, DOMAIN, ClientCredential(CLIENT_ID, CLIENT_SECRET), "cred") result = await hass.config_entries.flow.async_init( "senz", context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) assert result["url"] == ( f"{AUTHORIZATION_ENDPOINT}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope=restapi+offline_access") client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( TOKEN_ENDPOINT, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.senz.async_setup_entry", return_value=True) as mock_setup: await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup.mock_calls) == 1
async def test_import_migration(hass, aiohttp_client, aioclient_mock, current_request_with_host): """Test if importing step with migration works.""" old_entry = MockConfigEntry(domain=DOMAIN, unique_id=123, version=1) old_entry.add_to_hass(hass) await setup_component(hass) entries = hass.config_entries.async_entries(DOMAIN) assert len(entries) == 1 assert entries[0].version == 1 flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"][CONF_MIGRATE] == old_entry.entry_id # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": flows[0]["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) await hass.config_entries.flow.async_configure(flows[0]["flow_id"], {"implementation": "eneco"}) client = await aiohttp_client(hass.http.app) await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://api.toon.eu/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("toonapi.Toon.agreements", return_value=[Agreement(agreement_id=123)]): result = await hass.config_entries.flow.async_configure( flows[0]["flow_id"]) assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY entries = hass.config_entries.async_entries(DOMAIN) assert len(entries) == 1 assert entries[0].version == 2
async def test_full_flow( hass: HomeAssistant, hass_client_no_auth: Callable[[], Awaitable[TestClient]], aioclient_mock: AiohttpClientMocker, current_request_with_host: None, mock_geocaching_config_flow: MagicMock, mock_setup_entry: MagicMock, ) -> None: """Check full flow.""" result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) assert "flow_id" in result # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": REDIRECT_URI, }, ) assert result.get("type") == RESULT_TYPE_EXTERNAL_STEP assert result.get("step_id") == "auth" assert result.get("url") == ( f"{CURRENT_ENVIRONMENT_URLS['authorize_url']}?response_type=code&client_id={CLIENT_ID}" f"&redirect_uri={REDIRECT_URI}" f"&state={state}&scope=*") client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( CURRENT_ENVIRONMENT_URLS["token_url"], json={ "access_token": "mock-access-token", "token_type": "bearer", "expires_in": 3599, "refresh_token": "mock-refresh_token", }, ) await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup_entry.mock_calls) == 1
async def test_full_flow(hass, aiohttp_client, aioclient_mock): """Check full flow.""" assert await setup.async_setup_component( hass, "NEW_DOMAIN", { "NEW_DOMAIN": { "type": "oauth2", "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( "NEW_DOMAIN", context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, {"flow_id": result["flow_id"]}) assert result["type"] == data_entry_flow.RESULT_TYPE_EXTERNAL_STEP assert result["url"] == ( f"{OAUTH2_AUTHORIZE}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}") client = await aiohttp_client(hass.http.app) resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) result = await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 entry = hass.config_entries.async_entries(DOMAIN)[0] assert entry.data["type"] == "oauth2"
async def test_multiple_agreements(hass, aiohttp_client, aioclient_mock, current_request_with_host): """Test abort when there are no displays.""" await setup_component(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) await hass.config_entries.flow.async_configure(result["flow_id"], {"implementation": "eneco"}) client = await aiohttp_client(hass.http.app) await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://api.toon.eu/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch( "toonapi.Toon.agreements", return_value=[ Agreement(agreement_id=1), Agreement(agreement_id=2) ], ): result3 = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result3["type"] == data_entry_flow.RESULT_TYPE_FORM assert result3["step_id"] == "agreement" result4 = await hass.config_entries.flow.async_configure( result["flow_id"], {CONF_AGREEMENT: "None None, None"}) assert result4["data"]["auth_implementation"] == "eneco" assert result4["data"]["agreement_id"] == 1
async def async_generate_authorize_url(self, flow_id: str) -> str: """Generate a url for the user to authorize.""" ori_url = URL(self.authorize_url) _LOGGER.info("ori url parameters: %s", str(ori_url.query)) url = str( URL(self.authorize_url).update_query({ # "show_select_country": "Y", "callbackUrl": self.redirect_uri, "oauth2State": oauth2_flow._encode_jwt(self.hass, {"flow_id": flow_id}), })) _LOGGER.info("authorize_url: %s", url) return url
async def test_full_flow(hass, aiohttp_client, aioclient_mock): """Check full flow.""" assert await setup.async_setup_component( hass, DOMAIN, { DOMAIN: { CONF_CLIENT_ID: CLIENT_ID, CONF_CLIENT_SECRET: CLIENT_SECRET }, "http": { "base_url": "https://example.com" }, }, ) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_USER}) state = config_entry_oauth2_flow._encode_jwt( hass, {"flow_id": result["flow_id"]}) assert result["url"] == ( f"{AUTHORIZE_URL['PRODUCTION']}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}") client = await aiohttp_client(hass.http.app) resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.post( TOKEN_URL["PRODUCTION"], json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.smappee.async_setup_entry", return_value=True) as mock_setup: await hass.config_entries.flow.async_configure(result["flow_id"]) assert len(hass.config_entries.async_entries(DOMAIN)) == 1 assert len(mock_setup.mock_calls) == 1
async def test_cloud_abort_no_devices( hass: HomeAssistant, hass_client_no_auth: Callable[[], Awaitable[TestClient]], aioclient_mock: AiohttpClientMocker, current_request_with_host: None, mock_lametric_cloud_config_flow: MagicMock, ) -> None: """Test cloud importing aborts when account has no devices.""" result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER} ) assert "flow_id" in result flow_id = result["flow_id"] await hass.config_entries.flow.async_configure( flow_id, user_input={"next_step_id": "pick_implementation"} ) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": flow_id, "redirect_uri": "https://example.com/auth/external/callback", }, ) client = await hass_client_no_auth() await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://developer.lametric.com/api/v2/oauth2/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) # Stage there are no devices mock_lametric_cloud_config_flow.devices.return_value = [] result2 = await hass.config_entries.flow.async_configure(flow_id) assert result2.get("type") == FlowResultType.ABORT assert result2.get("reason") == "no_devices" assert len(mock_lametric_cloud_config_flow.devices.mock_calls) == 1
async def test_oauth_error( hass: HomeAssistant, hass_client_no_auth: Callable[[], Awaitable[TestClient]], aioclient_mock: AiohttpClientMocker, current_request_with_host: None, mock_geocaching_config_flow: MagicMock, mock_setup_entry: MagicMock, ) -> None: """Check if aborted when oauth error occurs.""" result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) assert "flow_id" in result # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": REDIRECT_URI, }, ) assert result.get("type") == RESULT_TYPE_EXTERNAL_STEP client = await hass_client_no_auth() resp = await client.get(f"/auth/external/callback?code=abcd&state={state}") assert resp.status == HTTPStatus.OK # No user information is returned from API mock_geocaching_config_flow.update.return_value.user = None aioclient_mock.post( CURRENT_ENVIRONMENT_URLS["token_url"], json={ "access_token": "mock-access-token", "token_type": "bearer", "expires_in": 3599, "refresh_token": "mock-refresh_token", }, ) result2 = await hass.config_entries.flow.async_configure(result["flow_id"]) assert result2.get("type") == RESULT_TYPE_ABORT assert result2.get("reason") == "oauth_error" assert len(hass.config_entries.async_entries(DOMAIN)) == 0 assert len(mock_setup_entry.mock_calls) == 0
async def async_oauth_flow(self, result): """Invoke the oauth flow with fake responses.""" state = config_entry_oauth2_flow._encode_jwt( self.hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) oauth_authorize = OAUTH2_AUTHORIZE.format(project_id=PROJECT_ID) assert result["type"] == "external" assert result["url"] == ( f"{oauth_authorize}?response_type=code&client_id={CLIENT_ID}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}&scope=https://www.googleapis.com/auth/sdm.service" "+https://www.googleapis.com/auth/pubsub" "&access_type=offline&prompt=consent") client = await self.aiohttp_client(self.hass.http.app) resp = await client.get( f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" self.aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.nest.async_setup_entry", return_value=True) as mock_setup: await self.hass.config_entries.flow.async_configure( result["flow_id"]) assert len(mock_setup.mock_calls) == 1
async def test_agreement_already_set_up(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Test showing display form again if display already exists.""" await setup_component(hass) MockConfigEntry(domain=DOMAIN, unique_id=123).add_to_hass(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) await hass.config_entries.flow.async_configure(result["flow_id"], {"implementation": "eneco"}) client = await hass_client_no_auth() await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://api.toon.eu/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("toonapi.Toon.agreements", return_value=[Agreement(agreement_id=123)]): result3 = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result3["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result3["reason"] == "already_configured"
async def complete_external_step( self, result: data_entry_flow.FlowResult) -> data_entry_flow.FlowResult: """Fixture method to complete the OAuth flow and return the completed result.""" client = await self.hass_client() state = config_entry_oauth2_flow._encode_jwt( self.hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) assert result["url"] == ( f"{AUTHORIZE_URL}?response_type=code&client_id={self.client_id}" "&redirect_uri=https://example.com/auth/external/callback" f"&state={state}") resp = await client.get( f"/auth/external/callback?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" self.aioclient_mock.post( TOKEN_URL, json={ "refresh_token": REFRESH_TOKEN, "access_token": ACCESS_TOKEN, "type": "bearer", "expires_in": 60, }, ) result = await self.hass.config_entries.flow.async_configure( result["flow_id"]) assert result.get("type") == data_entry_flow.RESULT_TYPE_CREATE_ENTRY assert result.get("title") == self.client_id assert "data" in result assert "token" in result["data"] return result
async def test_toon_abort( hass, aiohttp_client, aioclient_mock, current_request_with_host ): """Test we abort on Toon error.""" await setup_component(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER} ) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) await hass.config_entries.flow.async_configure( result["flow_id"], {"implementation": "eneco"} ) client = await aiohttp_client(hass.http.app) await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://api.toon.eu/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("toonapi.Toon.agreements", side_effect=ToonError): result2 = await hass.config_entries.flow.async_configure(result["flow_id"]) assert result2["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result2["reason"] == "connection_error"
async def test_no_agreements(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Test abort when there are no displays.""" await setup_component(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_USER}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) await hass.config_entries.flow.async_configure(result["flow_id"], {"implementation": "eneco"}) client = await hass_client_no_auth() await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( "https://api.toon.eu/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("toonapi.Toon.agreements", return_value=[]): result3 = await hass.config_entries.flow.async_configure( result["flow_id"]) assert result3["type"] == data_entry_flow.FlowResultType.ABORT assert result3["reason"] == "no_agreements"
async def test_config_reauth_profile(hass: HomeAssistant, aiohttp_client, aioclient_mock, current_request_with_host) -> None: """Test reauth an existing profile re-creates the config entry.""" hass_config = { HA_DOMAIN: { CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC, CONF_EXTERNAL_URL: "http://127.0.0.1:8080/", }, const.DOMAIN: { CONF_CLIENT_ID: "my_client_id", CONF_CLIENT_SECRET: "my_client_secret", const.CONF_USE_WEBHOOK: False, }, } await async_process_ha_core_config(hass, hass_config.get(HA_DOMAIN)) assert await async_setup_component(hass, const.DOMAIN, hass_config) await hass.async_block_till_done() config_entry = MockConfigEntry(domain=const.DOMAIN, data={const.PROFILE: "person0"}, unique_id="0") config_entry.add_to_hass(hass) result = await hass.config_entries.flow.async_init(const.DOMAIN, context={ "source": "reauth", "profile": "person0" }) assert result assert result["type"] == "form" assert result["step_id"] == "reauth" assert result["description_placeholders"] == {const.PROFILE: "person0"} result = await hass.config_entries.flow.async_configure( result["flow_id"], {}, ) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) client: TestClient = await aiohttp_client(hass.http.app) resp = await client.get(f"{AUTH_CALLBACK_PATH}?code=abcd&state={state}") assert resp.status == 200 assert resp.headers["content-type"] == "text/html; charset=utf-8" aioclient_mock.clear_requests() aioclient_mock.post( "https://account.withings.com/oauth2/token", json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, "userid": "0", }, ) result = await hass.config_entries.flow.async_configure(result["flow_id"]) assert result assert result["type"] == "abort" assert result["reason"] == "already_configured" entries = hass.config_entries.async_entries(const.DOMAIN) assert entries assert entries[0].data["token"]["refresh_token"] == "mock-refresh-token"
async def test_reauthentication(hass, hass_client_no_auth, aioclient_mock, current_request_with_host): """Test yolink reauthentication.""" await setup.async_setup_component( hass, DOMAIN, {}, ) await application_credentials.async_import_client_credential( hass, DOMAIN, application_credentials.ClientCredential(CLIENT_ID, CLIENT_SECRET), ) old_entry = MockConfigEntry( domain=DOMAIN, unique_id=DOMAIN, version=1, data={ "refresh_token": "outdated_fresh_token", "access_token": "outdated_access_token", }, ) old_entry.add_to_hass(hass) result = await hass.config_entries.flow.async_init( DOMAIN, context={ "source": config_entries.SOURCE_REAUTH, "unique_id": old_entry.unique_id, "entry_id": old_entry.entry_id, }, data=old_entry.data, ) flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 result = await hass.config_entries.flow.async_configure( flows[0]["flow_id"], {}) # pylint: disable=protected-access state = config_entry_oauth2_flow._encode_jwt( hass, { "flow_id": result["flow_id"], "redirect_uri": "https://example.com/auth/external/callback", }, ) client = await hass_client_no_auth() await client.get(f"/auth/external/callback?code=abcd&state={state}") aioclient_mock.post( OAUTH2_TOKEN, json={ "refresh_token": "mock-refresh-token", "access_token": "mock-access-token", "type": "Bearer", "expires_in": 60, }, ) with patch("homeassistant.components.yolink.api.ConfigEntryAuth"): with patch("homeassistant.components.yolink.async_setup_entry", return_value=True) as mock_setup: result = await hass.config_entries.flow.async_configure( result["flow_id"]) token_data = old_entry.data["token"] assert token_data["access_token"] == "mock-access-token" assert token_data["refresh_token"] == "mock-refresh-token" assert token_data["type"] == "Bearer" assert token_data["expires_in"] == 60 assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result["reason"] == "reauth_successful" assert len(mock_setup.mock_calls) == 1