Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

18.3 KB
Raw Blame
from collections.abc import Mapping, Sequence
from dataclasses import dataclass, field

import pytest
from sqlalchemy import Engine, event
from sqlalchemy.orm import sessionmaker

from enums import WebAppAccessMode
from models.enums import CustomizeTokenStrategy
from models.model import App, AppMode, AppModelConfig, Site
from repositories.webapp_access_query_repository import WebAppAccessQueryRepository
from services.webapp_access_query_service import (
    WebAppAccessAppNotFoundError,
    WebAppAccessQueryService,
    WebAppAccessReferenceRequiredError,
    WebAppAccessUnavailableError,
)


@dataclass
class AccessQueryStub:
    app_id: str | None = None
    available: bool = True
    error: Exception | None = None
    calls: list[str] = field(default_factory=list)
    availability_calls: list[str] = field(default_factory=list)

    def find_app_id_by_code(self, app_code: str) -> str | None:
        self.calls.append(app_code)
        if self.error is not None:
            raise self.error
        return self.app_id

    def is_app_available(self, app_id: str) -> bool:
        self.availability_calls.append(app_id)
        if self.error is not None:
            raise self.error
        return self.available


@dataclass
class AccessPolicyStub:
    access_mode: WebAppAccessMode = WebAppAccessMode.PRIVATE
    allowed: bool = True
    access_mode_error: Exception | None = None
    access_mode_calls: list[str] = field(default_factory=list)
    permission_calls: list[tuple[str, str]] = field(default_factory=list)

    def get_access_mode(self, app_id: str) -> WebAppAccessMode:
        self.access_mode_calls.append(app_id)
        if self.access_mode_error is not None:
            raise self.access_mode_error
        return self.access_mode

    def is_user_allowed(self, *, user_id: str, app_id: str) -> bool:
        self.permission_calls.append((user_id, app_id))
        return self.allowed


@dataclass(frozen=True, slots=True)
class ServiceFixture:
    service: WebAppAccessQueryService
    access: AccessQueryStub
    policy: AccessPolicyStub


def _unexpected_access_modes(*, app_ids: Sequence[str]) -> Mapping[str, WebAppAccessMode]:
    raise AssertionError(f"Unexpected batch access mode query: {app_ids}")


def _unexpected_user_permissions(*, user_id: str, app_ids: Sequence[str]) -> Mapping[str, bool]:
    raise AssertionError(f"Unexpected batch permission query: {user_id}, {app_ids}")


def _service(
    *,
    access: AccessQueryStub | None = None,
    enabled: bool = True,
    access_mode: WebAppAccessMode = WebAppAccessMode.PRIVATE,
    allowed: bool = True,
) -> ServiceFixture:
    access = access or AccessQueryStub()
    policy = AccessPolicyStub(access_mode=access_mode, allowed=allowed)
    return ServiceFixture(
        service=WebAppAccessQueryService(
            access=access,
            policy=policy,
            webapp_auth_enabled=enabled,
            get_access_modes=_unexpected_access_modes,
            get_user_permissions=_unexpected_user_permissions,
        ),
        access=access,
        policy=policy,
    )


def test_disabled_auth_returns_public_before_resolving_app() -> None:
    fixture = _service(enabled=False)

    assert fixture.service.get_access_mode(app_id=None, app_code=None) is WebAppAccessMode.PUBLIC
    assert fixture.access.calls == []
    assert fixture.policy.access_mode_calls == []


@pytest.mark.parametrize("enabled", [True, False])
def test_management_reads_configured_policy_without_publication_admission(enabled: bool) -> None:
    fixture = _service(access=AccessQueryStub(available=False), enabled=enabled)

    result = fixture.service.get_configured_access_mode(app_id="draft-app")

    assert result is (WebAppAccessMode.PRIVATE if enabled else WebAppAccessMode.PUBLIC)
    assert fixture.access.calls == []
    assert fixture.access.availability_calls == []
    assert fixture.policy.access_mode_calls == (["draft-app"] if enabled else [])


@pytest.mark.parametrize("enabled", [True, False])
@pytest.mark.parametrize("reference", ["code", "id"])
def test_public_identity_resolution_does_not_load_authentication_settings(enabled: bool, reference: str) -> None:
    fixture = _service(access=AccessQueryStub(app_id="resolved-id"), enabled=enabled)
    result = fixture.service.resolve_app_id(
        **({"app_code": "site-code"} if reference == "code" else {"app_id": "resolved-id"})
    )
    assert result == "resolved-id"
    assert fixture.policy.access_mode_calls == []
    assert fixture.policy.permission_calls == []
    assert fixture.access.calls == (["site-code"] if reference == "code" else [])
    assert fixture.access.availability_calls == (["resolved-id"] if reference == "id" else [])


def test_public_identity_requires_a_reference_even_when_auth_disabled() -> None:
    fixture = _service(enabled=False)
    with pytest.raises(WebAppAccessReferenceRequiredError):
        fixture.service.resolve_app_id()
    assert fixture.policy.access_mode_calls == []
    assert fixture.access.availability_calls == []


@pytest.mark.parametrize("reference", ["code", "id"])
def test_public_identity_dependency_failure_preserves_its_type(reference: str) -> None:
    failure = WebAppAccessUnavailableError("dependency")
    fixture = _service(access=AccessQueryStub(error=failure), enabled=False)
    with pytest.raises(WebAppAccessUnavailableError) as raised:
        fixture.service.resolve_app_id(**({"app_code": "site-code"} if reference == "code" else {"app_id": "app-1"}))
    assert raised.value is failure
    assert fixture.policy.access_mode_calls == []


@pytest.mark.parametrize("enabled", [True, False])
@pytest.mark.parametrize("app_id", [None, "resolved-id"])
def test_nullable_code_lookup_preserves_repository_admission_without_policy_reads(
    enabled: bool, app_id: str | None
) -> None:
    fixture = _service(access=AccessQueryStub(app_id=app_id), enabled=enabled)

    assert fixture.service.find_app_id_by_code("site-code") == app_id
    assert fixture.access.calls == ["site-code"]
    assert fixture.access.availability_calls == []
    assert fixture.policy.access_mode_calls == []
    assert fixture.policy.permission_calls == []


def test_nullable_code_lookup_does_not_turn_dependency_failure_into_missing_app() -> None:
    failure = WebAppAccessUnavailableError("dependency")
    fixture = _service(access=AccessQueryStub(error=failure))

    with pytest.raises(WebAppAccessUnavailableError) as raised:
        fixture.service.find_app_id_by_code("site-code")

    assert raised.value is failure
    assert fixture.policy.access_mode_calls == []


def test_enabled_auth_reads_access_mode_by_app_id() -> None:
    fixture = _service()

    assert fixture.service.get_access_mode(app_id="app-1", app_code=None) is WebAppAccessMode.PRIVATE
    assert fixture.access.calls == []
    assert fixture.access.availability_calls == ["app-1"]
    assert fixture.policy.access_mode_calls == ["app-1"]


def test_app_code_takes_precedence_over_app_id() -> None:
    fixture = _service(
        access=AccessQueryStub(app_id="resolved-id"),
        access_mode=WebAppAccessMode.SSO_VERIFIED,
    )

    assert fixture.service.get_access_mode(app_id="ignored-id", app_code="code-1") is WebAppAccessMode.SSO_VERIFIED
    assert fixture.access.calls == ["code-1"]
    assert fixture.policy.access_mode_calls == ["resolved-id"]
    assert fixture.access.availability_calls == []


def test_missing_app_code_raises_not_found() -> None:
    fixture = _service()

    with pytest.raises(WebAppAccessAppNotFoundError):
        fixture.service.get_access_mode(app_id="must-not-fallback", app_code="missing-code")

    assert fixture.policy.access_mode_calls == []


@pytest.mark.parametrize("enabled", [True, False])
def test_supplied_missing_app_id_is_not_public_when_auth_disabled(enabled: bool) -> None:
    fixture = _service(access=AccessQueryStub(available=False), enabled=enabled)
    with pytest.raises(WebAppAccessAppNotFoundError):
        fixture.service.get_access_mode(app_id="missing-app", app_code=None)
    assert fixture.access.availability_calls == ["missing-app"]
    assert fixture.policy.access_mode_calls == []


def test_disabled_auth_resolves_supplied_missing_code_before_public_shortcut() -> None:
    fixture = _service(enabled=False)
    with pytest.raises(WebAppAccessAppNotFoundError):
        fixture.service.get_access_mode(app_id=None, app_code="missing-code")
    assert fixture.access.calls == ["missing-code"]
    assert fixture.policy.access_mode_calls == []


def test_disabled_auth_returns_public_for_existing_code_without_enterprise_lookup() -> None:
    fixture = _service(access=AccessQueryStub(app_id="resolved-id"), enabled=False)
    assert fixture.service.get_access_mode(app_id=None, app_code="existing-code") is WebAppAccessMode.PUBLIC
    assert fixture.policy.access_mode_calls == []
    assert fixture.access.availability_calls == []


def test_enabled_auth_requires_app_id_or_code() -> None:
    fixture = _service()

    with pytest.raises(WebAppAccessReferenceRequiredError, match="^appId or appCode must be provided$"):
        fixture.service.get_access_mode(app_id=None, app_code=None)

    assert fixture.policy.access_mode_calls == []


def test_repository_failure_is_not_hidden() -> None:
    failure = TypeError("repository bug")
    fixture = _service(access=AccessQueryStub(error=failure))

    with pytest.raises(TypeError) as raised:
        fixture.service.get_access_mode(app_id=None, app_code="code-1")

    assert raised.value is failure


def test_access_mode_failure_is_not_hidden() -> None:
    fixture = _service()
    failure = TypeError("adapter bug")
    fixture.policy.access_mode_error = failure

    with pytest.raises(TypeError) as raised:
        fixture.service.get_access_mode(app_id="app-1", app_code=None)

    assert raised.value is failure


@pytest.mark.parametrize(
    ("access_mode", "expected"),
    [
        pytest.param(WebAppAccessMode.PUBLIC, False, id="public"),
        pytest.param(WebAppAccessMode.SSO_VERIFIED, False, id="sso-verified"),
        pytest.param(WebAppAccessMode.PRIVATE, True, id="private"),
        pytest.param(WebAppAccessMode.PRIVATE_ALL, True, id="private-all"),
    ],
)
def test_requires_permission_check_for_private_modes(access_mode: WebAppAccessMode, expected: bool) -> None:
    fixture = _service(access_mode=access_mode)

    assert fixture.service.requires_permission_check("app-1") is expected
    assert fixture.policy.access_mode_calls == ["app-1"]


def test_disabled_auth_still_reads_configured_mode_before_passport() -> None:
    fixture = _service(enabled=False, access_mode=WebAppAccessMode.PRIVATE)

    assert fixture.service.requires_permission_check("app-1") is True
    assert fixture.policy.access_mode_calls == ["app-1"]


def test_disabled_auth_allows_after_passport_without_querying_user_permission() -> None:
    fixture = _service(enabled=False, allowed=False)

    assert fixture.service.is_user_allowed(user_id="user-1", app_id="app-1") is True
    assert fixture.policy.permission_calls == []


def test_enabled_auth_delegates_user_permission() -> None:
    fixture = _service(allowed=False)

    assert fixture.service.is_user_allowed(user_id="user-1", app_id="app-1") is False
    assert fixture.policy.permission_calls == [("user-1", "app-1")]


@pytest.mark.parametrize("missing", [False, True], ids=["found", "missing"])
def test_app_code_lookup_releases_database_before_access_policy(sqlite_engine: Engine, missing: bool) -> None:
    factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False, close_resets_only=False)
    app_id = "11111111-1111-1111-1111-111111111111"
    with factory.begin() as session:
        config = AppModelConfig(app_id=app_id)
        config.id = "22222222-2222-2222-2222-222222222222"
        session.add(config)
        session.add(
            App(
                id=app_id,
                tenant_id=app_id,
                name="Test App",
                mode=AppMode.CHAT,
                enable_site=True,
                enable_api=True,
                app_model_config_id=config.id,
            )
        )
        session.add(
            Site(
                app_id=app_id,
                code="site-code",
                title="Test Site",
                default_language="en-US",
                customize_token_strategy=CustomizeTokenStrategy.UUID,
            )
        )

    connections: set[object] = set()
    resolved: list[str] = []

    def checkout(connection: object, *_args: object) -> None:
        connections.add(connection)

    def checkin(connection: object, *_args: object) -> None:
        connections.remove(connection)

    class AccessPolicy:
        def get_access_mode(self, app_id: str) -> WebAppAccessMode:
            assert not connections
            resolved.append(app_id)
            return WebAppAccessMode.PRIVATE

        def is_user_allowed(self, *, user_id: str, app_id: str) -> bool:
            raise AssertionError(f"Resolving access mode must not query user permissions: {user_id}, {app_id}")

    service = WebAppAccessQueryService(
        access=WebAppAccessQueryRepository(session_factory=factory),
        webapp_auth_enabled=True,
        policy=AccessPolicy(),
        get_access_modes=_unexpected_access_modes,
        get_user_permissions=_unexpected_user_permissions,
    )
    event.listen(sqlite_engine, "checkout", checkout)
    event.listen(sqlite_engine, "checkin", checkin)
    try:
        if missing:
            with pytest.raises(WebAppAccessAppNotFoundError):
                service.get_access_mode(app_id="must-not-fallback", app_code="missing-code")
            assert resolved == []
        else:
            assert service.get_access_mode(app_id=None, app_code="site-code") is WebAppAccessMode.PRIVATE
            assert resolved == [app_id]
        assert not connections
    finally:
        event.remove(sqlite_engine, "checkout", checkout)
        event.remove(sqlite_engine, "checkin", checkin)


@dataclass
class _BatchQueries:
    access_modes: Mapping[str, WebAppAccessMode] = field(default_factory=dict)
    user_permissions: Mapping[str, bool] = field(default_factory=dict)
    mode_requests: list[tuple[str, ...]] = field(default_factory=list)
    permission_requests: list[tuple[str, tuple[str, ...]]] = field(default_factory=list)
    mode_error: Exception | None = None
    permission_error: Exception | None = None

    def get_access_modes(self, *, app_ids: Sequence[str]) -> Mapping[str, WebAppAccessMode]:
        self.mode_requests.append(tuple(app_ids))
        if self.mode_error is not None:
            raise self.mode_error
        return self.access_modes

    def get_user_permissions(self, *, user_id: str, app_ids: Sequence[str]) -> Mapping[str, bool]:
        self.permission_requests.append((user_id, tuple(app_ids)))
        if self.permission_error is not None:
            raise self.permission_error
        return self.user_permissions

    def find_app_id_by_code(self, app_code: str) -> str | None:
        raise AssertionError(f"Batch queries must not resolve app codes: {app_code}")

    def is_app_available(self, app_id: str) -> bool:
        raise AssertionError(f"Batch queries must not check app availability: {app_id}")

    def get_access_mode(self, app_id: str) -> WebAppAccessMode:
        raise AssertionError(f"Batch queries must not use single-app lookups: {app_id}")

    def is_user_allowed(self, *, user_id: str, app_id: str) -> bool:
        raise AssertionError(f"Batch queries must not use single-app permissions: {user_id}, {app_id}")


def _batch_service(queries: _BatchQueries, *, enabled: bool = True) -> WebAppAccessQueryService:
    return WebAppAccessQueryService(
        access=queries,
        policy=queries,
        webapp_auth_enabled=enabled,
        get_access_modes=queries.get_access_modes,
        get_user_permissions=queries.get_user_permissions,
    )


@pytest.mark.parametrize(
    ("enabled", "app_ids"),
    [
        pytest.param(False, ("app-b", "app-a", "app-b"), id="disabled-auth"),
        pytest.param(False, (), id="disabled-empty"),
        pytest.param(True, (), id="enabled-empty"),
    ],
)
def test_disabled_or_empty_batch_queries_return_public_access_without_external_calls(
    enabled: bool, app_ids: tuple[str, ...]
) -> None:
    queries = _BatchQueries(
        mode_error=AssertionError("Must not query modes"),
        permission_error=AssertionError("Must not query permissions"),
    )
    service = _batch_service(queries, enabled=enabled)

    assert service.batch_get_access_modes(app_ids=app_ids) == dict.fromkeys(app_ids, WebAppAccessMode.PUBLIC)
    assert service.batch_get_user_permissions(user_id="viewer", app_ids=app_ids) == dict.fromkeys(app_ids, True)
    assert queries.mode_requests == []
    assert queries.permission_requests == []


def test_enabled_batch_queries_preserve_order_duplicates_missing_results_and_sso_mode() -> None:
    app_ids = ("private", "sso", "public", "private", "missing")
    queries = _BatchQueries(
        access_modes={
            "private": WebAppAccessMode.PRIVATE,
            "sso": WebAppAccessMode.SSO_VERIFIED,
            "public": WebAppAccessMode.PUBLIC,
        },
        user_permissions={"private": False, "sso": True, "public": True},
    )
    service = _batch_service(queries)

    modes = service.batch_get_access_modes(app_ids=app_ids)
    permissions = service.batch_get_user_permissions(user_id="viewer", app_ids=app_ids)

    assert modes == queries.access_modes
    assert modes["sso"] is WebAppAccessMode.SSO_VERIFIED
    assert "missing" not in modes
    assert permissions == queries.user_permissions
    assert "missing" not in permissions
    assert queries.mode_requests == [app_ids]
    assert queries.permission_requests == [("viewer", app_ids)]


@pytest.mark.parametrize("failure_stage", ["modes", "permissions"])
@pytest.mark.parametrize("failure", [ConnectionError("batch unavailable"), ValueError("invalid batch response")])
def test_batch_callback_errors_propagate_without_wrapping(failure_stage: str, failure: Exception) -> None:
    queries = _BatchQueries(mode_error=failure, permission_error=failure)
    service = _batch_service(queries)

    if failure_stage == "modes":
        with pytest.raises(type(failure)) as raised:
            service.batch_get_access_modes(app_ids=("app-1",))
        assert queries.mode_requests == [("app-1",)]
        assert queries.permission_requests == []
    else:
        with pytest.raises(type(failure)) as raised:
            service.batch_get_user_permissions(user_id="viewer", app_ids=("app-1",))
        assert queries.mode_requests == []
        assert queries.permission_requests == [("viewer", ("app-1",))]
    assert raised.value is failure