Skip to content

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

20.4 KB
Raw Blame
"""End-to-end L1 runs against an in-process fake deployment (#3245).

The fake answers the routes the check calls with the shapes the real ones
return (``/api/auth/login``, ``/api/mcp/apps``, and the
``/api/auth/{provider}/login`` launch start and redeem); no test opens a socket.
"""

import importlib
import io
import json
import sys
from pathlib import Path
from typing import Any
from urllib.parse import parse_qs, urlencode

import httpx
import pytest

# Importable under both pytest and `unittest discover -s tests/scripts`.
_SCRIPTS_DIR = str(Path(__file__).resolve().parents[2] / "scripts")
if _SCRIPTS_DIR not in sys.path:
    sys.path.insert(0, _SCRIPTS_DIR)
cli = importlib.import_module("connector_smoke.cli")

BASE = "https://cloud.example.com"
ACCESS_TOKEN = "access-token-SECRET"
STATE = "state-jwt-SECRET"

REGISTRY_ROWS = [
    {"app_id": "slack", "is_visible_in_connector": True},
    {"app_id": "google-calendar", "is_visible_in_connector": True},
    {"app_id": "notion", "is_visible_in_connector": True},
    {"app_id": "zendesk", "is_visible_in_connector": False},
]


def _catalog_app(
    app_id: str, provider: str | None, auth_type: str, **extra: Any
) -> dict[str, Any]:
    app: dict[str, Any] = {
        "id": app_id,
        "name": app_id,
        "provider": provider,
        "auth_type": auth_type,
        "is_visible_in_connector": True,
        "launch_config": {"env_mapping": {"TOKEN": "access_token"}},
    }
    if provider == "zendesk":
        app["oauth_account_input"] = {"suffix": ".zendesk.com"}
    app.update(extra)
    return app


class FakeDeployment:
    def __init__(self) -> None:
        self.catalog = [
            _catalog_app("slack", "slack", "builtin_oauth"),
            _catalog_app("google-calendar", "google", "builtin_oauth"),
            _catalog_app("notion", None, "mcp_oauth"),
        ]
        self.client_ids = {
            "slack": "slack-client-SECRET",
            "google": "google-client-SECRET",
            "zendesk": "zendesk-client-SECRET",
        }
        self.callback_origin = BASE
        self.shared_callback_origin = "https://global.example.net"
        self.composio_apps: set[str] = set()
        self.requests: list[httpx.Request] = []
        self.launch_bodies: dict[str, dict[str, Any]] = {}
        self.require_login_route = False

    def handler(self, request: httpx.Request) -> httpx.Response:
        self.requests.append(request)
        path = request.url.path
        if path == "/api/auth/login/start":
            return httpx.Response(
                204, headers={"set-cookie": "login_route=route-SECRET; Path=/"}
            )
        if path == "/api/auth/login":
            if self.require_login_route and "login_route=route-SECRET" not in (
                request.headers.get("cookie", "")
            ):
                return httpx.Response(404, json={"detail": "route_token_not_found"})
            body = json.loads(request.content)
            if body.get("password") != "pw":
                return httpx.Response(401, json={"detail": "Invalid credentials"})
            return httpx.Response(200, json={"access_token": ACCESS_TOKEN})
        if request.headers.get("authorization") != f"Bearer {ACCESS_TOKEN}":
            return httpx.Response(401, json={"detail": "Not authenticated"})
        if path == "/api/mcp/apps":
            return httpx.Response(200, json=self.catalog)
        parts = path.split("/")
        if len(parts) == 5 and parts[1:3] == ["api", "auth"] and parts[4] == "login":
            provider = parts[3]
            if request.method == "POST":
                return self._start(provider, request)
            return self._redeem(provider, request)
        return httpx.Response(404)

    def _start(self, provider: str, request: httpx.Request) -> httpx.Response:
        body = json.loads(request.content)
        self.launch_bodies[provider] = body
        ticket = f"ticket-{provider}-SECRET"
        origin = (
            self.shared_callback_origin
            if body.get("app_id") in self.composio_apps
            else self.callback_origin
        )
        return httpx.Response(
            200,
            json={
                "authorization_url": f"/api/auth/{provider}/login?"
                + urlencode({"ticket": ticket}),
                "callback_origin": origin,
            },
        )

    def _redeem(self, provider: str, request: httpx.Request) -> httpx.Response:
        assert parse_qs(request.url.query.decode())["ticket"] == [
            f"ticket-{provider}-SECRET"
        ]
        app_id = self.launch_bodies.get(provider, {}).get("app_id")
        if app_id in self.composio_apps:
            query = urlencode({"state": STATE})
            return httpx.Response(
                307,
                headers={
                    "location": f"{self.shared_callback_origin}"
                    f"/api/auth/meta/callback?{query}"
                },
            )
        client_id = self.client_ids.get(provider, "")
        if not client_id:
            env_name = f"{provider.upper()}_CLIENT_ID"
            return httpx.Response(
                500,
                html="<h1>Error: OAuth provider not configured</h1>"
                f"<p>Missing {env_name} for provider {provider}.</p>",
            )
        query = urlencode(
            {
                "response_type": "code",
                "client_id": client_id,
                "redirect_uri": f"{self.callback_origin}/api/auth/{provider}/callback",
                "state": STATE,
            }
        )
        return httpx.Response(
            307,
            headers={
                "location": f"https://{provider}.example.net/authorize?{query}",
                "set-cookie": "xagent_oauth_state_abc=nonce-SECRET; Path=/",
            },
        )


ENV = {
    "XAGENT_CONNECTOR_SMOKE_BASE_URL": BASE,
    "XAGENT_CONNECTOR_SMOKE_LOGIN": "monitor",
    "XAGENT_CONNECTOR_SMOKE_PASSWORD": "pw",
}


def _run(
    fake: FakeDeployment,
    *args: str,
    env: dict[str, str] | None = None,
    registry_rows: list[dict[str, Any]] | None = None,
) -> tuple[int, list[str]]:
    out = io.StringIO()
    code = cli.main(
        ["l1", *args],
        env={**ENV, **(env or {})},
        registry_rows=REGISTRY_ROWS if registry_rows is None else registry_rows,
        transport=httpx.MockTransport(fake.handler),
        out=out,
    )
    return code, out.getvalue().splitlines()


def _failures(lines: list[str]) -> list[str]:
    return [line for line in lines if line.startswith("FAIL")]


def _failed_checks(lines: list[str]) -> set[str]:
    return {line.split(" ")[1].rstrip(":") for line in _failures(lines)}


def test_healthy_deployment_passes_every_check() -> None:
    code, lines = _run(FakeDeployment())

    assert code == 0, lines
    assert _failures(lines) == []
    assert "PASS catalog:slack" in lines
    assert "PASS oauth:slack:callback" in lines
    assert "PASS oauth:slack:authorize" in lines
    assert "PASS oauth:google:authorize" in lines
    assert lines[-1] == "7 checks, 0 failed"


def test_unset_client_id_fails_only_that_provider() -> None:
    fake = FakeDeployment()
    fake.client_ids["slack"] = ""

    code, lines = _run(fake)

    assert code == 1
    assert _failures(lines) == [
        "FAIL oauth:slack:authorize: no provider redirect: HTTP 500 "
        "(Error: OAuth provider not configured - "
        "Missing SLACK_CLIENT_ID for provider slack.)"
    ]
    assert "PASS oauth:slack:callback" in lines
    assert "PASS oauth:google:authorize" in lines


def test_removed_expected_app_fails_the_catalog_check_by_name() -> None:
    fake = FakeDeployment()
    fake.catalog = [app for app in fake.catalog if app["id"] != "notion"]

    code, lines = _run(fake)

    assert code == 1
    assert _failures(lines) == [
        "FAIL catalog:notion: missing from the catalog (absent or hidden)"
    ]


def test_excluded_app_is_not_expected() -> None:
    fake = FakeDeployment()
    fake.catalog = [app for app in fake.catalog if app["id"] != "notion"]

    code, lines = _run(fake, "--exclude", "notion")

    assert code == 0, lines


def test_redirect_uri_fallback_to_localhost_fails_both_oauth_checks() -> None:
    fake = FakeDeployment()
    fake.callback_origin = "http://localhost:8000"

    code, lines = _run(fake)

    assert code == 1
    assert _failed_checks(lines) == {
        "oauth:slack:callback",
        "oauth:slack:authorize",
        "oauth:google:callback",
        "oauth:google:authorize",
    }


def test_output_never_contains_tokens_tickets_or_redirect_values() -> None:
    fake = FakeDeployment()
    fake.callback_origin = "http://localhost:8000"
    fake.client_ids["google"] = ""

    _, lines = _run(fake)

    output = "\n".join(lines)
    assert "SECRET" not in output
    assert "example.net" not in output


COMPOSIO_REGISTRY_ROWS = [
    {"app_id": "slack", "is_visible_in_connector": True},
    {"app_id": "salesforce", "is_visible_in_connector": True},
]


def _composio_deployment() -> FakeDeployment:
    fake = FakeDeployment()
    fake.catalog = [
        _catalog_app("slack", "slack", "builtin_oauth"),
        _catalog_app(
            "salesforce", "salesforce", "builtin_oauth", auth_backend="composio"
        ),
    ]
    fake.composio_apps = {"salesforce"}
    fake.client_ids.pop("salesforce", None)
    return fake


def test_a_composio_only_provider_needs_no_native_client() -> None:
    code, lines = _run(_composio_deployment(), registry_rows=COMPOSIO_REGISTRY_ROWS)

    assert code == 0, lines
    assert _failures(lines) == []
    assert "PASS oauth:salesforce:composio" in lines
    assert "PASS oauth:slack:callback" in lines
    assert "oauth:salesforce:callback" not in "\n".join(lines)
    assert "state-jwt-SECRET" not in "\n".join(lines)


def _launch_events(fake: FakeDeployment) -> list[tuple[str, str, str | None]]:
    events: list[tuple[str, str, str | None]] = []
    for request in fake.requests:
        parts = request.url.path.split("/")
        if len(parts) != 5 or parts[1:3] != ["api", "auth"] or parts[4] != "login":
            continue
        app_id = None
        if request.method == "POST":
            app_id = json.loads(request.content).get("app_id")
        events.append((request.method, parts[3], app_id))
    return events


def test_each_launch_is_redeemed_before_the_next_one_starts() -> None:
    fake = _composio_deployment()
    code, lines = _run(fake, registry_rows=COMPOSIO_REGISTRY_ROWS)

    assert code == 0, lines
    events = _launch_events(fake)
    redeems = [index for index, event in enumerate(events) if event[0] == "GET"]
    assert len(redeems) == len(events) // 2
    for index in redeems:
        method, provider, app_id = events[index - 1]
        assert (method, provider) == ("POST", events[index][1])
        assert app_id is not None


def test_the_composio_redeem_is_checked_against_its_own_start_origin() -> None:
    fake = _composio_deployment()
    fake.shared_callback_origin = "https://connect.example.net"
    assert fake.shared_callback_origin != BASE

    code, lines = _run(fake, registry_rows=COMPOSIO_REGISTRY_ROWS)

    assert code == 0, lines
    assert "PASS oauth:salesforce:composio" in lines


def test_a_composio_redeem_on_another_origin_than_its_start_fails() -> None:
    fake = _composio_deployment()
    original_redeem = fake._redeem

    def redeem(provider: str, request: httpx.Request) -> httpx.Response:
        if provider != "salesforce":
            return original_redeem(provider, request)
        return httpx.Response(
            307,
            headers={
                "location": "https://elsewhere.example.net"
                f"/api/auth/composio/callback?{urlencode({'state': STATE})}"
            },
        )

    fake._redeem = redeem  # type: ignore[method-assign]

    code, lines = _run(fake, registry_rows=COMPOSIO_REGISTRY_ROWS)

    assert code == 1
    assert _failures(lines) == [
        "FAIL oauth:salesforce:composio: callback origin is "
        "https://elsewhere.example.net, expected https://global.example.net"
    ]


@pytest.mark.parametrize("origin", [None, "", "/relative", "ftp://host"])
def test_a_composio_start_without_a_valid_callback_origin_fails(
    origin: str | None,
) -> None:
    fake = _composio_deployment()
    original_start = fake._start

    def start(provider: str, request: httpx.Request) -> httpx.Response:
        response = original_start(provider, request)
        if provider != "salesforce":
            return response
        payload = json.loads(response.content)
        if origin is None:
            del payload["callback_origin"]
        else:
            payload["callback_origin"] = origin
        return httpx.Response(200, json=payload)

    fake._start = start  # type: ignore[method-assign]

    code, lines = _run(fake, registry_rows=COMPOSIO_REGISTRY_ROWS)

    assert code == 1
    assert _failures(lines) == [
        "FAIL oauth:salesforce:composio: launch start returned no usable "
        "callback origin"
    ]
    assert ("GET", "salesforce", None) not in _launch_events(fake)


def test_a_refused_composio_start_fails_without_a_redeem() -> None:
    fake = _composio_deployment()
    original_start = fake._start

    def start(provider: str, request: httpx.Request) -> httpx.Response:
        if provider != "salesforce":
            return original_start(provider, request)
        return httpx.Response(503, json={"detail": "unavailable"})

    fake._start = start  # type: ignore[method-assign]

    code, lines = _run(fake, registry_rows=COMPOSIO_REGISTRY_ROWS)

    assert code == 1
    (failure,) = _failures(lines)
    assert failure.startswith(
        "FAIL oauth:salesforce:composio: launch start refused: HTTP 503"
    )
    assert ("GET", "salesforce", None) not in _launch_events(fake)


def _real_catalog_app(app_id: str) -> dict[str, Any]:
    """The entry the server's own catalog code builds for a builtin app."""
    from xagent.web.builtin_mcp_registry import get_builtin_public_mcp_app
    from xagent.web.mcp_apps import _app_to_dict
    from xagent.web.models.public_mcp import PublicMCPApp

    row = get_builtin_public_mcp_app(app_id)
    assert row is not None
    return _app_to_dict(PublicMCPApp(**row))


def test_the_facebook_switch_leaves_meta_native_and_adds_no_composio_check(
    monkeypatch,
) -> None:
    monkeypatch.setenv("XAGENT_FACEBOOK_AUTH_BACKEND", "composio")
    monkeypatch.setenv("COMPOSIO_FACEBOOK_AUTH_CONFIG_ID", "ac_facebook")
    monkeypatch.setenv("XAGENT_SALESFORCE_AUTH_BACKEND", "composio")
    monkeypatch.setenv("COMPOSIO_SALESFORCE_AUTH_CONFIG_ID", "ac_salesforce")
    monkeypatch.setenv("COMPOSIO_API_KEY", "key")
    monkeypatch.setenv("COMPOSIO_USER_ID_SECRET", "secret")
    fake = FakeDeployment()
    fake.shared_callback_origin = BASE
    fake.catalog = [_real_catalog_app("facebook"), _real_catalog_app("salesforce")]
    fake.composio_apps = {"salesforce"}
    fake.client_ids["meta"] = "meta-client-SECRET"
    fake.client_ids.pop("salesforce", None)

    code, lines = _run(
        fake,
        registry_rows=[
            {"app_id": "facebook", "is_visible_in_connector": True},
            {"app_id": "salesforce", "is_visible_in_connector": True},
        ],
    )

    assert code == 0, lines
    assert "PASS oauth:meta:callback" in lines
    assert "PASS oauth:meta:authorize" in lines
    assert "PASS oauth:salesforce:composio" in lines
    assert not [line for line in lines if "oauth:meta:composio" in line]
    events = _launch_events(fake)
    assert events == [
        ("POST", "meta", "facebook"),
        ("GET", "meta", None),
        ("POST", "salesforce", "salesforce"),
        ("GET", "salesforce", None),
    ]
    assert [event[1] for event in events if event[0] == "POST"] == [
        event[1] for event in events if event[0] == "GET"
    ]


def test_launch_names_the_catalog_app_and_never_follows_the_redirect() -> None:
    fake = FakeDeployment()

    _run(fake)

    assert fake.launch_bodies == {
        "google": {"app_id": "google-calendar"},
        "slack": {"app_id": "slack"},
    }
    assert all(r.url.host == "cloud.example.com" for r in fake.requests)


def test_saas_login_start_routes_with_the_given_cookies() -> None:
    fake = FakeDeployment()
    fake.require_login_route = True

    code, lines = _run(
        fake,
        "--login-start",
        "--login-field",
        "email",
        env={"XAGENT_CONNECTOR_SMOKE_COOKIES": "selected_region=sg"},
    )

    assert code == 0, lines
    start, login = fake.requests[0], fake.requests[1]
    assert start.url.path == "/api/auth/login/start"
    assert json.loads(start.content) == {"email": "monitor"}
    assert json.loads(login.content) == {"email": "monitor", "password": "pw"}
    for request in fake.requests:
        assert "selected_region=sg" in request.headers["cookie"]
    # The launch's OAuth state cookie is never sent back.
    assert all("nonce-SECRET" not in r.headers["cookie"] for r in fake.requests)
    assert all("login_route" not in r.headers["cookie"] for r in fake.requests[2:])


def test_login_failure_stops_the_run() -> None:
    code, lines = _run(
        FakeDeployment(), env={"XAGENT_CONNECTOR_SMOKE_PASSWORD": "wrong"}
    )

    assert code == 1
    assert lines == ["FAIL login: login failed: HTTP 401", "1 checks, 1 failed"]


def test_account_hosted_provider_needs_an_account_label() -> None:
    fake = FakeDeployment()
    fake.catalog.append(_catalog_app("zendesk", "zendesk", "builtin_oauth"))

    code, lines = _run(fake, "--include", "zendesk")

    assert code == 1
    assert _failures(lines) == [
        "FAIL oauth:zendesk:launch: needs an account label: "
        "pass --oauth-account zendesk=<label>"
    ]
    assert "zendesk" not in fake.launch_bodies


def test_account_label_is_sent_with_the_launch() -> None:
    fake = FakeDeployment()
    fake.catalog.append(_catalog_app("zendesk", "zendesk", "builtin_oauth"))

    code, lines = _run(fake, "--include", "zendesk", "--oauth-account", "zendesk=acme")

    assert code == 0, lines
    assert fake.launch_bodies["zendesk"] == {"app_id": "zendesk", "account": "acme"}


def test_foreign_authorization_url_is_never_requested() -> None:
    fake = FakeDeployment()
    fake.catalog = [_catalog_app("slack", "slack", "builtin_oauth")]
    original_start = fake._start

    def hostile_start(provider: str, request: httpx.Request) -> httpx.Response:
        original_start(provider, request)
        return httpx.Response(
            200,
            json={
                "authorization_url": "https://evil.example.org/api/auth/slack/login?x",
                "callback_origin": BASE,
            },
        )

    fake._start = hostile_start  # type: ignore[method-assign]

    _, lines = _run(fake, "--exclude", "google-calendar", "--exclude", "notion")

    assert _failed_checks(lines) == {"oauth:slack:authorize"}
    assert "unexpected authorization URL" in _failures(lines)[0]
    assert all(r.url.host == "cloud.example.com" for r in fake.requests)


def test_command_line_list_replaces_the_environment_value() -> None:
    fake = FakeDeployment()
    fake.catalog = [app for app in fake.catalog if app["id"] != "notion"]

    code, lines = _run(
        fake,
        "--exclude",
        "notion",
        env={"XAGENT_CONNECTOR_SMOKE_EXCLUDE": "slack,google-calendar"},
    )

    assert code == 0, lines
    assert "PASS catalog:slack" in lines


def test_connection_error_reports_the_class_only() -> None:
    def refuse(request: httpx.Request) -> httpx.Response:
        raise httpx.ConnectError(f"cannot reach {request.url}", request=request)

    out = io.StringIO()
    code = cli.main(
        ["l1"],
        env=ENV,
        registry_rows=REGISTRY_ROWS,
        transport=httpx.MockTransport(refuse),
        out=out,
    )

    assert code == 1
    assert out.getvalue().splitlines()[0] == (
        "FAIL login: POST request failed: ConnectError"
    )


def test_unsendable_request_reports_the_class_only() -> None:
    # httpx refuses a non-ASCII header before sending; that is not an
    # httpx.HTTPError, and its traceback must not reach the output.
    code, lines = _run(FakeDeployment(), "--cookie", "selected_region=s\u00e9")

    assert code == 1
    assert lines[0] == "FAIL login: POST request failed: UnicodeEncodeError"


@pytest.mark.parametrize(
    ("env", "args"),
    [
        ({"XAGENT_CONNECTOR_SMOKE_PASSWORD": ""}, []),
        ({"XAGENT_CONNECTOR_SMOKE_BASE_URL": ""}, []),
        ({}, ["--exclude", "gmail"]),
        ({}, ["--cookie", "no-value"]),
    ],
)
def test_bad_configuration_is_a_usage_error(
    env: dict[str, str], args: list[str]
) -> None:
    with pytest.raises(SystemExit) as exc:
        _run(FakeDeployment(), *args, env=env)

    assert exc.value.code == 2