Skip to content

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

12.0 KB
Raw Blame
"""Tests for the post-deploy OAuth client readiness check (#3248)."""

import io
import logging
from types import SimpleNamespace

import pytest
from cryptography.fernet import Fernet
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from xagent.core.utils.encryption import encrypt_value, get_cipher
from xagent.web import oauth_readiness
from xagent.web.api.auth import _oauth_env_name
from xagent.web.builtin_mcp_registry import get_builtin_oauth_provider_rows
from xagent.web.models.database import Base
from xagent.web.models.oauth_provider import OAuthProvider

KEY_A = Fernet.generate_key().decode()
KEY_B = Fernet.generate_key().decode()
BUILTIN_PROVIDERS = [row["provider_name"] for row in get_builtin_oauth_provider_rows()]


@pytest.fixture(autouse=True)
def clean_env(monkeypatch):
    """No ambient client env var or cached cipher leaks into a test."""
    for provider in [*BUILTIN_PROVIDERS, "custom", "google-sandbox"]:
        for suffix in ("CLIENT_ID", "CLIENT_SECRET"):
            monkeypatch.delenv(_oauth_env_name(provider, suffix), raising=False)
    monkeypatch.setenv("ENCRYPTION_KEY", KEY_A)
    get_cipher.cache_clear()
    yield
    get_cipher.cache_clear()


def _row(provider, client_id="", client_secret=""):
    return SimpleNamespace(
        provider_name=provider, client_id=client_id, client_secret=client_secret
    )


def _set_env(monkeypatch, provider, *, client_id=None, client_secret=None):
    if client_id is not None:
        monkeypatch.setenv(_oauth_env_name(provider, "CLIENT_ID"), client_id)
    if client_secret is not None:
        monkeypatch.setenv(_oauth_env_name(provider, "CLIENT_SECRET"), client_secret)


def test_env_only_is_ready_from_env(monkeypatch):
    _set_env(monkeypatch, "zoom", client_id="env-id", client_secret="env-secret")

    result = oauth_readiness.check_provider("zoom", _row("zoom"))

    assert result.ready
    assert (result.client_id, result.client_secret) == ("env", "env")


def test_row_only_is_ready_from_row():
    row = _row("zoom", encrypt_value("row-id"), encrypt_value("row-secret"))

    result = oauth_readiness.check_provider("zoom", row)

    assert result.ready
    assert (result.client_id, result.client_secret) == ("row", "row")


def test_plaintext_row_counts_as_row():
    """Seed migrations copy the env value into the row unencrypted."""
    result = oauth_readiness.check_provider(
        "zoom", _row("zoom", "row-id", "row-secret")
    )

    assert result.ready
    assert (result.client_id, result.client_secret) == ("row", "row")


def test_row_wins_over_env_when_both_are_set(monkeypatch):
    _set_env(monkeypatch, "zoom", client_id="env-id", client_secret="env-secret")
    row = _row("zoom", encrypt_value("row-id"), encrypt_value("row-secret"))

    result = oauth_readiness.check_provider("zoom", row)

    assert result.ready
    assert (result.client_id, result.client_secret) == ("row", "row")


def test_neither_is_not_ready():
    result = oauth_readiness.check_provider("zoom", _row("zoom"))

    assert not result.ready
    assert (result.client_id, result.client_secret) == ("missing", "missing")


def test_missing_secret_alone_is_not_ready(monkeypatch):
    _set_env(monkeypatch, "zoom", client_id="env-id")

    result = oauth_readiness.check_provider("zoom", _row("zoom"))

    assert not result.ready
    assert (result.client_id, result.client_secret) == ("env", "missing")


def test_row_encrypted_under_another_key_is_unreadable(monkeypatch):
    """The runtime would send the ciphertext as the secret; env cannot rescue it."""
    secret_token = encrypt_value("row-secret")
    monkeypatch.setenv("ENCRYPTION_KEY", KEY_B)
    get_cipher.cache_clear()
    _set_env(monkeypatch, "zoom", client_id="env-id", client_secret="env-secret")

    result = oauth_readiness.check_provider("zoom", _row("zoom", "", secret_token))

    assert not result.ready
    assert (result.client_id, result.client_secret) == ("env", "unreadable")


def test_provider_without_row_is_not_ready(monkeypatch):
    _set_env(monkeypatch, "zoom", client_id="env-id", client_secret="env-secret")

    result = oauth_readiness.check_provider("zoom", None)

    assert not result.ready
    assert not result.has_row


def test_provider_set_is_builtin_union_rows_minus_excluded():
    rows = [_row("google"), _row("google-sandbox")]

    results = oauth_readiness.check_providers(
        rows, builtin_providers=["google", "zoom"], exclude={"zoom"}
    )

    assert [r.provider for r in results] == ["google", "google-sandbox"]


def test_unknown_exclusion_is_rejected():
    with pytest.raises(ValueError, match="zooom"):
        oauth_readiness.check_providers(
            [], builtin_providers=["google", "zoom"], exclude={"zooom"}
        )


def test_format_reports_status_and_source_only():
    ready = oauth_readiness.ProviderReadiness("google", True, "row", "env")
    missing = oauth_readiness.ProviderReadiness("zoom", True, "env", "missing")
    no_row = oauth_readiness.ProviderReadiness("jira", False, "env", "env")
    composio = oauth_readiness.ProviderReadiness(
        "salesforce", False, "missing", "missing", composio_only=True
    )

    assert (
        oauth_readiness.format_result(ready)
        == "PASS oauth-client:google: client_id=row client_secret=env"
    )
    assert (
        oauth_readiness.format_result(missing)
        == "FAIL oauth-client:zoom: client_id=env client_secret=missing"
    )
    assert oauth_readiness.format_result(no_row) == (
        "FAIL oauth-client:jira: no provider row"
    )
    assert oauth_readiness.format_result(composio) == (
        "SKIP oauth-client:salesforce: connects through Composio"
    )


def _set_composio_only(monkeypatch):
    monkeypatch.setenv("XAGENT_SALESFORCE_AUTH_BACKEND", "composio")
    monkeypatch.setenv("COMPOSIO_API_KEY", "key")
    monkeypatch.setenv("COMPOSIO_SALESFORCE_AUTH_CONFIG_ID", "ac_test")
    monkeypatch.setenv("COMPOSIO_USER_ID_SECRET", "secret")


def test_a_composio_only_provider_needs_no_row_or_credentials(monkeypatch):
    _set_composio_only(monkeypatch)

    result = oauth_readiness.check_provider("salesforce", None)

    assert result.composio_only
    assert not result.ready
    assert oauth_readiness.format_result(result) == (
        "SKIP oauth-client:salesforce: connects through Composio"
    )


def test_a_provider_whose_web_connects_stay_native_is_not_skipped(monkeypatch):
    monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", "composio")
    monkeypatch.setenv("COMPOSIO_GMAIL_AUTH_CONFIG_ID", "ac_gmail")
    monkeypatch.setenv("XAGENT_GOOGLE_DRIVE_AUTH_BACKEND", "composio")
    monkeypatch.setenv("COMPOSIO_GOOGLE_DRIVE_AUTH_CONFIG_ID", "ac_drive")
    monkeypatch.setenv("COMPOSIO_API_KEY", "key")
    monkeypatch.setenv("COMPOSIO_USER_ID_SECRET", "secret")

    result = oauth_readiness.check_provider("google", None)

    assert not result.composio_only
    assert oauth_readiness.format_result(result) == (
        "FAIL oauth-client:google: no provider row"
    )


@pytest.fixture
def database(tmp_path, monkeypatch):
    path = tmp_path / "xagent.db"
    engine = create_engine(f"sqlite:///{path}")
    Base.metadata.create_all(engine, tables=[OAuthProvider.__table__])
    monkeypatch.setenv("DATABASE_URL", f"sqlite:///{path}")
    session = sessionmaker(bind=engine)()
    try:
        yield session
    finally:
        session.close()
        engine.dispose()


def _add_provider(db, provider, client_id="", client_secret=""):
    db.add(
        OAuthProvider(
            provider_name=provider,
            name=provider,
            client_id=client_id,
            client_secret=client_secret,
            auth_url="https://provider.example/authorize",
            token_url="https://provider.example/token",
        )
    )


def _run(argv=()):
    out = io.StringIO()
    code = oauth_readiness.main(list(argv), out=out)
    return code, out.getvalue()


def test_main_fails_only_the_provider_whose_secret_is_unset(
    database, monkeypatch, caplog
):
    for index, provider in enumerate(BUILTIN_PROVIDERS):
        _add_provider(database, provider)
        _set_env(
            monkeypatch,
            provider,
            client_id=f"distinctive-client-id-{index}",
            client_secret=f"distinctive-client-secret-{index}",
        )
    database.commit()
    monkeypatch.delenv(_oauth_env_name("zoom", "CLIENT_SECRET"))

    with caplog.at_level(logging.DEBUG):
        code, output = _run()

    assert code == 1
    lines = output.splitlines()
    assert "FAIL oauth-client:zoom: client_id=env client_secret=missing" in lines
    passed = {line.split(":")[1] for line in lines if line.startswith("PASS ")}
    assert passed == set(BUILTIN_PROVIDERS) - {"zoom"}
    assert lines[-1] == f"{len(BUILTIN_PROVIDERS)} checks, 1 failed"
    for text in (output, caplog.text):
        assert "distinctive" not in text


def test_main_never_prints_row_values(database, monkeypatch, caplog):
    for provider in BUILTIN_PROVIDERS:
        _add_provider(
            database,
            provider,
            encrypt_value("distinctive-row-id"),
            encrypt_value("distinctive-row-secret"),
        )
    database.commit()
    # Rows written under KEY_A, read under KEY_B: every field is unreadable.
    monkeypatch.setenv("ENCRYPTION_KEY", KEY_B)
    get_cipher.cache_clear()

    with caplog.at_level(logging.DEBUG):
        code, output = _run()

    assert code == 1
    assert "FAIL oauth-client:zoom: client_id=unreadable client_secret=unreadable" in (
        output
    )
    for text in (output, caplog.text):
        assert "distinctive" not in text
        assert "gAAAA" not in text  # no Fernet token fragment either


def test_main_passes_when_every_provider_is_ready(database, monkeypatch):
    for provider in BUILTIN_PROVIDERS:
        _add_provider(database, provider, "row-id", "row-secret")
    database.commit()

    code, output = _run()

    assert code == 0
    assert output.splitlines()[-1] == f"{len(BUILTIN_PROVIDERS)} checks, 0 failed"


def test_main_skips_a_composio_only_provider(database, monkeypatch):
    for provider in BUILTIN_PROVIDERS:
        if provider != "salesforce":
            _add_provider(database, provider, "row-id", "row-secret")
    database.commit()
    _set_composio_only(monkeypatch)

    code, output = _run()

    assert code == 0
    assert "SKIP oauth-client:salesforce: connects through Composio" in (
        output.splitlines()
    )
    assert output.splitlines()[-1] == f"{len(BUILTIN_PROVIDERS)} checks, 0 failed"


def test_main_excludes_providers(database, monkeypatch):
    for provider in BUILTIN_PROVIDERS:
        if provider not in {"zoom", "xero"}:
            _add_provider(database, provider, "row-id", "row-secret")
    database.commit()

    code, output = _run(["--exclude", "zoom", "--exclude", "xero"])

    assert code == 0
    assert "zoom" not in output and "xero" not in output


def test_main_rejects_an_unknown_exclusion(database):
    with pytest.raises(SystemExit) as exc:
        _run(["--exclude", "zooom"])
    assert exc.value.code == 2


def test_main_reports_a_database_failure_by_class_only(tmp_path, monkeypatch):
    monkeypatch.setenv("DATABASE_URL", f"sqlite:///{tmp_path / 'missing.db'}")

    code, output = _run()

    assert code == 1
    assert output.splitlines() == ["FAIL database: OperationalError"]


@pytest.mark.parametrize("key", [None, "not-a-fernet-key"])
def test_main_fails_once_when_this_process_has_no_usable_key(
    database, monkeypatch, key
):
    """`compose exec` skips the entrypoint that loads ENCRYPTION_KEY from its
    file. The server refuses to start without a valid key in production, so
    this process does not share the server's environment: say so once rather
    than reporting every encrypted row as unreadable."""
    for provider in BUILTIN_PROVIDERS:
        _add_provider(database, provider, encrypt_value("row-id"), "row-secret")
    database.commit()
    monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
    if key is None:
        monkeypatch.delenv("ENCRYPTION_KEY")
    else:
        monkeypatch.setenv("ENCRYPTION_KEY", key)
    get_cipher.cache_clear()

    code, output = _run()

    assert code == 1
    assert output.splitlines() == ["FAIL encryption-key: ValueError"]