Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Pacalexandre_oidc_pure /tests /test_oauth2.py
"""Tests for OAuth2 flows."""
from urllib.parse import parse_qs, urlparse
import httpx
import pytest
import respx
from oidc_pure.exceptions import AuthorizationError, TokenError
from oidc_pure.models import OIDCConfig, TokenResponse
from oidc_pure.oauth2 import OAuth2Flow
class TestOAuth2Flow:
"""Tests for OAuth2Flow class."""
@pytest.fixture
def oauth2_flow(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Create an OAuth2Flow instance."""
return OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
)
def test_context_manager(self, oauth2_flow: OAuth2Flow):
"""Test OAuth2Flow as context manager."""
with oauth2_flow as flow:
assert flow._client is not None
def test_build_authorization_url_basic(self, oauth2_flow: OAuth2Flow):
"""Test building basic authorization URL."""
auth_url, state, verifier = oauth2_flow.build_authorization_url()
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert parsed_url.scheme == "https"
assert "client_id" in query_params
assert "redirect_uri" in query_params
assert "response_type" in query_params
assert "scope" in query_params
assert "state" in query_params
assert query_params["response_type"][0] == "code"
assert state is not None
assert verifier is not None
def test_build_authorization_url_with_pkce(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with PKCE."""
auth_url, state, verifier = oauth2_flow.build_authorization_url(use_pkce=True)
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "code_challenge" in query_params
assert "code_challenge_method" in query_params
assert query_params["code_challenge_method"][0] == "S256"
assert verifier is not None
def test_build_authorization_url_without_pkce(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL without PKCE."""
auth_url, state, verifier = oauth2_flow.build_authorization_url(use_pkce=False)
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "code_challenge" not in query_params
assert "code_challenge_method" not in query_params
assert verifier is None
def test_build_authorization_url_custom_scope(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with custom scope."""
auth_url, _, _ = oauth2_flow.build_authorization_url(scope="openid profile")
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "openid" in query_params["scope"][0]
assert "profile" in query_params["scope"][0]
def test_build_authorization_url_list_scope(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with list of scopes."""
auth_url, _, _ = oauth2_flow.build_authorization_url(scope=["openid", "email"])
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "openid" in query_params["scope"][0]
assert "email" in query_params["scope"][0]
def test_build_authorization_url_extra_params(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with extra parameters."""
auth_url, _, _ = oauth2_flow.build_authorization_url(
extra_params={"prompt": "consent", "ui_locales": "pt-BR"}
)
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert query_params["prompt"][0] == "consent"
assert query_params["ui_locales"][0] == "pt-BR"
def test_build_authorization_url_no_redirect_uri(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
):
"""Test building authorization URL without redirect URI."""
flow = OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
)
with pytest.raises(AuthorizationError, match="redirect_uri is required"):
flow.build_authorization_url()
@respx.mock
def test_exchange_code_for_token_success(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test successful code exchange."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=mock_token_response)
)
token = oauth2_flow.exchange_code_for_token(
code="test_auth_code",
code_verifier="test_verifier",
)
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
assert token.token_type == mock_token_response["token_type"]
assert token.refresh_token == mock_token_response["refresh_token"]
@respx.mock
def test_exchange_code_for_token_error(self, oauth2_flow: OAuth2Flow):
"""Test code exchange with error response."""
error_response = {"error": "invalid_grant", "error_description": "Invalid code"}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(400, json=error_response)
)
with pytest.raises(TokenError, match="invalid_grant"):
oauth2_flow.exchange_code_for_token(code="invalid_code")
@respx.mock
def test_refresh_token_success(self, oauth2_flow: OAuth2Flow, mock_token_response: dict):
"""Test successful token refresh."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=mock_token_response)
)
token = oauth2_flow.refresh_access_token(refresh_token="test_refresh_token")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@respx.mock
def test_refresh_token_error(self, oauth2_flow: OAuth2Flow):
"""Test token refresh with error response."""
error_response = {"error": "invalid_grant", "error_description": "Invalid refresh token"}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(400, json=error_response)
)
with pytest.raises(TokenError, match="invalid_grant"):
oauth2_flow.refresh_access_token(refresh_token="invalid_token")
@respx.mock
def test_client_credentials_flow_success(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test successful client credentials flow."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=mock_token_response)
)
token = oauth2_flow.client_credentials_flow(scope="api:read api:write")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@respx.mock
def test_client_credentials_flow_error(self, oauth2_flow: OAuth2Flow):
"""Test client credentials flow with error."""
error_response = {"error": "invalid_client", "error_description": "Invalid credentials"}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(401, json=error_response)
)
with pytest.raises(TokenError, match="invalid_client"):
oauth2_flow.client_credentials_flow()
def test_parse_authorization_response_success(self, oauth2_flow: OAuth2Flow):
"""Test parsing successful authorization response."""
response_url = "http://localhost:8080/callback?code=test_auth_code&state=test_state"
code = oauth2_flow.parse_authorization_response(
response_url=response_url,
expected_state="test_state",
)
assert code == "test_auth_code"
def test_parse_authorization_response_state_mismatch(self, oauth2_flow: OAuth2Flow):
"""Test parsing response with state mismatch."""
response_url = "http://localhost:8080/callback?code=test_auth_code&state=wrong_state"
with pytest.raises(AuthorizationError, match="State mismatch"):
oauth2_flow.parse_authorization_response(
response_url=response_url,
expected_state="expected_state",
)
def test_parse_authorization_response_missing_code(self, oauth2_flow: OAuth2Flow):
"""Test parsing response with missing code."""
response_url = "http://localhost:8080/callback?state=test_state"
with pytest.raises(AuthorizationError, match="Response missing authorization code"):
oauth2_flow.parse_authorization_response(
response_url=response_url,
expected_state="test_state",
)
def test_parse_authorization_response_error(self, oauth2_flow: OAuth2Flow):
"""Test parsing response with error."""
response_url = (
"http://localhost:8080/callback?error=access_denied&error_description=User denied"
)
with pytest.raises(AuthorizationError, match="access_denied"):
oauth2_flow.parse_authorization_response(
response_url=response_url,
expected_state="test_state",
)
class TestOAuth2FlowAsync:
"""Tests for OAuth2Flow async methods."""
@pytest.fixture
def oauth2_flow(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Create an OAuth2Flow instance."""
return OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
)
@pytest.mark.asyncio
@respx.mock
async def test_exchange_code_for_token_async_success(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test successful async code exchange."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=mock_token_response)
)
token = await oauth2_flow.exchange_code_for_token_async(
code="test_auth_code",
code_verifier="test_verifier",
)
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
assert token.token_type == mock_token_response["token_type"]
assert token.refresh_token == mock_token_response["refresh_token"]
@pytest.mark.asyncio
@respx.mock
async def test_exchange_code_for_token_async_error(self, oauth2_flow: OAuth2Flow):
"""Test async code exchange with error response."""
error_response = {"error": "invalid_grant", "error_description": "Invalid code"}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(400, json=error_response)
)
with pytest.raises(TokenError, match="invalid_grant"):
await oauth2_flow.exchange_code_for_token_async(code="invalid_code")
@pytest.mark.asyncio
@respx.mock
async def test_exchange_code_for_token_async_no_redirect_uri(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
):
"""Test async code exchange without redirect URI."""
flow = OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
)
with pytest.raises(TokenError, match="redirect_uri is required"):
await flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_refresh_access_token_async_success(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test successful async token refresh."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=mock_token_response)
)
token = await oauth2_flow.refresh_access_token_async(refresh_token="test_refresh_token")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@pytest.mark.asyncio
@respx.mock
async def test_refresh_access_token_async_error(self, oauth2_flow: OAuth2Flow):
"""Test async token refresh with error response."""
error_response = {"error": "invalid_grant", "error_description": "Invalid refresh token"}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(400, json=error_response)
)
with pytest.raises(TokenError, match="invalid_grant"):
await oauth2_flow.refresh_access_token_async(refresh_token="invalid_token")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_form_urlencoded_response(self, oauth2_flow: OAuth2Flow):
"""Test async token request with form-urlencoded response (GitHub OAuth)."""
# GitHub OAuth returns form-urlencoded by default
form_response = "access_token=gho_testtoken123&token_type=bearer&scope=repo%2Cuser"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded"},
)
)
token = await oauth2_flow.exchange_code_for_token_async(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "gho_testtoken123"
assert token.token_type == "bearer"
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_json_fallback(self, oauth2_flow: OAuth2Flow):
"""Test async token request with JSON fallback when content-type is missing."""
json_response = {
"access_token": "test_token",
"token_type": "Bearer",
"expires_in": 3600,
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
json=json_response,
headers={"content-type": "text/plain"}, # Wrong content-type
)
)
token = await oauth2_flow.exchange_code_for_token_async(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "test_token"
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_form_urlencoded_with_charset(self, oauth2_flow: OAuth2Flow):
"""Test async token request with form-urlencoded and charset."""
form_response = "access_token=gho_github_token_456&token_type=bearer&scope=admin%3Aorg"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded; charset=utf-8"},
)
)
token = await oauth2_flow.exchange_code_for_token_async(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "gho_github_token_456"
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_json_with_charset(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test async token request with JSON and charset."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
json=mock_token_response,
headers={"content-type": "application/json; charset=utf-8"},
)
)
token = await oauth2_flow.exchange_code_for_token_async(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_content_type_case_insensitive(self, oauth2_flow: OAuth2Flow):
"""Test async token request with uppercase Content-Type."""
form_response = "access_token=case_test&token_type=Bearer"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"Content-Type": "APPLICATION/X-WWW-FORM-URLENCODED"},
)
)
token = await oauth2_flow.refresh_access_token_async(refresh_token="test_refresh")
assert isinstance(token, TokenResponse)
assert token.access_token == "case_test"
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_form_urlencoded_with_special_chars(
self, oauth2_flow: OAuth2Flow
):
"""Test async token request with URL encoded special characters."""
form_response = (
"access_token=special_token&"
"token_type=bearer&"
"scope=read%3Auser+write%3Arepo&"
"expires_in=7200"
)
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded"},
)
)
token = await oauth2_flow.exchange_code_for_token_async(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "special_token"
assert token.expires_in == "7200" # Form-urlencoded returns string
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_empty_response(self, oauth2_flow: OAuth2Flow):
"""Test async token request with empty response."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text="")
)
with pytest.raises(TokenError, match="Invalid token response"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_network_error(self, oauth2_flow: OAuth2Flow):
"""Test async token request with network error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ConnectError("Connection failed")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_connect_timeout(self, oauth2_flow: OAuth2Flow):
"""Test async token request with connection timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ConnectTimeout("Connection timeout")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_read_timeout(self, oauth2_flow: OAuth2Flow):
"""Test async token request with read timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ReadTimeout("Read timeout")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_pool_timeout(self, oauth2_flow: OAuth2Flow):
"""Test async token request with connection pool timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.PoolTimeout("Connection pool exhausted")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_write_timeout(self, oauth2_flow: OAuth2Flow):
"""Test async token request with write timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.WriteTimeout("Write timeout")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_remote_protocol_error(self, oauth2_flow: OAuth2Flow):
"""Test async token request with remote protocol error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.RemoteProtocolError("Remote host closed connection")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_local_protocol_error(self, oauth2_flow: OAuth2Flow):
"""Test async token request with local protocol error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.LocalProtocolError("Invalid HTTP response")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_proxy_error(self, oauth2_flow: OAuth2Flow):
"""Test async token request with proxy error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ProxyError("Proxy connection failed")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_refresh_token_async_network_error(self, oauth2_flow: OAuth2Flow):
"""Test async refresh token with network error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ConnectTimeout("Connection timeout")
)
with pytest.raises(NetworkError, match="Network error"):
await oauth2_flow.refresh_access_token_async(refresh_token="test_refresh")
@pytest.mark.asyncio
@respx.mock
async def test_token_request_async_http_status_error(self, oauth2_flow: OAuth2Flow):
"""Test async token request with HTTP status error without JSON body."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(500, text="Internal Server Error")
)
with pytest.raises(TokenError, match="Token request failed with status 500"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
class TestOAuth2FlowEdgeCases:
"""Tests for OAuth2Flow edge cases and error handling."""
@pytest.fixture
def oauth2_flow(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Create an OAuth2Flow instance."""
return OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
)
@respx.mock
def test_exchange_code_for_token_no_redirect_uri(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
):
"""Test code exchange without redirect URI."""
flow = OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
)
with pytest.raises(TokenError, match="redirect_uri is required"):
flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_client_credentials_flow_no_client_secret(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_redirect_uri: str,
):
"""Test client credentials flow without client secret."""
flow = OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
redirect_uri=mock_redirect_uri,
)
with pytest.raises(TokenError, match="client_secret is required"):
flow.client_credentials_flow()
@respx.mock
def test_token_request_form_urlencoded_response(self, oauth2_flow: OAuth2Flow):
"""Test token request with form-urlencoded response (GitHub OAuth)."""
form_response = (
"access_token=gho_testtoken123&token_type=bearer&"
"scope=repo%2Cuser&refresh_token=gho_refresh123"
)
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "gho_testtoken123"
assert token.token_type == "bearer"
assert token.refresh_token == "gho_refresh123"
@respx.mock
def test_token_request_json_fallback_with_json_start(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test token request with JSON fallback when content-type is wrong but body is JSON."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
json=mock_token_response,
headers={"content-type": "text/html"}, # Wrong content-type
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@respx.mock
def test_token_request_json_fallback_with_form_urlencoded(self, oauth2_flow: OAuth2Flow):
"""Test token request with form-urlencoded fallback when no content-type."""
form_response = "access_token=test_token&token_type=bearer&expires_in=3600"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text=form_response)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "test_token"
@respx.mock
def test_token_request_form_urlencoded_with_charset(self, oauth2_flow: OAuth2Flow):
"""Test token request with form-urlencoded and charset (GitHub OAuth)."""
form_response = "access_token=gho_16C7e42F292c6912E7710c838347Ae178B4a&token_type=bearer&scope=repo%2Cuser"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded; charset=utf-8"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "gho_16C7e42F292c6912E7710c838347Ae178B4a"
assert token.token_type == "bearer"
@respx.mock
def test_token_request_json_with_charset(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test token request with JSON and charset."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
json=mock_token_response,
headers={"content-type": "application/json; charset=utf-8"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@respx.mock
def test_token_request_content_type_case_insensitive(self, oauth2_flow: OAuth2Flow):
"""Test token request with uppercase Content-Type."""
form_response = "access_token=test_token&token_type=Bearer"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"Content-Type": "APPLICATION/X-WWW-FORM-URLENCODED"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "test_token"
@respx.mock
def test_token_request_form_urlencoded_with_special_chars(self, oauth2_flow: OAuth2Flow):
"""Test token request with URL encoded special characters."""
# Simulates GitHub OAuth response with encoded scope values
form_response = (
"access_token=test_token_123&"
"token_type=bearer&"
"scope=user%3Aemail+repo%3Astatus+notifications"
)
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "test_token_123"
assert token.token_type == "bearer"
@respx.mock
def test_token_request_form_urlencoded_multivalue(self, oauth2_flow: OAuth2Flow):
"""Test token request with multiple values for same key."""
# Some OAuth providers may return multiple scope values
form_response = "access_token=test_token&token_type=bearer&scope=read&scope=write"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=form_response,
headers={"content-type": "application/x-www-form-urlencoded"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "test_token"
@respx.mock
def test_token_request_json_in_text_content_type(
self, oauth2_flow: OAuth2Flow, mock_token_response: dict
):
"""Test token request with JSON body but text/plain content-type (fallback detection)."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
json=mock_token_response,
headers={"content-type": "text/plain"},
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == mock_token_response["access_token"]
@respx.mock
def test_token_request_form_urlencoded_no_header(self, oauth2_flow: OAuth2Flow):
"""Test token request with form-urlencoded body but missing Content-Type header."""
form_response = "access_token=github_token&token_type=bearer&expires_in=28800"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text=form_response)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert isinstance(token, TokenResponse)
assert token.access_token == "github_token"
assert token.expires_in == "28800" # Form-urlencoded returns string
@respx.mock
def test_token_request_empty_response(self, oauth2_flow: OAuth2Flow):
"""Test token request with empty response."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text="")
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_malformed_json(self, oauth2_flow: OAuth2Flow):
"""Test token request with malformed JSON response."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text="{invalid json}",
headers={"content-type": "application/json"},
)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_network_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with network error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ConnectError("Connection failed")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_connect_timeout_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with connection timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ConnectTimeout("Connection timeout")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_read_timeout_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with read timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ReadTimeout("Read timeout")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_pool_timeout_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with connection pool timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.PoolTimeout("Connection pool exhausted")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_write_timeout_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with write timeout."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.WriteTimeout("Write timeout")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_remote_protocol_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with remote protocol error (connection closed)."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.RemoteProtocolError("Remote host closed connection")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_local_protocol_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with local protocol error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.LocalProtocolError("Invalid HTTP response")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_request_proxy_error(self, oauth2_flow: OAuth2Flow):
"""Test token request with proxy error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ProxyError("Proxy connection failed")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_refresh_token_network_error(self, oauth2_flow: OAuth2Flow):
"""Test refresh token with network error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ConnectError("Connection failed")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.refresh_access_token(refresh_token="test_refresh")
@respx.mock
def test_client_credentials_flow_network_error(self, oauth2_flow: OAuth2Flow):
"""Test client credentials flow with network error."""
from oidc_pure.exceptions import NetworkError
respx.post(oauth2_flow.config.token_endpoint).mock(
side_effect=httpx.ReadTimeout("Read timeout during client credentials")
)
with pytest.raises(NetworkError, match="Network error"):
oauth2_flow.client_credentials_flow(scope="api:read")
@respx.mock
def test_token_request_http_status_error_without_json(self, oauth2_flow: OAuth2Flow):
"""Test token request with HTTP error but no JSON error body."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(500, text="Internal Server Error")
)
with pytest.raises(TokenError, match="Token request failed with status 500"):
oauth2_flow.exchange_code_for_token(code="test_code")
def test_oauth2_flow_with_custom_client(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Test OAuth2Flow with custom httpx.Client."""
custom_client = httpx.Client(timeout=60.0)
flow = OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
client=custom_client,
)
assert flow._client is custom_client
assert flow._own_client is False
def test_oauth2_flow_context_manager_with_custom_client(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Test OAuth2Flow context manager doesn't close custom client."""
custom_client = httpx.Client(timeout=60.0)
flow = OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
client=custom_client,
)
with flow:
assert flow._client is custom_client
# Custom client should not be closed
assert not custom_client.is_closed
custom_client.close()
class TestOAuth2MalformedResponses:
"""Tests for malformed and edge case responses."""
@pytest.fixture
def oauth2_flow(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Create an OAuth2Flow instance."""
return OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
)
@respx.mock
def test_token_response_missing_access_token(self, oauth2_flow: OAuth2Flow):
"""Test token response missing required access_token field."""
incomplete_response = {
"token_type": "Bearer",
"expires_in": 3600,
# Missing access_token
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=incomplete_response)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_missing_token_type(self, oauth2_flow: OAuth2Flow):
"""Test token response missing token_type field."""
incomplete_response = {
"access_token": "test_token",
"expires_in": 3600,
# Missing token_type
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=incomplete_response)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_whitespace_only(self, oauth2_flow: OAuth2Flow):
"""Test token response with only whitespace."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text=" \n\t ")
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_null_json(self, oauth2_flow: OAuth2Flow):
"""Test token response with null JSON."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200, text="null", headers={"content-type": "application/json"}
)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_empty_json_object(self, oauth2_flow: OAuth2Flow):
"""Test token response with empty JSON object."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json={}, headers={"content-type": "application/json"})
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_json_array_instead_of_object(self, oauth2_flow: OAuth2Flow):
"""Test token response with JSON array instead of object."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200, text='["access_token", "bearer"]', headers={"content-type": "application/json"}
)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_html_instead_of_json(self, oauth2_flow: OAuth2Flow):
"""Test token response with HTML error page instead of JSON."""
html_error = """
<html>
<body>
<h1>500 Internal Server Error</h1>
<p>Something went wrong</p>
</body>
</html>
"""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text=html_error, headers={"content-type": "text/html"})
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_invalid_json_syntax(self, oauth2_flow: OAuth2Flow):
"""Test token response with invalid JSON syntax."""
invalid_jsons = [
"{access_token: 'missing_quotes'}", # Missing quotes on key
"{'access_token': 'single_quotes'}", # Single quotes
"{access_token: test_token}", # Missing quotes on both
'{"access_token": "test", }', # Trailing comma
'{"access_token": undefined}', # JavaScript undefined
]
for invalid_json in invalid_jsons:
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200, text=invalid_json, headers={"content-type": "application/json"}
)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_xml_instead_of_json(self, oauth2_flow: OAuth2Flow):
"""Test token response with XML instead of JSON."""
xml_response = """<?xml version="1.0"?>
<response>
<access_token>test_token</access_token>
<token_type>Bearer</token_type>
</response>
"""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200, text=xml_response, headers={"content-type": "application/xml"}
)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_binary_data(self, oauth2_flow: OAuth2Flow):
"""Test token response with binary data."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
content=b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR", # PNG header
headers={"content-type": "application/octet-stream"},
)
)
with pytest.raises(TokenError, match="Invalid token response"):
oauth2_flow.exchange_code_for_token(code="test_code")
@respx.mock
def test_token_response_extremely_large(self, oauth2_flow: OAuth2Flow):
"""Test token response with extremely large payload."""
# Simulate a large (but valid) response
large_response = {
"access_token": "a" * 100000, # 100KB token
"token_type": "Bearer",
"expires_in": 3600,
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=large_response)
)
# Should work despite large size
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert token.access_token == "a" * 100000
@respx.mock
def test_token_response_unicode_in_fields(self, oauth2_flow: OAuth2Flow):
"""Test token response with unicode characters."""
unicode_response = {
"access_token": "test_token_🔒",
"token_type": "Bearer",
"expires_in": 3600,
"scope": "read:user 読み取り write:repo",
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=unicode_response)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert "🔒" in token.access_token
@respx.mock
def test_token_response_with_bom(self, oauth2_flow: OAuth2Flow):
"""Test token response with UTF-8 BOM (Byte Order Mark)."""
import json
response_data = {"access_token": "test_token", "token_type": "Bearer", "expires_in": 3600}
# UTF-8 BOM + JSON
json_with_bom = "\ufeff" + json.dumps(response_data)
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200, text=json_with_bom, headers={"content-type": "application/json; charset=utf-8"}
)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert token.access_token == "test_token"
@respx.mock
def test_token_response_numeric_strings(self, oauth2_flow: OAuth2Flow):
"""Test token response with numeric values as strings."""
response_with_strings = {
"access_token": "test_token",
"token_type": "Bearer",
"expires_in": "3600", # String instead of int
"scope": "openid profile",
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=response_with_strings)
)
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert token.expires_in == "3600" # Should accept as-is
@respx.mock
def test_token_response_extra_unknown_fields(self, oauth2_flow: OAuth2Flow):
"""Test token response with extra unknown fields."""
response_with_extras = {
"access_token": "test_token",
"token_type": "Bearer",
"expires_in": 3600,
"unknown_field": "unknown_value",
"custom_data": {"nested": "value"},
"deprecated_field": None,
}
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, json=response_with_extras)
)
# Should ignore unknown fields and work normally
token = oauth2_flow.exchange_code_for_token(code="test_code")
assert token.access_token == "test_token"
@respx.mock
def test_token_response_form_urlencoded_malformed(self, oauth2_flow: OAuth2Flow):
"""Test malformed form-urlencoded response."""
malformed_forms = [
"access_token=test&=invalid", # Missing key
"access_token&token_type=Bearer", # Missing value
"access_token=test&token_type", # Incomplete pair
"===", # Only separators
"access_token=test&token_type=Bearer&", # Trailing &
]
for malformed in malformed_forms:
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200,
text=malformed,
headers={"content-type": "application/x-www-form-urlencoded"},
)
)
# Should handle gracefully (may succeed with partial data or fail)
try:
token = oauth2_flow.exchange_code_for_token(code="test_code")
# If it succeeds, at least access_token should be present
assert hasattr(token, "access_token")
except TokenError:
# Acceptable to fail on malformed data
pass
@pytest.mark.asyncio
@respx.mock
async def test_token_response_async_malformed_json(self, oauth2_flow: OAuth2Flow):
"""Test async token request with malformed JSON."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(
200, text="{broken json}", headers={"content-type": "application/json"}
)
)
with pytest.raises(TokenError, match="Invalid token response"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_response_async_empty_response(self, oauth2_flow: OAuth2Flow):
"""Test async token request with empty response."""
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text="")
)
with pytest.raises(TokenError, match="Invalid token response"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
@pytest.mark.asyncio
@respx.mock
async def test_token_response_async_html_error(self, oauth2_flow: OAuth2Flow):
"""Test async token request with HTML error page."""
html_error = "<html><body><h1>Error</h1></body></html>"
respx.post(oauth2_flow.config.token_endpoint).mock(
return_value=httpx.Response(200, text=html_error, headers={"content-type": "text/html"})
)
with pytest.raises(TokenError, match="Invalid token response"):
await oauth2_flow.exchange_code_for_token_async(code="test_code")
"""Tests for OAuth2 flows."""
from urllib.parse import parse_qs, urlparse
import httpx
import pytest
import respx
from oidc_pure.exceptions import AuthorizationError, TokenError
from oidc_pure.models import OIDCConfig, TokenResponse
from oidc_pure.oauth2 import OAuth2Flow
class TestOAuth2Flow:
"""Tests for OAuth2Flow class."""
def oauth2_flow(
self,
mock_oidc_config: OIDCConfig,
mock_client_id: str,
mock_client_secret: str,
mock_redirect_uri: str,
):
"""Create an OAuth2Flow instance."""
return OAuth2Flow(
config=mock_oidc_config,
client_id=mock_client_id,
client_secret=mock_client_secret,
redirect_uri=mock_redirect_uri,
)
def test_context_manager(self, oauth2_flow: OAuth2Flow):
"""Test OAuth2Flow as context manager."""
with oauth2_flow as flow:
assert flow._client is not None
def test_build_authorization_url_basic(self, oauth2_flow: OAuth2Flow):
"""Test building basic authorization URL."""
auth_url, state, verifier = oauth2_flow.build_authorization_url()
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert parsed_url.scheme == "https"
assert "client_id" in query_params
assert "redirect_uri" in query_params
assert "response_type" in query_params
assert "scope" in query_params
assert "state" in query_params
assert query_params["response_type"][0] == "code"
assert state is not None
assert verifier is not None
def test_build_authorization_url_with_pkce(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with PKCE."""
auth_url, state, verifier = oauth2_flow.build_authorization_url(use_pkce=True)
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "code_challenge" in query_params
assert "code_challenge_method" in query_params
assert query_params["code_challenge_method"][0] == "S256"
assert verifier is not None
def test_build_authorization_url_without_pkce(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL without PKCE."""
auth_url, state, verifier = oauth2_flow.build_authorization_url(use_pkce=False)
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "code_challenge" not in query_params
assert "code_challenge_method" not in query_params
assert verifier is None
def test_build_authorization_url_custom_scope(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with custom scope."""
auth_url, _, _ = oauth2_flow.build_authorization_url(scope="openid profile")
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "openid" in query_params["scope"][0]
assert "profile" in query_params["scope"][0]
def test_build_authorization_url_list_scope(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with list of scopes."""
auth_url, _, _ = oauth2_flow.build_authorization_url(scope=["openid", "email"])
parsed_url = urlparse(auth_url)
query_params = parse_qs(parsed_url.query)
assert "openid" in query_params["scope"][0]
assert "email" in query_params["scope"][0]
def test_build_authorization_url_extra_params(self, oauth2_flow: OAuth2Flow):
"""Test building authorization URL with extra parameters."""
auth_url, _, _ = oauth2_flow.build_authorization_url(
Xet Storage Details
- Size:
- 53.1 kB
- Xet hash:
- 61f17b58d1754cf79f62ec5d3e811ed33c102daa6189efca28c44659a713d195
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.