Open-source personal finance manager. Self-hosted, privacy-first.
import base64
import hashlib
import json
from urllib.parse import parse_qs, urlparse
import pytest
from pydantic import SecretStr
from httpx import AsyncClient
from sqlalchemy import select
from app.api import oidc_auth
from app.core.config import get_settings
from app.models.app_settings import AppSetting
from app.models.workspace import WorkspaceMember
class FakeRedis:
def __init__(self):
self.store = {}
async def set(self, key, value, ex=None):
self.store[key] = value
async def get(self, key):
return self.store.get(key)
async def delete(self, key):
self.store.pop(key, None)
@pytest.fixture
def oidc_settings(monkeypatch):
settings = get_settings()
old = settings.model_dump()
settings.oidc_enabled = True
settings.oidc_provider_name = "Pocket ID"
settings.oidc_discovery_url = "https://id.example.com/.well-known/openid-configuration"
settings.oidc_client_id = "securo"
settings.oidc_client_secret = SecretStr("secret")
settings.frontend_url = "http://test"
settings.oidc_sync_roles = False
settings.oidc_roles_claim = "groups"
settings.oidc_admin_roles = ""
settings.oidc_workspace_role_map = ""
yield settings
for key, value in old.items():
setattr(settings, key, value)
@pytest.mark.asyncio
async def test_decode_id_token_accepts_google_style_at_hash(monkeypatch, oidc_settings):
"""Google id_token carrying at_hash must validate (regression for the
'Invalid OIDC id_token' failure: jwt.decode got no access_token)."""
import time
from cryptography.hazmat.primitives.asymmetric import rsa
from jose import jwt as jose_jwt
from jose.backends.cryptography_backend import CryptographyRSAKey
from jose.constants import ALGORITHMS
private = rsa.generate_private_key(public_exponent=65537, key_size=2048)
priv_jwk = CryptographyRSAKey(private, ALGORITHMS.RS256).to_dict()
pub_jwk = CryptographyRSAKey(private.public_key(), ALGORITHMS.RS256).to_dict()
pub_jwk.update({"kid": "test-key", "alg": "RS256", "use": "sig"})
access_token = "ya29.google-access-token"
issuer = "https://accounts.google.com"
now = int(time.time())
id_token = jose_jwt.encode(
{
"iss": issuer,
"aud": oidc_settings.oidc_client_id,
"sub": "google-sub-123",
"email": "[email protected]",
"email_verified": True,
"nonce": "nonce123",
"iat": now,
"exp": now + 600,
},
priv_jwk,
algorithm="RS256",
headers={"kid": "test-key"},
access_token=access_token,
)
assert "at_hash" in jose_jwt.get_unverified_claims(id_token)
class _Resp:
def raise_for_status(self):
return None
def json(self):
return {"keys": [pub_jwk]}
class _FakeAsyncClient:
def __init__(self, *a, **k):
pass
async def __aenter__(self):
return self
async def __aexit__(self, *a):
return False
async def get(self, url, **k):
return _Resp()
monkeypatch.setattr(oidc_auth.httpx, "AsyncClient", _FakeAsyncClient)
discovery = {"jwks_uri": "https://accounts.google.com/jwks", "issuer": issuer}
claims = await oidc_auth._decode_id_token(discovery, id_token, "nonce123", access_token)
assert claims["sub"] == "google-sub-123"
assert claims["email"] == "[email protected]"
@pytest.mark.asyncio
async def test_oidc_config_disabled_by_default(client: AsyncClient, clean_db):
response = await client.get("/api/auth/oidc/config")
assert response.status_code == 200
data = response.json()
assert data["enabled"] is False
assert data["local_auth_enabled"] is True
@pytest.mark.asyncio
async def test_oidc_config_exposes_local_auth_disabled(client: AsyncClient, clean_db, oidc_settings):
oidc_settings.local_auth_enabled = False
response = await client.get("/api/auth/oidc/config")
assert response.status_code == 200
data = response.json()
assert data["enabled"] is True
assert data["provider_name"] == "Pocket ID"
assert data["local_auth_enabled"] is False
@pytest.mark.asyncio
async def test_oidc_login_redirects_to_provider(client: AsyncClient, clean_db, oidc_settings, monkeypatch):
fake_redis = FakeRedis()
async def fake_discover():
return {"authorization_endpoint": "https://id.example.com/authorize"}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
response = await client.get("/api/auth/oidc/login", follow_redirects=False)
assert response.status_code == 307
location = response.headers["location"]
parsed = urlparse(location)
params = parse_qs(parsed.query)
assert parsed.scheme == "https"
assert parsed.netloc == "id.example.com"
assert parsed.path == "/authorize"
assert params["client_id"] == ["securo"]
assert params["scope"] == ["openid email profile"]
assert params["redirect_uri"] == ["http://test/api/auth/oidc/callback"]
assert params["code_challenge_method"] == ["S256"]
assert params["code_challenge"][0]
stored = json.loads(fake_redis.store[f"oidc_state:{params['state'][0]}"])
expected_challenge = (
base64.urlsafe_b64encode(hashlib.sha256(stored["code_verifier"].encode()).digest())
.rstrip(b"=")
.decode()
)
assert params["code_challenge"][0] == expected_challenge
@pytest.mark.asyncio
async def test_oidc_callback_creates_user_and_redirects_with_securo_token(
client: AsyncClient, clean_db, oidc_settings, monkeypatch
):
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
assert code == "abc"
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
assert id_token == "id-token"
assert nonce == "nonce123"
return {"sub": "user-sub", "email": "[email protected]", "email_verified": True, "name": "OIDC User"}
async def fake_userinfo(discovery, access_token):
assert access_token == "provider-token"
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
location = response.headers["location"]
assert location.startswith("http://test/auth/oidc/callback#access_token=")
token = parse_qs(urlparse(location).fragment)["access_token"][0]
me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})
assert me.status_code == 200
assert me.json()["email"] == "[email protected]"
@pytest.mark.asyncio
async def test_oidc_callback_syncs_existing_user_admin_and_workspace_role(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_sync_roles = True
oidc_settings.oidc_admin_roles = "securo-admins"
test_user.oidc_issuer = "https://id.example.com"
test_user.oidc_subject = "user-sub"
session.add(test_user)
await session.commit()
oidc_settings.oidc_workspace_role_map = json.dumps(
{
"securo-viewers": "viewer",
"securo-editors": "editor",
"securo-owners": "owner",
}
)
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {
"sub": "user-sub",
"email": "[email protected]",
"email_verified": True,
"groups": ["securo-admins", "securo-editors"],
}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
token = parse_qs(urlparse(response.headers["location"]).fragment)["access_token"][0]
me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})
assert me.status_code == 200
assert me.json()["is_superuser"] is True
workspace = await client.get("/api/workspaces/current", headers={"Authorization": f"Bearer {token}"})
assert workspace.status_code == 200
assert workspace.json()["role"] == "owner"
member = (
await session.execute(select(WorkspaceMember).where(WorkspaceMember.user_id == test_user.id))
).scalars().first()
assert member.role == "owner"
@pytest.mark.asyncio
async def test_oidc_callback_sync_roles_can_revoke_admin(
client: AsyncClient, session, test_superuser, oidc_settings, monkeypatch
):
oidc_settings.oidc_sync_roles = True
oidc_settings.oidc_admin_roles = "securo-admins"
test_superuser.oidc_issuer = "https://id.example.com"
test_superuser.oidc_subject = "user-sub"
session.add(test_superuser)
await session.commit()
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {
"sub": "user-sub",
"email": "[email protected]",
"email_verified": True,
"groups": ["securo-users"],
}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
token = parse_qs(urlparse(response.headers["location"]).fragment)["access_token"][0]
me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})
assert me.status_code == 200
assert me.json()["is_superuser"] is False
@pytest.mark.asyncio
async def test_oidc_callback_signed_claims_override_userinfo_roles(
client: AsyncClient, clean_db, oidc_settings, monkeypatch
):
oidc_settings.oidc_sync_roles = True
oidc_settings.oidc_admin_roles = "securo-admins"
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {
"sub": "signed-sub",
"email": "[email protected]",
"email_verified": True,
"groups": ["securo-users"],
}
async def fake_userinfo(discovery, access_token):
return {
"sub": "signed-sub",
"email": "[email protected]",
"email_verified": True,
"groups": ["securo-admins"],
}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
token = parse_qs(urlparse(response.headers["location"]).fragment)["access_token"][0]
me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})
assert me.status_code == 200
assert me.json()["email"] == "[email protected]"
assert me.json()["is_superuser"] is False
@pytest.mark.asyncio
async def test_oidc_callback_rejects_userinfo_subject_mismatch(
client: AsyncClient, clean_db, oidc_settings, monkeypatch
):
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "signed-sub", "email": "[email protected]", "email_verified": True}
async def fake_userinfo(discovery, access_token):
return {"sub": "different-sub", "email": "[email protected]", "email_verified": True}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")
assert response.status_code == 400
assert response.json()["detail"] == "OIDC userinfo subject does not match id_token subject"
@pytest.mark.asyncio
async def test_oidc_callback_requires_verified_email_claim_when_enabled(
client: AsyncClient, clean_db, oidc_settings, monkeypatch
):
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "signed-sub", "email": "[email protected]"}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")
assert response.status_code == 400
assert response.json()["detail"] == "OIDC email is not verified"
@pytest.mark.asyncio
async def test_oidc_callback_rejects_unlinked_existing_user_by_default(
client: AsyncClient, test_user, oidc_settings, monkeypatch
):
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "new-sub", "email": "[email protected]", "email_verified": True}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")
assert response.status_code == 403
assert response.json()["detail"] == "Existing account is not linked to this OIDC identity"
@pytest.mark.asyncio
async def test_oidc_callback_verified_email_link_mode_links_existing_user(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_existing_user_link_mode = "verified_email"
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "linked-sub", "email": "[email protected]", "email_verified": True}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
await session.refresh(test_user)
assert test_user.oidc_issuer == "https://id.example.com"
assert test_user.oidc_subject == "linked-sub"
@pytest.mark.asyncio
async def test_oidc_callback_rejects_existing_user_with_different_linked_subject(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_existing_user_link_mode = "verified_email"
test_user.oidc_issuer = "https://id.example.com"
test_user.oidc_subject = "original-sub"
session.add(test_user)
await session.commit()
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "different-sub", "email": "[email protected]", "email_verified": True}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")
assert response.status_code == 403
assert response.json()["detail"] == "OIDC identity is linked to a different account"
@pytest.mark.asyncio
async def test_oidc_callback_respects_disabled_registration_setting(
client: AsyncClient, session, clean_db, oidc_settings, monkeypatch
):
oidc_settings.registration_enabled = True
oidc_settings.oidc_auto_register = True
session.add(AppSetting(key="registration_enabled", value="false"))
await session.commit()
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "new-sub", "email": "[email protected]", "email_verified": True}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")
assert response.status_code == 403
assert response.json()["detail"] == "Registration is disabled"
@pytest.mark.asyncio
async def test_oidc_callback_email_link_mode_links_existing_user_without_verified_email(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_existing_user_link_mode = "email"
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "unverified-linked-sub", "email": "[email protected]"}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
await session.refresh(test_user)
assert test_user.oidc_issuer == "https://id.example.com"
assert test_user.oidc_subject == "unverified-linked-sub"
@pytest.mark.asyncio
async def test_oidc_callback_linked_user_can_login_without_verified_email_when_required(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_require_verified_email = True
oidc_settings.oidc_existing_user_link_mode = "verified_email"
test_user.oidc_issuer = "https://id.example.com"
test_user.oidc_subject = "linked-sub"
session.add(test_user)
await session.commit()
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "linked-sub", "email": "[email protected]"}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
@pytest.mark.asyncio
async def test_oidc_callback_linked_user_can_login_without_email_claim(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_require_verified_email = True
test_user.oidc_issuer = "https://id.example.com"
test_user.oidc_subject = "linked-sub"
session.add(test_user)
await session.commit()
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "linked-sub"}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
@pytest.mark.asyncio
async def test_oidc_callback_registration_disabled_does_not_block_existing_email_link(
client: AsyncClient, session, test_user, oidc_settings, monkeypatch
):
oidc_settings.oidc_existing_user_link_mode = "email"
session.add(AppSetting(key="registration_enabled", value="false"))
await session.commit()
fake_redis = FakeRedis()
await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))
async def fake_discover():
return {"issuer": "https://id.example.com"}
async def fake_exchange(discovery, code, code_verifier=""):
return {"id_token": "id-token", "access_token": "provider-token"}
async def fake_decode(discovery, id_token, nonce, access_token=""):
return {"sub": "linked-with-registration-disabled", "email": "[email protected]"}
async def fake_userinfo(discovery, access_token):
return {}
async def fake_get_redis():
return fake_redis
monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)
monkeypatch.setattr(oidc_auth, "_discover", fake_discover)
monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)
monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)
monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)
response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)
assert response.status_code == 307
await session.refresh(test_user)
assert test_user.oidc_subject == "linked-with-registration-disabled"