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
test: implement web passport fixture protocols (#43394)
Asuka Minato4663d3e5fb4b
diff --git a/api/tests/unit_tests/services/test_web_passport_service.py b/api/tests/unit_tests/services/test_web_passport_service.pyindex 446d4ead07d..e1e91846dc5 100644--- a/api/tests/unit_tests/services/test_web_passport_service.py+++ b/api/tests/unit_tests/services/test_web_passport_service.py@@ -1,5 +1,5 @@+from collections.abc import Mappingfrom datetime import UTC, datetime-from unittest.mock import MagicMockimport pytest@@ -12,8 +12,11 @@ from services.entities.passport_entities import (from services.web_passport_service import (WebAppAuthType,WebPassportAuthenticationRequiredError,+ WebPassportAuthGateway,WebPassportNotFoundError,+ WebPassportRepository,WebPassportService,+ WebPassportTokenGateway,WebPassportUnauthorizedError,)@@ -21,31 +24,86 @@ APP = WebAppRecord(site_id="site-1", app_id="app-1", tenant_id="tenant-1", app_cNOW = datetime(2026, 8, 13, 12, 0, tzinfo=UTC)+class PassportRepository(WebPassportRepository):+ def __init__(self) -> None:+ self.app: WebAppRecord | None = APP+ self.active = True+ self.resolution = WebPassportEndUserResolution(app_active=True, end_user=EndUserRecord(id="end-user-1"))+ self.standard_calls: list[tuple[WebAppRecord, str | None]] = []+ self.authenticated_calls: list[tuple[WebAppRecord, str | None, str | None]] = []+ self.events: list[str] = []++ def get_active_web_app(self, app_code: str) -> WebAppRecord | None:+ assert app_code == "app-code"+ return self.app++ def is_web_app_active(self, app: WebAppRecord) -> bool:+ assert app == APP+ self.events.append("active")+ return self.active++ def resolve_standard_end_user(self, app: WebAppRecord, session_id: str | None) -> WebPassportEndUserResolution:+ self.standard_calls.append((app, session_id))+ return self.resolution++ def resolve_authenticated_end_user(+ self, app: WebAppRecord, *, end_user_id: str | None, session_id: str | None+ ) -> WebPassportEndUserResolution:+ self.authenticated_calls.append((app, end_user_id, session_id))+ return self.resolution+++class PassportAuth(WebPassportAuthGateway):+ def __init__(self) -> None:+ self.enabled = False+ self.auth_type = WebAppAuthType.INTERNAL+ self.enabled_calls = 0+ self.auth_type_calls: list[str] = []+ self.events: list[str] = []++ def is_webapp_auth_enabled(self) -> bool:+ self.enabled_calls += 1+ return self.enabled++ def get_app_auth_type(self, app_id: str) -> WebAppAuthType:+ self.auth_type_calls.append(app_id)+ self.events.append("auth_type")+ return self.auth_type+++class PassportTokens(WebPassportTokenGateway):+ def __init__(self) -> None:+ self.claims: dict[str, object] = {}+ self.token = "issued-token"+ self.verify_calls: list[str] = []+ self.issue_calls: list[dict[str, object]] = []++ def verify(self, token: str) -> Mapping[str, object]:+ self.verify_calls.append(token)+ return self.claims++ def issue(self, payload: Mapping[str, object]) -> str:+ self.issue_calls.append(dict(payload))+ return self.token++def _service(*,- repository: MagicMock | None = None,- auth: MagicMock | None = None,- tokens: MagicMock | None = None,-) -> tuple[WebPassportService, MagicMock, MagicMock, MagicMock]:+ repository: PassportRepository | None = None,+ auth: PassportAuth | None = None,+ tokens: PassportTokens | None = None,+) -> tuple[WebPassportService, PassportRepository, PassportAuth, PassportTokens]:if repository is None:- repository = MagicMock()- repository.get_active_web_app.return_value = APP- repository.is_web_app_active.return_value = True- resolution = WebPassportEndUserResolution(app_active=True, end_user=EndUserRecord(id="end-user-1"))- repository.resolve_standard_end_user.return_value = resolution- repository.resolve_authenticated_end_user.return_value = resolution+ repository = PassportRepository()if auth is None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = False+ auth = PassportAuth()if tokens is None:- tokens = MagicMock()- tokens.issue.return_value = "issued-token"- now = MagicMock(return_value=NOW)+ tokens = PassportTokens()service = WebPassportService(passports=repository,auth=auth,tokens=tokens,- now=now,+ now=lambda: NOW,access_token_expire_minutes=60,)return service, repository, auth, tokens@@ -61,8 +119,8 @@ def test_issue_creates_anonymous_user_and_standard_passport() -> None:result = service.issue(_request())assert result.access_token == "issued-token"- repository.resolve_standard_end_user.assert_called_once_with(APP, None)- tokens.issue.assert_called_once_with(+ assert repository.standard_calls == [(APP, None)]+ assert tokens.issue_calls == [{"iss": "app-1","sub": "Web API Passport",@@ -70,7 +128,7 @@ def test_issue_creates_anonymous_user_and_standard_passport() -> None:"app_code": "app-code","end_user_id": "end-user-1",}- )+ ]def test_issue_reuses_requested_session_user() -> None:@@ -78,48 +136,47 @@ def test_issue_reuses_requested_session_user() -> None:service.issue(_request(user_session_id="existing-session"))- repository.resolve_standard_end_user.assert_called_once_with(APP, "existing-session")+ assert repository.standard_calls == [(APP, "existing-session")]def test_issue_returns_not_found_for_inactive_app() -> None:- repository = MagicMock()- repository.get_active_web_app.return_value = None+ repository = PassportRepository()+ repository.app = Noneservice, _repository, auth, _tokens = _service(repository=repository)with pytest.raises(WebPassportNotFoundError):service.issue(_request())- auth.is_webapp_auth_enabled.assert_not_called()+ assert auth.enabled_calls == 0def test_issue_revalidates_app_after_enterprise_io() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.INTERNAL- tokens = MagicMock()- tokens.verify.return_value = {+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.INTERNAL+ tokens = PassportTokens()+ tokens.claims = {"token_source": "webapp_login_token","auth_type": "internal","session_id": "session-1",}service, repository, _auth, _tokens = _service(auth=auth, tokens=tokens)- def app_is_active(_app: WebAppRecord) -> bool:- auth.get_app_auth_type.assert_called_once_with(APP.app_id)- return False-- repository.is_web_app_active.side_effect = app_is_active+ repository.active = False+ repository.events = auth.eventswith pytest.raises(WebPassportNotFoundError):service.issue(_request(access_token="login-token"))- repository.resolve_authenticated_end_user.assert_not_called()- tokens.issue.assert_not_called()+ assert auth.auth_type_calls == [APP.app_id]+ assert auth.events == ["auth_type", "active"]+ assert repository.authenticated_calls == []+ assert tokens.issue_calls == []def test_issue_returns_not_found_when_app_becomes_inactive_before_user_creation() -> None:service, repository, _auth, tokens = _service()- repository.resolve_standard_end_user.return_value = WebPassportEndUserResolution(+ repository.resolution = WebPassportEndUserResolution(app_active=False,end_user=None,)@@ -127,13 +184,13 @@ def test_issue_returns_not_found_when_app_becomes_inactive_before_user_creation(with pytest.raises(WebPassportNotFoundError):service.issue(_request())- tokens.issue.assert_not_called()+ assert tokens.issue_calls == []def test_issue_requires_login_for_private_webapp() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.INTERNAL+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.INTERNALservice, _repository, _auth, _tokens = _service(auth=auth)with pytest.raises(WebPassportAuthenticationRequiredError):@@ -141,11 +198,11 @@ def test_issue_requires_login_for_private_webapp() -> None:def test_issue_rejects_wrong_login_token_source() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.INTERNAL- tokens = MagicMock()- tokens.verify.return_value = {"token_source": "other"}+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.INTERNAL+ tokens = PassportTokens()+ tokens.claims = {"token_source": "other"}service, _repository, _auth, _tokens = _service(auth=auth, tokens=tokens)with pytest.raises(WebPassportUnauthorizedError, match="token source"):@@ -153,11 +210,11 @@ def test_issue_rejects_wrong_login_token_source() -> None:def test_issue_rejects_auth_type_mismatch() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.EXTERNAL- tokens = MagicMock()- tokens.verify.return_value = {+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.EXTERNAL+ tokens = PassportTokens()+ tokens.claims = {"token_source": "webapp_login_token","auth_type": "internal","session_id": "session-1",@@ -169,11 +226,11 @@ def test_issue_rejects_auth_type_mismatch() -> None:def test_issue_exchanges_enterprise_token_after_user_resolution() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.INTERNAL- tokens = MagicMock()- tokens.verify.return_value = {+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.INTERNAL+ tokens = PassportTokens()+ tokens.claims = {"token_source": "webapp_login_token","user_id": "account-1","end_user_id": "stale-end-user",@@ -181,9 +238,9 @@ def test_issue_exchanges_enterprise_token_after_user_resolution() -> None:"auth_type": "internal","exp": 2_000_000_000,}- tokens.issue.return_value = "enterprise-token"+ tokens.token = "enterprise-token"service, repository, _auth, _tokens = _service(auth=auth, tokens=tokens)- repository.resolve_authenticated_end_user.return_value = WebPassportEndUserResolution(+ repository.resolution = WebPassportEndUserResolution(app_active=True,end_user=EndUserRecord(id="end-user-by-session"),)@@ -191,12 +248,8 @@ def test_issue_exchanges_enterprise_token_after_user_resolution() -> None:result = service.issue(_request(access_token="login-token"))assert result.access_token == "enterprise-token"- repository.resolve_authenticated_end_user.assert_called_once_with(- APP,- end_user_id="stale-end-user",- session_id="session-1",- )- tokens.issue.assert_called_once_with(+ assert repository.authenticated_calls == [(APP, "stale-end-user", "session-1")]+ assert tokens.issue_calls == [{"iss": "site-1","sub": "Web API Passport",@@ -209,17 +262,17 @@ def test_issue_exchanges_enterprise_token_after_user_resolution() -> None:"token_source": "webapp","exp": 2_000_000_000,}- )+ ]def test_issue_requires_session_id_when_enterprise_user_is_missing() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.INTERNAL- tokens = MagicMock()- tokens.verify.return_value = {"token_source": "webapp_login_token", "auth_type": "internal"}+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.INTERNAL+ tokens = PassportTokens()+ tokens.claims = {"token_source": "webapp_login_token", "auth_type": "internal"}service, repository, _auth, _tokens = _service(auth=auth, tokens=tokens)- repository.resolve_authenticated_end_user.return_value = WebPassportEndUserResolution(+ repository.resolution = WebPassportEndUserResolution(app_active=True,end_user=None,)@@ -229,15 +282,15 @@ def test_issue_requires_session_id_when_enterprise_user_is_missing() -> None:def test_public_webapp_verifies_optional_login_token_then_uses_standard_flow() -> None:- auth = MagicMock()- auth.is_webapp_auth_enabled.return_value = True- auth.get_app_auth_type.return_value = WebAppAuthType.PUBLIC- tokens = MagicMock()- tokens.verify.return_value = {"token_source": "webapp_login_token"}- tokens.issue.return_value = "public-token"+ auth = PassportAuth()+ auth.enabled = True+ auth.auth_type = WebAppAuthType.PUBLIC+ tokens = PassportTokens()+ tokens.claims = {"token_source": "webapp_login_token"}+ tokens.token = "public-token"service, _repository, _auth, _tokens = _service(auth=auth, tokens=tokens)service.issue(_request(access_token="login-token"))- tokens.verify.assert_called_once_with("login-token")- assert tokens.issue.call_args.args[0]["iss"] == "app-1"+ assert tokens.verify_calls == ["login-token"]+ assert tokens.issue_calls[0]["iss"] == "app-1"