Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

19.5 KB
Raw Blame
from __future__ import annotations

import asyncio
import time
from datetime import datetime, timedelta, timezone
from urllib.parse import parse_qs, urlparse

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from starlette.middleware.sessions import SessionMiddleware

from xagent.web.api.auth import auth_router, set_registration_enabled
from xagent.web.models.database import Base, get_db
from xagent.web.models.user import User
from xagent.web.models.user_identity import UserIdentity


def test_exchange_cleanup_preserves_connector_proof_namespaces(oidc_client):
    from xagent.web.api import oidc_google
    from xagent.web.models.oidc_consumed_token import OidcConsumedToken

    _, SessionLocal = oidc_client
    with SessionLocal() as db:
        old = datetime.now(timezone.utc) - timedelta(minutes=5)
        db.add_all(
            [
                OidcConsumedToken(token_id=key, expires_at=old)
                for key in (
                    "oauth-launch:old",
                    "oauth-state:old",
                    "expired-exchange",
                )
            ]
        )
        db.commit()
        code = oidc_google._create_exchange_code(1, None)
        assert oidc_google._consume_exchange_code(db, code) is not None
        keys = {row.token_id for row in db.query(OidcConsumedToken)}
        assert "oauth-launch:old" in keys
        assert "oauth-state:old" in keys
        assert "expired-exchange" not in keys


@pytest.fixture()
def oidc_client(tmp_path, monkeypatch):
    db_path = tmp_path / "oidc.db"
    engine = create_engine(
        f"sqlite:///{db_path}", connect_args={"check_same_thread": False}
    )
    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
    Base.metadata.create_all(bind=engine)

    def override_get_db():
        db = SessionLocal()
        try:
            yield db
        finally:
            db.close()

    monkeypatch.setenv("XAGENT_GOOGLE_OIDC_CLIENT_ID", "google-client-id")
    monkeypatch.setenv("XAGENT_GOOGLE_OIDC_CLIENT_SECRET", "google-client-secret")
    monkeypatch.setenv(
        "XAGENT_GOOGLE_OIDC_REDIRECT_URI",
        "http://testserver/api/auth/oidc/google/callback",
    )
    monkeypatch.setenv("XAGENT_FRONTEND_URL", "http://frontend.local")

    app = FastAPI()
    app.add_middleware(SessionMiddleware, secret_key="test-session-secret")
    app.include_router(auth_router)
    app.dependency_overrides[get_db] = override_get_db

    yield TestClient(app), SessionLocal

    engine.dispose()


def _create_admin(SessionLocal) -> User:
    from xagent.web.api.auth import hash_password
    from xagent.web.models.system_setting import SystemSetting

    db = SessionLocal()
    try:
        user = User(
            username="admin",
            password_hash=hash_password("admin123"),
            is_admin=True,
        )
        db.add(user)
        db.add(SystemSetting(key="setup_completed", value="true"))
        db.commit()
        db.refresh(user)
        return user
    finally:
        db.close()


def _install_google_fakes(monkeypatch, claims: dict[str, object]) -> None:
    async def fake_complete(request, *, redirect_uri: str):
        code = request.query_params.get("code")
        assert code == "google-code"
        assert redirect_uri == "http://testserver/api/auth/oidc/google/callback"
        return claims

    monkeypatch.setattr(
        "xagent.web.api.oidc_google.complete_google_oidc_authorization",
        fake_complete,
    )


class FakeAuthlibGoogleClient:
    def __init__(self, expires_in: int = 3600) -> None:
        self.expires_in = expires_in
        from authlib.integrations.starlette_client.integration import (
            StarletteIntegration,
        )

        self.framework = StarletteIntegration("google")

    async def authorize_redirect(self, request, redirect_uri, **authorize_params):
        from authlib.common.security import generate_token
        from authlib.oauth2.rfc7636 import create_s256_code_challenge
        from starlette.responses import RedirectResponse

        state = generate_token(48)
        nonce = generate_token(20)
        code_verifier = generate_token(48)
        code_challenge = create_s256_code_challenge(code_verifier)
        request.session[f"_state_google_{state}"] = {
            "data": {
                "redirect_uri": redirect_uri,
                "nonce": nonce,
                "code_verifier": code_verifier,
            },
            "exp": time.time() + self.expires_in,
        }
        url = (
            "https://accounts.google.com/o/oauth2/v2/auth"
            f"?response_type=code"
            f"&client_id=google-client-id"
            f"&redirect_uri={redirect_uri}"
            f"&scope=openid+email+profile"
            f"&state={state}"
            f"&nonce={nonce}"
            f"&code_challenge={code_challenge}"
            f"&code_challenge_method=S256"
        )
        if prompt := authorize_params.get("prompt"):
            url = f"{url}&prompt={prompt}"
        return RedirectResponse(url)


def _install_authlib_login_fake(monkeypatch) -> None:
    monkeypatch.setattr(
        "xagent.web.api.oidc_google._google_oauth_client",
        lambda: FakeAuthlibGoogleClient(),
    )


def _start_google_login(client: TestClient) -> str:
    response = client.get("/api/auth/oidc/google/login", follow_redirects=False)
    if response.status_code != 307:
        raise AssertionError(response.text)
    location = response.headers["location"]
    query = parse_qs(urlparse(location).query)
    assert query["client_id"] == ["google-client-id"]
    assert query["scope"] == ["openid email profile"]
    assert query["response_type"] == ["code"]
    assert query["code_challenge_method"] == ["S256"]
    assert query["prompt"] == ["select_account"]
    assert "code_challenge" in query
    assert "state" in query
    assert "nonce" in query
    return query["state"][0]


def _complete_google_callback(client: TestClient, state: str) -> str:
    response = client.get(
        f"/api/auth/oidc/google/callback?code=google-code&state={state}",
        follow_redirects=False,
    )
    assert response.status_code == 307
    redirect = response.headers["location"]
    parsed = urlparse(redirect)
    query = parse_qs(parsed.query)
    assert parsed.scheme == "http"
    assert parsed.netloc == "frontend.local"
    assert parsed.path == "/auth/oidc/callback"
    assert query["provider"] == ["google"]
    assert "code" in query
    return query["code"][0]


def test_google_oidc_login_creates_user_when_registration_enabled(
    oidc_client, monkeypatch
):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)

    claims = {
        "sub": "google-sub-123",
        "email": "[email protected]",
        "email_verified": True,
        "name": "Person Example",
        "picture": "https://example.com/avatar.png",
    }
    _install_google_fakes(monkeypatch, claims)

    state = _start_google_login(client)
    exchange_code = _complete_google_callback(client, state)

    response = client.post(
        "/api/auth/oidc/google/exchange", json={"code": exchange_code}
    )
    assert response.status_code == 200
    data = response.json()
    assert data["success"] is True
    assert data["user"]["username"] == "[email protected]"
    assert data["user"]["email"] == "[email protected]"
    assert data["user"]["is_admin"] is False
    assert data["user"]["has_password"] is False
    assert data["access_token"]
    assert data["refresh_token"]

    db = SessionLocal()
    try:
        user = db.query(User).filter(User.username == "[email protected]").one()
        identity = db.query(UserIdentity).filter(UserIdentity.user_id == user.id).one()
        assert identity.provider == "google"
        assert identity.provider_subject == "google-sub-123"
        assert identity.email == "[email protected]"
        assert identity.email_verified is True
    finally:
        db.close()


def test_google_oidc_status_reports_configuration(oidc_client):
    client, _ = oidc_client

    response = client.get("/api/auth/oidc/google/status")

    assert response.status_code == 200
    assert response.json() == {"configured": True, "provider": "google"}


def test_google_oidc_rejects_new_user_when_registration_disabled(
    oidc_client, monkeypatch
):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    db = SessionLocal()
    try:
        set_registration_enabled(db, False)
    finally:
        db.close()
    _install_authlib_login_fake(monkeypatch)

    _install_google_fakes(
        monkeypatch,
        {
            "sub": "google-sub-456",
            "email": "[email protected]",
            "email_verified": True,
        },
    )

    state = _start_google_login(client)
    response = client.get(
        f"/api/auth/oidc/google/callback?code=google-code&state={state}",
        follow_redirects=False,
    )

    assert response.status_code == 307
    parsed = urlparse(response.headers["location"])
    query = parse_qs(parsed.query)
    assert parsed.path == "/login"
    assert query["oidc_error"] == ["registration_disabled"]

    db = SessionLocal()
    try:
        assert (
            db.query(User).filter(User.username == "[email protected]").first()
            is None
        )
    finally:
        db.close()


def test_google_oidc_rejects_unverified_email(oidc_client, monkeypatch):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)
    _install_google_fakes(
        monkeypatch,
        {
            "sub": "google-sub-789",
            "email": "[email protected]",
            "email_verified": False,
        },
    )

    state = _start_google_login(client)
    response = client.get(
        f"/api/auth/oidc/google/callback?code=google-code&state={state}",
        follow_redirects=False,
    )

    assert response.status_code == 307
    parsed = urlparse(response.headers["location"])
    query = parse_qs(parsed.query)
    assert parsed.path == "/login"
    assert query["oidc_error"] == ["email_unverified"]


def test_google_oidc_exchange_code_is_stateless_across_workers(
    oidc_client, monkeypatch
):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)
    _install_google_fakes(
        monkeypatch,
        {
            "sub": "google-sub-single-use",
            "email": "[email protected]",
            "email_verified": True,
        },
    )

    state = _start_google_login(client)
    exchange_code = _complete_google_callback(client, state)

    from xagent.web.api.oidc_google import _decode_exchange_code

    transaction = _decode_exchange_code(exchange_code)

    assert transaction is not None
    assert isinstance(transaction.user_id, int)
    assert transaction.token_id


def test_google_oidc_exchange_code_rejects_replay(oidc_client, monkeypatch):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)
    _install_google_fakes(
        monkeypatch,
        {
            "sub": "google-sub-replay",
            "email": "[email protected]",
            "email_verified": True,
        },
    )

    state = _start_google_login(client)
    exchange_code = _complete_google_callback(client, state)

    first_response = client.post(
        "/api/auth/oidc/google/exchange", json={"code": exchange_code}
    )
    second_response = client.post(
        "/api/auth/oidc/google/exchange", json={"code": exchange_code}
    )

    assert first_response.status_code == 200
    assert second_response.status_code == 400
    assert second_response.json()["detail"] == "Invalid or expired OIDC exchange code"


def test_google_oidc_exchange_code_rejects_tampering(oidc_client, monkeypatch):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)
    _install_google_fakes(
        monkeypatch,
        {
            "sub": "google-sub-tamper",
            "email": "[email protected]",
            "email_verified": True,
        },
    )

    state = _start_google_login(client)
    exchange_code = _complete_google_callback(client, state)
    tampered_code = f"{exchange_code}x"

    response = client.post(
        "/api/auth/oidc/google/exchange", json={"code": tampered_code}
    )

    assert response.status_code == 400
    assert response.json()["detail"] == "Invalid or expired OIDC exchange code"


def test_existing_google_identity_logs_in_when_registration_disabled(
    oidc_client, monkeypatch
):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)
    db = SessionLocal()
    try:
        user = User(
            username="[email protected]",
            password_hash="!oidc",
            is_admin=False,
        )
        db.add(user)
        db.flush()
        db.add(
            UserIdentity(
                user_id=user.id,
                provider="google",
                provider_subject="linked-google-sub",
                email="[email protected]",
                email_verified=True,
            )
        )
        set_registration_enabled(db, False)
        db.commit()
    finally:
        db.close()

    _install_google_fakes(
        monkeypatch,
        {
            "sub": "linked-google-sub",
            "email": "[email protected]",
            "email_verified": True,
        },
    )

    state = _start_google_login(client)
    exchange_code = _complete_google_callback(client, state)

    response = client.post(
        "/api/auth/oidc/google/exchange", json={"code": exchange_code}
    )
    assert response.status_code == 200
    assert response.json()["user"]["username"] == "[email protected]"


def test_oidc_state_expires(oidc_client, monkeypatch):
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    _install_authlib_login_fake(monkeypatch)

    state = _start_google_login(client)

    async def fake_invalid_state(request, *, redirect_uri: str):
        raise ValueError("invalid_state")

    monkeypatch.setattr(
        "xagent.web.api.oidc_google.complete_google_oidc_authorization",
        fake_invalid_state,
    )
    response = client.get(
        f"/api/auth/oidc/google/callback?code=google-code&state={state}",
        follow_redirects=False,
    )

    assert response.status_code == 307
    query = parse_qs(urlparse(response.headers["location"]).query)
    assert query["oidc_error"] == ["invalid_state"]


def test_google_oidc_login_uses_configured_state_ttl(oidc_client, monkeypatch):
    monkeypatch.setenv("XAGENT_OIDC_LOGIN_TTL_SECONDS", "7")

    from xagent.web.api.oidc_google import _google_oauth_client

    class RequestStub:
        session: dict[str, object] = {}

    started_at = time.time()
    client = _google_oauth_client()
    request = RequestStub()
    asyncio.run(
        client.save_authorize_data(
            request,
            state="short-state",
            redirect_uri="http://testserver/api/auth/oidc/google/callback",
        )
    )

    assert client.framework.expires_in == 7
    assert request.session["_state_google_short-state"]["exp"] == pytest.approx(
        started_at + 7,
        abs=2,
    )


@pytest.mark.parametrize("origin", ["https://legacy.example", "https://new.example"])
def test_dual_entry_google_error_returns_to_bound_entry(
    oidc_client, monkeypatch, origin
):
    import json

    client, _ = oidc_client
    monkeypatch.setenv("XAGENT_APP_BASE_URL", "https://legacy.example")
    monkeypatch.setenv(
        "XAGENT_PUBLIC_ENTRIES_JSON",
        json.dumps(
            [
                {
                    "origin": o,
                    "region_cookie_domain": None,
                    "google_oidc_redirect_uri": o + "/api/auth/oidc/google/callback",
                }
                for o in ["https://legacy.example", "https://new.example"]
            ]
        ),
    )
    _install_authlib_login_fake(monkeypatch)
    started = client.get(origin + "/api/auth/oidc/google/login", follow_redirects=False)
    query = parse_qs(urlparse(started.headers["location"]).query)
    assert query["redirect_uri"] == [origin + "/api/auth/oidc/google/callback"]
    callback = client.get(
        origin + "/api/auth/oidc/google/callback",
        params={"state": query["state"][0], "error": "access_denied"},
        follow_redirects=False,
    )
    assert callback.headers["location"] == origin + "/login?oidc_error=provider_error"


def test_new_exchange_entry_rejection_does_not_consume_code(oidc_client, monkeypatch):
    import json

    from xagent.web.api.oidc_google import _create_exchange_code

    client, sessions = oidc_client
    user = _create_admin(sessions)
    old, new = "https://legacy.example", "https://new.example"
    monkeypatch.setenv("XAGENT_APP_BASE_URL", old)
    monkeypatch.setenv(
        "XAGENT_PUBLIC_ENTRIES_JSON",
        json.dumps(
            [
                {
                    "origin": o,
                    "region_cookie_domain": None,
                    "google_oidc_redirect_uri": o + "/api/auth/oidc/google/callback",
                }
                for o in [old, new]
            ]
        ),
    )
    code = _create_exchange_code(user.id, user.session_epoch, new)
    assert (
        client.post(
            old + "/api/auth/oidc/google/exchange", json={"code": code}
        ).status_code
        == 400
    )
    assert (
        client.post(
            new + "/api/auth/oidc/google/exchange", json={"code": code}
        ).status_code
        == 200
    )
    assert (
        client.post(
            new + "/api/auth/oidc/google/exchange", json={"code": code}
        ).status_code
        == 400
    )
    old_code = _create_exchange_code(user.id, user.session_epoch)
    assert (
        client.post(
            new + "/api/auth/oidc/google/exchange", json={"code": old_code}
        ).status_code
        == 400
    )
    assert (
        client.post(
            old + "/api/auth/oidc/google/exchange", json={"code": old_code}
        ).status_code
        == 200
    )


def test_unconfigured_entries_keep_legacy_google_behavior(oidc_client, monkeypatch):
    """Without explicit entries, origins outside the strict entry grammar work
    and callback errors keep the legacy mapping instead of raising."""
    client, SessionLocal = oidc_client
    _create_admin(SessionLocal)
    monkeypatch.delenv("XAGENT_PUBLIC_ENTRIES_JSON", raising=False)
    monkeypatch.delenv("XAGENT_APP_BASE_URL", raising=False)
    monkeypatch.setenv("XAGENT_FRONTEND_URL", "http://xagent_web:3000")
    _install_authlib_login_fake(monkeypatch)

    _start_google_login(client)

    def callback_error(query: str) -> tuple[str, list[str]]:
        response = client.get(
            f"/api/auth/oidc/google/callback?{query}", follow_redirects=False
        )
        assert response.status_code == 307
        location = urlparse(response.headers["location"])
        return location.netloc, parse_qs(location.query)["oidc_error"]

    assert callback_error("error=access_denied&state=s") == (
        "xagent_web:3000",
        ["provider_error"],
    )
    assert callback_error("code=google-code") == (
        "xagent_web:3000",
        ["invalid_callback"],
    )

    # An unconfigured client fails inside the guarded completion, as before.
    def unconfigured_client():
        raise RuntimeError("Google OIDC is not configured")

    monkeypatch.setattr(
        "xagent.web.api.oidc_google._google_oauth_client", unconfigured_client
    )
    assert callback_error("code=google-code&state=s") == (
        "xagent_web:3000",
        ["callback_failed"],
    )