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 build_transport_security, commit_changes, mcp
from app.storage.db import Database
from app.storage.models import AuditLog, 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_")
with database.session() as session:
audit = session.scalars(
select(AuditLog).where(
AuditLog.entity_id == issued["key_id"],
AuditLog.action == "mcp_key.issue",
)
).first()
assert audit is not None
assert audit.actor_user_id == user.id
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}",
"Host": "127.0.0.1:8001",
"Accept": "application/json, text/event-stream",
},
)
assert authenticated.status_code == 200
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_read_only_key_cannot_mint_write_key(
key_settings: Settings, database: Database
) -> None:
user = _insert_user(database, sub="sub-read-only")
current = to_current_user(user)
issued, token = create_key(database, current, "navi", "Read-only key")
with database.session() as session:
with session.begin():
row = session.get(McpToken, uuid.UUID(issued["key_id"]))
assert row is not None
row.scopes = ["read"]
client = TestClient(app)
headers = {"Authorization": f"Bearer {token}"}
denied = client.post(
"/mcp-keys",
headers=headers,
json={"consumer": "evil", "name": "escalated"},
)
assert denied.status_code == 403
assert (
client.post(
f"/mcp-keys/{issued['key_id']}/rotate", headers=headers
).status_code
== 403
)
assert (
client.delete(f"/mcp-keys/{issued['key_id']}", headers=headers).status_code
== 403
)
assert client.get("/mcp-keys", headers=headers).status_code == 200
def test_commit_changes_requires_write_scope() -> None:
reset = current_mcp_scopes.set(("read",))
try:
result = commit_changes("denied", ["10-systems/example.md"])
assert result == {"error": 403, "detail": "write scope required"}
finally:
current_mcp_scopes.reset(reset)
def test_transport_security_uses_configured_hosts(
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setenv(
"GNEXUS_BOOK_MCP_ALLOWED_HOSTS",
"book.gnexus.space,127.0.0.1:*",
)
security = build_transport_security(Settings())
assert "book.gnexus.space" in security.allowed_hosts
assert "127.0.0.1:*" in security.allowed_hosts
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