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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
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