Enterprise agent platform for building, deploying, and operating AI teammates.
"""Authentication must never return a live synchronous ORM object to the loop."""
import asyncio
import os
import threading
import uuid
from contextlib import contextmanager
import pytest
from fastapi import HTTPException
from sqlalchemy import create_engine, event, select, text
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session, sessionmaker
from xagent.web.api import auth
from xagent.web.auth_sessions import hash_refresh_token
from xagent.web.models import auth_database
from xagent.web.models.user import User
@pytest.fixture(params=["sqlite", "postgresql"])
def worker_db(tmp_path, request):
schema = None
if request.param == "postgresql":
url = os.getenv("XAGENT_TEST_AUTH_DATABASE_URL")
if not url:
pytest.skip("Set XAGENT_TEST_AUTH_DATABASE_URL for PostgreSQL")
schema = "sync_auth_test_" + uuid.uuid4().hex
engine = create_engine(
url, execution_options={"schema_translate_map": {None: schema}}
)
with engine.begin() as connection:
connection.execute(text(f'CREATE SCHEMA "{schema}"'))
else:
engine = create_engine(f"sqlite:///{tmp_path / 'auth.db'}")
User.__table__.create(engine)
with Session(engine) as session:
session.add(
User(username="worker", password_hash=auth.hash_password("password123"))
)
session.commit()
events = []
class OwnedSession(Session):
def __init__(self, *args, **kwargs):
events.append(("create", threading.get_ident()))
super().__init__(*args, **kwargs)
def commit(self):
events.append(("commit", threading.get_ident()))
super().commit()
def close(self):
events.append(("close", threading.get_ident()))
super().close()
@event.listens_for(engine, "before_cursor_execute")
def statement(conn, cursor, sql, params, context, executemany):
events.append((sql.split()[0], threading.get_ident()))
factory = sessionmaker(bind=engine, class_=OwnedSession)
try:
yield factory, events, engine
finally:
if schema:
with engine.begin() as connection:
connection.execute(text(f'DROP SCHEMA "{schema}" CASCADE'))
engine.dispose()
@pytest.mark.asyncio
async def test_dependency_is_lazy_and_worker_owned(worker_db, monkeypatch):
factory, events, _ = worker_db
def provider():
with factory() as session:
yield session
monkeypatch.setattr(auth_database, "get_db", provider)
dependency = auth_database.get_auth_db()
lazy_factory = await anext(dependency)
assert events == []
response = await auth.login(
auth.LoginRequest(username="worker", password="password123"), lazy_factory
)
assert response["success"]
await dependency.aclose()
assert len({owner for _, owner in events}) == 1
assert events[0][1] != threading.get_ident()
assert events[-1][0] == "close"
@pytest.mark.asyncio
async def test_login_and_refresh_have_single_thread_owners(worker_db):
factory, events, _ = worker_db
response = await auth.login(
auth.LoginRequest(username="worker", password="password123"), factory
)
assert response["user"]["username"] == "worker"
assert [name for name, _ in events] == [
"create",
"SELECT",
"UPDATE",
"commit",
"close",
]
assert len({owner for _, owner in events}) == 1
assert events[0][1] != threading.get_ident()
events.clear()
# Force a different token so UPDATE is observable even within one JWT second.
from unittest.mock import patch
with patch.object(auth, "create_refresh_token", return_value="rotated-token"):
renewed = await auth.refresh_token(
auth.RefreshTokenRequest(refresh_token=response["refresh_token"]), factory
)
assert renewed.refresh_token == "rotated-token"
assert [name for name, _ in events] == [
"create",
"SELECT",
"UPDATE",
"commit",
"close",
]
assert len({owner for _, owner in events}) == 1
assert events[0][1] != threading.get_ident()
@pytest.mark.asyncio
async def test_commit_failure_rolls_back_and_closes(worker_db, monkeypatch):
factory, events, engine = worker_db
def fail(session):
session.flush()
raise SQLAlchemyError("private-db-detail")
monkeypatch.setattr(factory.class_, "commit", fail)
with pytest.raises(HTTPException) as caught:
await auth.login(
auth.LoginRequest(username="worker", password="password123"), factory
)
assert caught.value.status_code == 500
assert "private-db-detail" not in caught.value.detail
assert events[-1][0] == "close"
with Session(engine) as session:
assert session.scalar(select(User.refresh_token)) is None
@pytest.mark.asyncio
async def test_concurrent_refresh_consumes_token_once(worker_db, monkeypatch):
factory, _, engine = worker_db
logged_in = await auth.login(
auth.LoginRequest(username="worker", password="password123"), factory
)
token = logged_in["refresh_token"]
barrier = threading.Barrier(2)
prepare = auth._prepare_refresh_response
def overlapping_prepare(user, request):
response = prepare(user, request)
# Both independent sessions have validated the same old token before
# either is allowed to attempt its conditional write.
barrier.wait(timeout=10)
return response
monkeypatch.setattr(auth, "_prepare_refresh_response", overlapping_prepare)
results = await asyncio.gather(
*(
auth.refresh_token(auth.RefreshTokenRequest(refresh_token=token), factory)
for _ in range(2)
),
return_exceptions=True,
)
winners = [r for r in results if isinstance(r, auth.RefreshTokenResponse)]
losers = [r for r in results if isinstance(r, HTTPException)]
assert len(winners) == len(losers) == 1, results
assert losers[0].status_code == 401
assert winners[0].refresh_token != token
with Session(engine) as session:
assert session.scalar(select(User.refresh_token)) == hash_refresh_token(
winners[0].refresh_token
)
monkeypatch.setattr(auth, "_prepare_refresh_response", prepare)
with pytest.raises(HTTPException) as caught:
await auth.refresh_token(auth.RefreshTokenRequest(refresh_token=token), factory)
assert caught.value.status_code == 401
def test_refresh_tokens_are_unique_at_identical_time(monkeypatch):
from unittest.mock import Mock
fixed = auth.datetime.now(auth.timezone.utc)
monkeypatch.setattr(auth, "datetime", Mock(now=Mock(return_value=fixed)))
first = auth.create_refresh_token({"sub": "worker", "user_id": 1})
second = auth.create_refresh_token({"sub": "worker", "user_id": 1})
assert first != second
assert (
auth.verify_refresh_token(first)["jti"]
!= auth.verify_refresh_token(second)["jti"]
)
@pytest.mark.parametrize("algorithm", ["HS256", "HS384", "HS512"])
def test_refresh_token_size_is_independent_of_username(monkeypatch, algorithm):
monkeypatch.setattr(auth, "JWT_ALGORITHM", algorithm)
token = auth.create_refresh_token({"sub": "用" * 50, "user_id": 2**63 - 1})
assert len(token) <= User.__table__.c.refresh_token.type.length
payload = auth.verify_refresh_token(token)
assert payload["user_id"] == 2**63 - 1
assert "sub" not in payload
@pytest.mark.asyncio
@pytest.mark.parametrize("username", ["a" * 50, "用" * 50])
async def test_long_username_login_and_legacy_refresh(worker_db, username):
factory, _, engine = worker_db
with Session(engine) as session:
user = session.scalar(select(User))
user.username = username
session.commit()
result = await auth.login(
auth.LoginRequest(username=username, password="password123"), factory
)
assert len(result["refresh_token"]) <= 255
refreshed = await auth.refresh_token(
auth.RefreshTokenRequest(refresh_token=result["refresh_token"]), factory
)
assert len(refreshed.refresh_token) <= 255
assert auth.verify_token(refreshed.access_token)["sub"] == username
# Previously issued refresh JWTs with sub and no jti remain valid.
with Session(engine) as session:
user = session.scalar(select(User))
legacy = auth.jwt.encode(
{
"sub": "worker",
"user_id": user.id,
"type": "refresh",
"exp": auth.datetime.now(auth.timezone.utc) + auth.timedelta(days=1),
},
auth.JWT_SECRET_KEY,
algorithm=auth.JWT_ALGORITHM,
)
user.refresh_token = legacy
session.commit()
renewed = await auth.refresh_token(
auth.RefreshTokenRequest(refresh_token=legacy), factory
)
with Session(engine) as session:
assert session.scalar(select(User.refresh_token)) == hash_refresh_token(
renewed.refresh_token
)
@pytest.mark.asyncio
async def test_refresh_commit_failure_preserves_old_token(worker_db, monkeypatch):
factory, events, engine = worker_db
logged_in = await auth.login(
auth.LoginRequest(username="worker", password="password123"), factory
)
token = logged_in["refresh_token"]
def fail(session):
raise SQLAlchemyError("private-db-detail")
monkeypatch.setattr(factory.class_, "commit", fail)
with pytest.raises(HTTPException) as caught:
await auth.refresh_token(auth.RefreshTokenRequest(refresh_token=token), factory)
assert caught.value.status_code == 503
assert "private-db-detail" not in caught.value.detail
assert events[-1][0] == "close"
with Session(engine) as session:
assert session.scalar(select(User.refresh_token)) == hash_refresh_token(token)
@pytest.mark.asyncio
async def test_login_phase_histograms_use_configured_buckets(worker_db, monkeypatch):
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import InMemoryMetricReader
from xagent.core import runtime_performance as metrics
reader = InMemoryMetricReader()
provider = MeterProvider(
metric_readers=[reader],
views=metrics._histogram_views(),
shutdown_on_exit=False,
)
monkeypatch.setattr(
metrics,
"runtime_performance",
metrics.RuntimePerformanceTelemetry(provider.get_meter("test")),
)
try:
await auth.login(
auth.LoginRequest(username="worker", password="password123"), worker_db[0]
)
recorded = {
metric.name: metric
for resource in reader.get_metrics_data().resource_metrics
for scope in resource.scope_metrics
for metric in scope.metrics
}
for phase in ("sync_lookup", "sync_commit"):
point = recorded[f"xagent.auth.login.{phase}.duration"].data.data_points[0]
assert point.count == 1
assert tuple(point.explicit_bounds) == tuple(metrics._DURATION_BUCKETS_MS)
finally:
provider.shutdown()
@pytest.mark.asyncio
@pytest.mark.parametrize("operation", ["login", "refresh"])
async def test_cancelled_auth_drains_commit_and_close(
worker_db, monkeypatch, operation
):
factory, events, engine = worker_db
token = None
if operation == "refresh":
logged_in = await auth.login(
auth.LoginRequest(username="worker", password="password123"), factory
)
token = logged_in["refresh_token"]
events.clear()
entered = threading.Event()
release = threading.Event()
original = factory.class_.commit
def blocked_commit(session):
entered.set()
assert release.wait(5)
original(session)
monkeypatch.setattr(factory.class_, "commit", blocked_commit)
request = (
auth.refresh_token(auth.RefreshTokenRequest(refresh_token=token), factory)
if operation == "refresh"
else auth.login(
auth.LoginRequest(username="worker", password="password123"), factory
)
)
task = asyncio.create_task(request)
try:
assert await asyncio.to_thread(entered.wait, 5)
task.cancel()
await asyncio.sleep(0)
task.cancel()
await asyncio.sleep(0)
assert not task.done()
assert not any(name == "close" for name, _ in events)
finally:
release.set()
with pytest.raises(asyncio.CancelledError):
await task
assert events[-1][0] == "close"
assert len({owner for _, owner in events}) == 1
# Cancellation cannot promise rollback if commit has already begun.
with Session(engine) as session:
persisted = session.scalar(select(User.refresh_token))
assert persisted is not None
if operation == "refresh":
assert persisted != hash_refresh_token(token)
@pytest.mark.asyncio
async def test_bad_password_closes_without_commit(worker_db):
factory, events, _ = worker_db
with pytest.raises(HTTPException) as caught:
await auth.login(
auth.LoginRequest(username="worker", password="wrong"), factory
)
assert caught.value.status_code == 401
assert [name for name, _ in events] == ["create", "SELECT", "close"]
@pytest.mark.asyncio
async def test_cancelled_worker_before_session_entry_still_closes(worker_db):
factory, events, _ = worker_db
entered = threading.Event()
release = threading.Event()
@contextmanager
def delayed_factory():
entered.set()
assert release.wait(5)
with factory() as session:
yield session
task = asyncio.create_task(
auth.login(
auth.LoginRequest(username="worker", password="password123"),
delayed_factory,
)
)
try:
assert await asyncio.to_thread(entered.wait, 5)
task.cancel()
await asyncio.sleep(0)
assert not task.done()
finally:
release.set()
with pytest.raises(asyncio.CancelledError):
await task
assert events[-1][0] == "close"