Newer
Older
gnexus-book / server / tests / test_mcp_keys.py
from __future__ import annotations

import hashlib
import hmac
import json
import time
import uuid
from datetime import UTC, datetime

import pytest
from fastapi.testclient import TestClient
from sqlalchemy import select
from starlette.responses import JSONResponse

from app.auth.actor import Actor
from app.auth.context import current_actor, current_mcp_scopes
from app.auth.mcp_guard import McpTokenGuard, mcp_actor
from app.auth.mcp_keys import create_key, resolve_mcp_token
from app.auth.sessions import create_session, to_current_user
from app.config import Settings, get_settings
from app.main import app
from app.mcp_http import app as mcp_http_app
from app.mcp_server import mcp
from app.storage.db import Database
from app.storage.models import McpToken, User

AUTH_ENV = {
    "GNEXUS_BOOK_STORAGE_BACKEND": "db",
    "GNEXUS_BOOK_AUTH_CLIENT_ID": "gnexus-book",
    "GNEXUS_BOOK_AUTH_CLIENT_SECRET": "test-client-secret",
    "GNEXUS_BOOK_AUTH_BASE_URL": "https://auth.example.test",
    "GNEXUS_BOOK_AUTH_REDIRECT_URI": "https://book.example.test/auth/callback",
    "GNEXUS_BOOK_AUTH_WEBHOOK_SECRET": "test-webhook-secret",
    "GNEXUS_BOOK_AUTH_COOKIE_SECURE": "false",
    "GNEXUS_BOOK_INTERNAL_KEY_SECRET": "test-internal-secret",
    "GNEXUS_BOOK_INTERNAL_ALLOWLIST": "testclient",
    "GNEXUS_BOOK_MCP_KEY_RATE_LIMIT": "100",
}


@pytest.fixture()
def key_settings(database: Database, monkeypatch: pytest.MonkeyPatch) -> Settings:
    monkeypatch.setenv("GNEXUS_BOOK_DATABASE_URL", database.url)
    for key, value in AUTH_ENV.items():
        monkeypatch.setenv(key, value)
    get_settings.cache_clear()
    return get_settings()


def _insert_user(database: Database, sub: str = "sub-key-user") -> User:
    with database.session() as session:
        with session.begin():
            user = User(
                sub=sub,
                email=f"{sub}@example.test",
                display_name=sub,
                profile={"locale": "en"},
                system_role="admin",
                status="active",
            )
            session.add(user)
            session.flush()
            return user


def _service_headers() -> dict[str, str]:
    return {"X-Service-Key": "test-internal-secret"}


def _sign(body: str, secret: str, timestamp: int) -> str:
    digest = hmac.new(
        secret.encode(), f"{timestamp}.{body}".encode(), hashlib.sha256
    ).hexdigest()
    return f"t={timestamp},v1={digest}"


def test_streamable_http_path_is_protocol_endpoint() -> None:
    assert mcp.settings.streamable_http_path == "/mcp-protocol/"


def test_internal_key_lifecycle(
    key_settings: Settings, database: Database
) -> None:
    user = _insert_user(database)
    client = TestClient(app)

    created = client.post(
        "/internal/keys",
        headers=_service_headers(),
        json={"user_id": user.sub, "consumer": "navi", "name": "Navi key"},
    )
    assert created.status_code == 201, created.text
    issued = created.json()
    assert issued["token"].startswith("mcp_")
    assert issued["consumer"] == "navi"
    assert issued["role"] == "admin"
    assert issued["user_id"] == user.sub

    with database.session() as session:
        row = session.scalars(
            select(McpToken).where(
                McpToken.token_hash
                == hashlib.sha256(issued["token"].encode()).hexdigest()
            )
        ).first()
        assert row is not None
        assert row.token_hash != issued["token"]
        assert row.token_hint == issued["token"][-6:]

    listed = client.get(
        "/internal/keys",
        params={"user_id": user.sub},
        headers=_service_headers(),
    )
    assert listed.status_code == 200
    items = listed.json()["items"]
    assert len(items) == 1
    assert "token" not in items[0]
    assert items[0]["token_hint"] == issued["token"][-6:]

    duplicate = client.post(
        "/internal/keys",
        headers=_service_headers(),
        json={"user_id": user.sub, "consumer": "navi", "name": "Another"},
    )
    assert duplicate.status_code == 409
    assert duplicate.json()["error"] == "key_exists"

    reissued = client.post(
        "/internal/keys",
        headers=_service_headers(),
        json={"user_id": user.sub, "consumer": "navi", "name": "Navi key", "reissue": True},
    )
    assert reissued.status_code == 201
    new_token = reissued.json()["token"]
    assert new_token != issued["token"]
    assert resolve_mcp_token(database, issued["token"]) is None
    assert resolve_mcp_token(database, new_token) is not None

    revoked = client.delete(
        f"/internal/keys/{reissued.json()['key_id']}",
        headers=_service_headers(),
    )
    assert revoked.status_code == 204
    assert resolve_mcp_token(database, new_token) is None


def test_internal_key_validation(
    key_settings: Settings, database: Database, monkeypatch: pytest.MonkeyPatch
) -> None:
    user = _insert_user(database, sub="sub-key-validation")
    client = TestClient(app)

    missing_user = client.post(
        "/internal/keys",
        headers=_service_headers(),
        json={"user_id": "missing", "consumer": "navi"},
    )
    assert missing_user.status_code == 400
    assert missing_user.json()["error"] == "invalid_user_id"

    bad_consumer = client.post(
        "/internal/keys",
        headers=_service_headers(),
        json={"user_id": user.sub, "consumer": "Bad Consumer"},
    )
    assert bad_consumer.status_code == 400

    wrong_secret = client.post(
        "/internal/keys",
        headers={"X-Service-Key": "wrong"},
        json={"user_id": user.sub, "consumer": "navi"},
    )
    assert wrong_secret.status_code == 401

    monkeypatch.setenv("GNEXUS_BOOK_INTERNAL_ALLOWLIST", "127.0.0.1")
    get_settings.cache_clear()
    denied_source = client.post(
        "/internal/keys",
        headers=_service_headers(),
        json={"user_id": user.sub, "consumer": "navi"},
    )
    assert denied_source.status_code == 403


def test_user_key_api_requires_session(
    key_settings: Settings, database: Database
) -> None:
    user = _insert_user(database, sub="sub-user-api")
    token, _ = create_session(database, user.id, 3600)

    anonymous = TestClient(app).get("/mcp-keys")
    assert anonymous.status_code == 401

    client = TestClient(app)
    client.cookies.set("gnb_session", token)

    created = client.post(
        "/mcp-keys", json={"consumer": "claude-code", "name": "Claude Code key"}
    )
    assert created.status_code == 201, created.text
    issued = created.json()
    assert issued["token"].startswith("mcp_")

    listed = client.get("/mcp-keys")
    assert listed.status_code == 200
    assert len(listed.json()["items"]) == 1

    revoked = client.delete(f"/mcp-keys/{issued['key_id']}")
    assert revoked.status_code == 204
    assert resolve_mcp_token(database, issued["token"]) is None


def test_guard_rejects_missing_and_revoked_keys(
    key_settings: Settings, database: Database
) -> None:
    user = _insert_user(database, sub="sub-guard")
    current = to_current_user(user)
    issued, token = create_key(database, current, "navi", "Guard key")
    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": {
            "protocolVersion": "2025-03-26",
            "capabilities": {},
            "clientInfo": {"name": "test", "version": "1"},
        },
    }

    with TestClient(mcp_http_app) as client:
        anonymous = client.post("/mcp-protocol/", json=payload)
        assert anonymous.status_code == 401
        assert anonymous.headers["www-authenticate"] == "Bearer"

        authenticated = client.post(
            "/mcp-protocol/",
            json=payload,
            headers={"Authorization": f"Bearer {token}"},
        )
        assert authenticated.status_code != 401

        with database.session() as session:
            with session.begin():
                row = session.get(McpToken, uuid.UUID(issued["key_id"]))
                assert row is not None
                row.revoked_at = datetime.now(UTC)

        revoked = client.post(
            "/mcp-protocol/",
            json=payload,
            headers={"Authorization": f"Bearer {token}"},
        )
        assert revoked.status_code == 401


class _EchoActorApp:
    async def __call__(self, scope, receive, send) -> None:
        actor = current_actor.get()
        scopes = current_mcp_scopes.get()
        response = JSONResponse(
            {
                "actor_kind": actor.kind if actor else None,
                "actor_name": actor.name if actor else None,
                "via": actor.via if actor else None,
                "scopes": list(scopes or []),
            }
        )
        await response(scope, receive, send)


def test_guard_sets_key_actor_and_scopes(
    key_settings: Settings, database: Database
) -> None:
    user = _insert_user(database, sub="sub-actor")
    current = to_current_user(user)
    _, token = create_key(database, current, "navi", "Actor key")

    guarded = McpTokenGuard(_EchoActorApp(), lambda: key_settings)
    client = TestClient(guarded)
    response = client.get(
        "/anything", headers={"Authorization": f"Bearer {token}"}
    )

    assert response.status_code == 200
    body = response.json()
    assert body["actor_kind"] == "agent"
    assert body["actor_name"] == "Actor key"
    assert body["via"] == "mcp"
    assert body["scopes"] == ["read", "write"]


def test_guard_rate_limits_requests(
    key_settings: Settings,
    database: Database,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    user = _insert_user(database, sub="sub-rate-limit")
    current = to_current_user(user)
    _, token = create_key(database, current, "navi", "Rate key")

    monkeypatch.setenv("GNEXUS_BOOK_MCP_REQUEST_RATE_LIMIT", "1")
    get_settings.cache_clear()
    settings = get_settings()
    guarded = McpTokenGuard(_EchoActorApp(), lambda: settings)
    client = TestClient(guarded)
    headers = {"Authorization": f"Bearer {token}"}

    assert client.get("/anything", headers=headers).status_code == 200
    limited = client.get("/anything", headers=headers)
    assert limited.status_code == 429


def test_is_user_toggles_actor_kind_only() -> None:
    base_actor = Actor(kind="agent", name="Navi key", via="mcp")
    reset = current_actor.set(base_actor)
    try:
        assert mcp_actor(False).kind == "agent"
        assert mcp_actor(True).kind == "user"
        assert mcp_actor(True).name == "Navi key"
        assert mcp_actor(True).via == "mcp"
    finally:
        current_actor.reset(reset)


def test_blocked_user_webhook_revokes_keys(
    key_settings: Settings, database: Database
) -> None:
    user = _insert_user(database, sub="sub-blocked")
    current = to_current_user(user)
    issued, token = create_key(database, current, "navi", "Blocked key")

    body = json.dumps(
        {
            "id": "evt_block_key",
            "type": "user.blocked",
            "target": {"user_id": user.sub},
            "data": {"user": {"id": user.sub, "status": "blocked"}},
        }
    )
    timestamp = int(time.time())
    headers = {
        "X-Gnexus-Event-Id": "evt_block_key",
        "X-Gnexus-Event-Type": "user.blocked",
        "X-Gnexus-Event-Timestamp": str(timestamp),
        "X-Gnexus-Signature": _sign(body, "test-webhook-secret", timestamp),
        "Content-Type": "application/json",
    }
    client = TestClient(app)
    response = client.post("/webhooks/gnexus-auth", content=body, headers=headers)
    assert response.status_code == 200
    assert resolve_mcp_token(database, token) is None

    with database.session() as session:
        row = session.get(McpToken, uuid.UUID(issued["key_id"]))
        assert row is not None and row.revoked_at is not None