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.

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.py
index 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 Mapping
from datetime import UTC, datetime
-from unittest.mock import MagicMock
import 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_c
NOW = 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 = None
service, _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 == 0
def 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.events
with 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.INTERNAL
service, _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"