Files
0e43340012 feat(openapi): let personal access tokens manage apps, credentials and app API keys (#46510)
Co-authored-by: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
2026-11-20 07:47:09 +00:00

278 lines
10 KiB
Python

from __future__ import annotations
import uuid
from collections.abc import Callable
from typing import Protocol, cast
import pytest
from flask import Flask
from pydantic import ValidationError
from werkzeug.exceptions import NotFound, ServiceUnavailable
from controllers.common.fields import SimpleResultResponse
from controllers.openapi._models import (
MAX_PAGE_LIMIT,
AppDescribeResponse,
PermittedExternalAppsListQuery,
PermittedExternalAppsListResponse,
)
from controllers.openapi._models import (
AppDescribeQuery as _app_discovery_AppDescribeQuery,
)
from controllers.openapi.apps import AppDescribeApi, AppListQuery
from controllers.openapi.apps import AppDescribeQuery as _app_describe_query_AppDescribeQuery
from controllers.openapi.apps_permitted_external import PermittedExternalAppDescribeApi, PermittedExternalAppsListApi
from machinery.context import AppRequestContext, RequestContext
from models.model import AppMode
from services.app.console_service import ConsoleAppNotFoundError
from services.app.query_service import AppDescription
from services.entities.app_entities import AppListParams, AppSummary
from services.errors.app import AppDiscoveryNotFoundError, PermittedAppsUnavailableError
from tests.helpers.unit.controllers.openapi._mode_constants import LISTABLE_MODES, NON_LISTABLE_MODES
from tests.unit_tests.controllers.conftest import ControllerTestServices
"""Unit tests for AppDescribeQuery (`?fields=` allow-list)."""
def test_no_fields_returns_none() -> None:
q = _app_describe_query_AppDescribeQuery.model_validate({})
assert q.fields is None
def test_empty_string_returns_none() -> None:
q = _app_describe_query_AppDescribeQuery.model_validate({"fields": ""})
assert q.fields is None
def test_single_field() -> None:
q = _app_describe_query_AppDescribeQuery.model_validate({"fields": "info"})
assert q.fields == {"info"}
def test_comma_list() -> None:
q = _app_describe_query_AppDescribeQuery.model_validate({"fields": "info,parameters"})
assert q.fields == {"info", "parameters"}
def test_whitespace_tolerant() -> None:
q = _app_describe_query_AppDescribeQuery.model_validate({"fields": " info , input_schema "})
assert q.fields == {"info", "input_schema"}
def test_unknown_member_rejected() -> None:
with pytest.raises(ValidationError):
_app_describe_query_AppDescribeQuery.model_validate({"fields": "garbage"})
def test_unknown_among_known_rejected() -> None:
with pytest.raises(ValidationError):
_app_describe_query_AppDescribeQuery.model_validate({"fields": "info,garbage"})
def test_extra_param_forbidden() -> None:
with pytest.raises(ValidationError):
_app_describe_query_AppDescribeQuery.model_validate({"fields": "info", "page": "1"})
"""Transport mappings over stable admitted contexts."""
class Endpoint[T](Protocol):
__handler__: Callable[..., T]
@pytest.mark.parametrize("api", [AppDescribeApi(), PermittedExternalAppDescribeApi()])
def test_describe_passes_admitted_scope_and_projects_response(
app: Flask,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
api: AppDescribeApi | PermittedExternalAppDescribeApi,
) -> None:
context = AppRequestContext(tenant_id="workspace-id", app_id="app-id")
calls: list[tuple[AppRequestContext, set[str] | None]] = []
def describe(ctx: AppRequestContext, fields: set[str] | None) -> AppDescription:
calls.append((ctx, fields))
return AppDescription(
AppSummary("app-id", "workspace-id", "App", "", AppMode.CHAT, "normal", None, None), True, None
)
monkeypatch.setattr(app_query_services.apps.discovery, "describe", describe)
with app.test_request_context():
result = cast(Endpoint[AppDescribeResponse], api.get).__handler__(
api, context, "app-id", query=_app_discovery_AppDescribeQuery.model_validate({"fields": "info"})
)
assert calls == [(context, {"info"})]
assert result.info is not None
assert result.info.id == "app-id"
assert result.parameters is None
assert result.input_schema is None
@pytest.mark.parametrize("api", [AppDescribeApi(), PermittedExternalAppDescribeApi()])
def test_describe_translates_disappearing_app_to_404(
app: Flask,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
api: AppDescribeApi | PermittedExternalAppDescribeApi,
) -> None:
def missing(*_args: object) -> AppDescription:
raise AppDiscoveryNotFoundError("app not found")
monkeypatch.setattr(app_query_services.apps.discovery, "describe", missing)
context = AppRequestContext(tenant_id="workspace-id", app_id="app-id")
with app.test_request_context(), pytest.raises(NotFound, match="app not found"):
cast(Endpoint[AppDescribeResponse], api.get).__handler__(
api, context, "app-id", query=_app_discovery_AppDescribeQuery()
)
def test_external_failure_is_translated_at_http_boundary(
app: Flask,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
) -> None:
def unavailable(*_args: object) -> None:
raise PermittedAppsUnavailableError("permitted_apps_unavailable")
monkeypatch.setattr(app_query_services.apps.discovery, "list_permitted_apps", unavailable)
api = PermittedExternalAppsListApi()
with app.test_request_context(), pytest.raises(ServiceUnavailable, match="permitted_apps_unavailable"):
cast(Endpoint[PermittedExternalAppsListResponse], api.get).__handler__(
api, query=PermittedExternalAppsListQuery()
)
def _handler(view: Callable[..., object]) -> Callable[..., object]:
"""Return the bare view ``@endpoint`` attaches as ``__handler__``."""
handler = vars(view).get("__handler__")
assert callable(handler)
return handler
def _request_context() -> RequestContext:
return RequestContext(
request_id="request-id", trace_id=None, account_id=str(uuid.uuid4()), active_workspace_id=str(uuid.uuid4())
)
def test_delete_delegates_to_the_console_service(
app: Flask, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
calls: list[tuple[RequestContext, str]] = []
def delete(ctx: RequestContext, app_id: str) -> None:
calls.append((ctx, app_id))
monkeypatch.setattr(app_query_services.apps.console, "delete", delete)
ctx = _request_context()
app_id = str(uuid.uuid4())
api = AppDescribeApi()
with app.test_request_context():
result = _handler(api.delete)(api, ctx, app_id)
assert result == SimpleResultResponse(result="success")
assert calls == [(ctx, app_id)]
def test_delete_translates_a_missing_app_to_404(
app: Flask, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
def missing(_ctx: RequestContext, _app_id: str) -> None:
raise ConsoleAppNotFoundError("app not found")
monkeypatch.setattr(app_query_services.apps.console, "delete", missing)
api = AppDescribeApi()
with app.test_request_context(), pytest.raises(NotFound, match="app not found"):
_handler(api.delete)(api, _request_context(), str(uuid.uuid4()))
"""Unit tests for AppListQuery — the /apps query-param validator.
Runs against the model directly, not the HTTP layer. Pins:
- defaults match the plan (page=1, limit=20).
- workspace_id is required.
- numeric bounds enforced (page >= 1, limit in [1, MAX_PAGE_LIMIT]).
- mode validates against the SupportedAppType enum (listable app types only).
- name has a length cap.
"""
WS_ID = "00000000-0000-0000-0000-000000000001"
def test_defaults() -> None:
q = AppListQuery.model_validate({"workspace_id": WS_ID})
assert q.workspace_id == WS_ID
assert q.page == 1
assert q.limit == 20
assert q.mode is None
assert q.name is None
def test_workspace_id_required() -> None:
with pytest.raises(ValidationError):
AppListQuery.model_validate({})
def test_page_rejects_non_integer_string() -> None:
with pytest.raises(ValidationError):
AppListQuery.model_validate({"workspace_id": WS_ID, "page": "abc"})
def test_limit_caps_at_max_page_limit() -> None:
# Boundary accepts.
"""Given the maximum supported page size, accept that exact limit."""
q = AppListQuery.model_validate({"workspace_id": WS_ID, "limit": MAX_PAGE_LIMIT})
assert q.limit == MAX_PAGE_LIMIT
@pytest.mark.parametrize("mode", LISTABLE_MODES)
def test_mode_accepts_listable_app_types(mode: str) -> None:
q = AppListQuery.model_validate({"workspace_id": WS_ID, "mode": mode})
assert q.mode is not None
assert q.mode.value == mode
def test_mode_rejects_unknown_value() -> None:
with pytest.raises(ValidationError):
AppListQuery.model_validate({"workspace_id": WS_ID, "mode": "not-a-mode"})
@pytest.mark.parametrize("mode", NON_LISTABLE_MODES)
def test_mode_rejects_non_listable_app_modes(mode: str) -> None:
"""rag-pipeline (a knowledge Pipeline), channel (unused) and agent (roster-owned)
are AppMode members but not standalone listable apps — the `app` face rejects them."""
with pytest.raises(ValidationError):
AppListQuery.model_validate({"workspace_id": WS_ID, "mode": mode})
def test_name_length_capped() -> None:
AppListQuery.model_validate({"workspace_id": WS_ID, "name": "x" * 200})
with pytest.raises(ValidationError):
AppListQuery.model_validate({"workspace_id": WS_ID, "name": "x" * 201})
def test_all_fields_accept_valid_values() -> None:
"""Pin the happy-path acceptance for every field in one place."""
q = AppListQuery.model_validate(
{
"workspace_id": WS_ID,
"page": 5,
"limit": 50,
"mode": "workflow",
"name": "search",
}
)
assert q.workspace_id == WS_ID
assert q.page == 5
assert q.limit == 50
assert q.mode is not None
assert q.mode.value == "workflow"
assert q.name == "search"
def test_max_page_limit_is_accepted_by_the_app_service() -> None:
# The catalog advertises MAX_PAGE_LIMIT; the service model must not reject it.
assert AppListParams(limit=MAX_PAGE_LIMIT).limit == MAX_PAGE_LIMIT