-Dify is an open-source LLM app development platform. Its intuitive interface combines agentic AI workflow, RAG pipeline, agent capabilities, model management, observability features, and more, allowing you to quickly move from prototype to production.
+Dify is an open-source platform for developing LLM applications. Its intuitive interface combines agentic AI workflows, RAG pipelines, agent capabilities, model management, observability features, and more—allowing you to quickly move from prototype to production.
## Quick start
diff --git a/api/controllers/console/app/mcp_server.py b/api/controllers/console/app/mcp_server.py
index ccda97d80c..0f53860f56 100644
--- a/api/controllers/console/app/mcp_server.py
+++ b/api/controllers/console/app/mcp_server.py
@@ -92,7 +92,8 @@ class AppMCPServerRefreshController(Resource):
raise NotFound()
server = (
db.session.query(AppMCPServer)
- .filter(AppMCPServer.id == server_id and AppMCPServer.tenant_id == current_user.current_tenant_id)
+ .filter(AppMCPServer.id == server_id)
+ .filter(AppMCPServer.tenant_id == current_user.current_tenant_id)
.first()
)
if not server:
diff --git a/api/core/helper/code_executor/template_transformer.py b/api/core/helper/code_executor/template_transformer.py
index 84f212a9c1..a8e9f41a84 100644
--- a/api/core/helper/code_executor/template_transformer.py
+++ b/api/core/helper/code_executor/template_transformer.py
@@ -5,6 +5,8 @@ from base64 import b64encode
from collections.abc import Mapping
from typing import Any
+from core.variables.utils import SegmentJSONEncoder
+
class TemplateTransformer(ABC):
_code_placeholder: str = "{{code}}"
@@ -95,7 +97,7 @@ class TemplateTransformer(ABC):
@classmethod
def serialize_inputs(cls, inputs: Mapping[str, Any]) -> str:
- inputs_json_str = json.dumps(inputs, ensure_ascii=False).encode()
+ inputs_json_str = json.dumps(inputs, ensure_ascii=False, cls=SegmentJSONEncoder).encode()
input_base64_encoded = b64encode(inputs_json_str).decode("utf-8")
return input_base64_encoded
diff --git a/api/libs/passport.py b/api/libs/passport.py
index 8df4f529bc..fe8fc33b5f 100644
--- a/api/libs/passport.py
+++ b/api/libs/passport.py
@@ -14,9 +14,11 @@ class PassportService:
def verify(self, token):
try:
return jwt.decode(token, self.sk, algorithms=["HS256"])
+ except jwt.exceptions.ExpiredSignatureError:
+ raise Unauthorized("Token has expired.")
except jwt.exceptions.InvalidSignatureError:
raise Unauthorized("Invalid token signature.")
except jwt.exceptions.DecodeError:
raise Unauthorized("Invalid token.")
- except jwt.exceptions.ExpiredSignatureError:
- raise Unauthorized("Token has expired.")
+ except jwt.exceptions.PyJWTError: # Catch-all for other JWT errors
+ raise Unauthorized("Invalid token.")
diff --git a/api/pyproject.toml b/api/pyproject.toml
index 420bc771b6..7f1efa671f 100644
--- a/api/pyproject.toml
+++ b/api/pyproject.toml
@@ -108,7 +108,7 @@ dev = [
"faker~=32.1.0",
"lxml-stubs~=0.5.1",
"mypy~=1.16.0",
- "ruff~=0.11.5",
+ "ruff~=0.12.3",
"pytest~=8.3.2",
"pytest-benchmark~=4.0.0",
"pytest-cov~=4.1.0",
diff --git a/api/services/enterprise/enterprise_service.py b/api/services/enterprise/enterprise_service.py
index 8c06ee9386..54d45f45ea 100644
--- a/api/services/enterprise/enterprise_service.py
+++ b/api/services/enterprise/enterprise_service.py
@@ -29,7 +29,7 @@ class EnterpriseService:
raise ValueError("No data found.")
try:
# parse the UTC timestamp from the response
- return datetime.fromisoformat(data.replace("Z", "+00:00"))
+ return datetime.fromisoformat(data)
except ValueError as e:
raise ValueError(f"Invalid date format: {data}") from e
@@ -40,7 +40,7 @@ class EnterpriseService:
raise ValueError("No data found.")
try:
# parse the UTC timestamp from the response
- return datetime.fromisoformat(data.replace("Z", "+00:00"))
+ return datetime.fromisoformat(data)
except ValueError as e:
raise ValueError(f"Invalid date format: {data}") from e
diff --git a/api/services/entities/knowledge_entities/knowledge_entities.py b/api/services/entities/knowledge_entities/knowledge_entities.py
index 603064ca07..88d4224e97 100644
--- a/api/services/entities/knowledge_entities/knowledge_entities.py
+++ b/api/services/entities/knowledge_entities/knowledge_entities.py
@@ -95,7 +95,7 @@ class WeightKeywordSetting(BaseModel):
class WeightModel(BaseModel):
- weight_type: Optional[str] = None
+ weight_type: Optional[Literal["semantic_first", "keyword_first", "customized"]] = None
vector_setting: Optional[WeightVectorSetting] = None
keyword_setting: Optional[WeightKeywordSetting] = None
diff --git a/api/tests/integration_tests/workflow/nodes/test_llm.py b/api/tests/integration_tests/workflow/nodes/test_llm.py
index 638323f850..8acaa54b9c 100644
--- a/api/tests/integration_tests/workflow/nodes/test_llm.py
+++ b/api/tests/integration_tests/workflow/nodes/test_llm.py
@@ -116,11 +116,11 @@ def test_execute_llm(flask_req_ctx):
mock_usage = LLMUsage(
prompt_tokens=30,
prompt_unit_price=Decimal("0.001"),
- prompt_price_unit=Decimal("1000"),
+ prompt_price_unit=Decimal(1000),
prompt_price=Decimal("0.00003"),
completion_tokens=20,
completion_unit_price=Decimal("0.002"),
- completion_price_unit=Decimal("1000"),
+ completion_price_unit=Decimal(1000),
completion_price=Decimal("0.00004"),
total_tokens=50,
total_price=Decimal("0.00007"),
@@ -219,11 +219,11 @@ def test_execute_llm_with_jinja2(flask_req_ctx, setup_code_executor_mock):
mock_usage = LLMUsage(
prompt_tokens=30,
prompt_unit_price=Decimal("0.001"),
- prompt_price_unit=Decimal("1000"),
+ prompt_price_unit=Decimal(1000),
prompt_price=Decimal("0.00003"),
completion_tokens=20,
completion_unit_price=Decimal("0.002"),
- completion_price_unit=Decimal("1000"),
+ completion_price_unit=Decimal(1000),
completion_price=Decimal("0.00004"),
total_tokens=50,
total_price=Decimal("0.00007"),
diff --git a/api/tests/unit_tests/libs/test_login.py b/api/tests/unit_tests/libs/test_login.py
new file mode 100644
index 0000000000..39671077d4
--- /dev/null
+++ b/api/tests/unit_tests/libs/test_login.py
@@ -0,0 +1,232 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from flask import Flask, g
+from flask_login import LoginManager, UserMixin
+
+from libs.login import _get_user, current_user, login_required
+
+
+class MockUser(UserMixin):
+ """Mock user class for testing."""
+
+ def __init__(self, id: str, is_authenticated: bool = True):
+ self.id = id
+ self._is_authenticated = is_authenticated
+
+ @property
+ def is_authenticated(self):
+ return self._is_authenticated
+
+
+class TestLoginRequired:
+ """Test cases for login_required decorator."""
+
+ @pytest.fixture
+ def setup_app(self, app: Flask):
+ """Set up Flask app with login manager."""
+ # Initialize login manager
+ login_manager = LoginManager()
+ login_manager.init_app(app)
+
+ # Mock unauthorized handler
+ login_manager.unauthorized = MagicMock(return_value="Unauthorized")
+
+ # Add a dummy user loader to prevent exceptions
+ @login_manager.user_loader
+ def load_user(user_id):
+ return None
+
+ return app
+
+ def test_authenticated_user_can_access_protected_view(self, setup_app: Flask):
+ """Test that authenticated users can access protected views."""
+
+ @login_required
+ def protected_view():
+ return "Protected content"
+
+ with setup_app.test_request_context():
+ # Mock authenticated user
+ mock_user = MockUser("test_user", is_authenticated=True)
+ with patch("libs.login._get_user", return_value=mock_user):
+ result = protected_view()
+ assert result == "Protected content"
+
+ def test_unauthenticated_user_cannot_access_protected_view(self, setup_app: Flask):
+ """Test that unauthenticated users are redirected."""
+
+ @login_required
+ def protected_view():
+ return "Protected content"
+
+ with setup_app.test_request_context():
+ # Mock unauthenticated user
+ mock_user = MockUser("test_user", is_authenticated=False)
+ with patch("libs.login._get_user", return_value=mock_user):
+ result = protected_view()
+ assert result == "Unauthorized"
+ setup_app.login_manager.unauthorized.assert_called_once()
+
+ def test_login_disabled_allows_unauthenticated_access(self, setup_app: Flask):
+ """Test that LOGIN_DISABLED config bypasses authentication."""
+
+ @login_required
+ def protected_view():
+ return "Protected content"
+
+ with setup_app.test_request_context():
+ # Mock unauthenticated user and LOGIN_DISABLED
+ mock_user = MockUser("test_user", is_authenticated=False)
+ with patch("libs.login._get_user", return_value=mock_user):
+ with patch("libs.login.dify_config") as mock_config:
+ mock_config.LOGIN_DISABLED = True
+
+ result = protected_view()
+ assert result == "Protected content"
+ # Ensure unauthorized was not called
+ setup_app.login_manager.unauthorized.assert_not_called()
+
+ def test_options_request_bypasses_authentication(self, setup_app: Flask):
+ """Test that OPTIONS requests are exempt from authentication."""
+
+ @login_required
+ def protected_view():
+ return "Protected content"
+
+ with setup_app.test_request_context(method="OPTIONS"):
+ # Mock unauthenticated user
+ mock_user = MockUser("test_user", is_authenticated=False)
+ with patch("libs.login._get_user", return_value=mock_user):
+ result = protected_view()
+ assert result == "Protected content"
+ # Ensure unauthorized was not called
+ setup_app.login_manager.unauthorized.assert_not_called()
+
+ def test_flask_2_compatibility(self, setup_app: Flask):
+ """Test Flask 2.x compatibility with ensure_sync."""
+
+ @login_required
+ def protected_view():
+ return "Protected content"
+
+ # Mock Flask 2.x ensure_sync
+ setup_app.ensure_sync = MagicMock(return_value=lambda: "Synced content")
+
+ with setup_app.test_request_context():
+ mock_user = MockUser("test_user", is_authenticated=True)
+ with patch("libs.login._get_user", return_value=mock_user):
+ result = protected_view()
+ assert result == "Synced content"
+ setup_app.ensure_sync.assert_called_once()
+
+ def test_flask_1_compatibility(self, setup_app: Flask):
+ """Test Flask 1.x compatibility without ensure_sync."""
+
+ @login_required
+ def protected_view():
+ return "Protected content"
+
+ # Remove ensure_sync to simulate Flask 1.x
+ if hasattr(setup_app, "ensure_sync"):
+ delattr(setup_app, "ensure_sync")
+
+ with setup_app.test_request_context():
+ mock_user = MockUser("test_user", is_authenticated=True)
+ with patch("libs.login._get_user", return_value=mock_user):
+ result = protected_view()
+ assert result == "Protected content"
+
+
+class TestGetUser:
+ """Test cases for _get_user function."""
+
+ def test_get_user_returns_user_from_g(self, app: Flask):
+ """Test that _get_user returns user from g._login_user."""
+ mock_user = MockUser("test_user")
+
+ with app.test_request_context():
+ g._login_user = mock_user
+ user = _get_user()
+ assert user == mock_user
+ assert user.id == "test_user"
+
+ def test_get_user_loads_user_if_not_in_g(self, app: Flask):
+ """Test that _get_user loads user if not already in g."""
+ mock_user = MockUser("test_user")
+
+ # Mock login manager
+ login_manager = MagicMock()
+ login_manager._load_user = MagicMock()
+ app.login_manager = login_manager
+
+ with app.test_request_context():
+ # Simulate _load_user setting g._login_user
+ def side_effect():
+ g._login_user = mock_user
+
+ login_manager._load_user.side_effect = side_effect
+
+ user = _get_user()
+ assert user == mock_user
+ login_manager._load_user.assert_called_once()
+
+ def test_get_user_returns_none_without_request_context(self, app: Flask):
+ """Test that _get_user returns None outside request context."""
+ # Outside of request context
+ user = _get_user()
+ assert user is None
+
+
+class TestCurrentUser:
+ """Test cases for current_user proxy."""
+
+ def test_current_user_proxy_returns_authenticated_user(self, app: Flask):
+ """Test that current_user proxy returns authenticated user."""
+ mock_user = MockUser("test_user", is_authenticated=True)
+
+ with app.test_request_context():
+ with patch("libs.login._get_user", return_value=mock_user):
+ assert current_user.id == "test_user"
+ assert current_user.is_authenticated is True
+
+ def test_current_user_proxy_returns_none_when_no_user(self, app: Flask):
+ """Test that current_user proxy handles None user."""
+ with app.test_request_context():
+ with patch("libs.login._get_user", return_value=None):
+ # When _get_user returns None, accessing attributes should fail
+ # or current_user should evaluate to falsy
+ try:
+ # Try to access an attribute that would exist on a real user
+ _ = current_user.id
+ pytest.fail("Should have raised AttributeError")
+ except AttributeError:
+ # This is expected when current_user is None
+ pass
+
+ def test_current_user_proxy_thread_safety(self, app: Flask):
+ """Test that current_user proxy is thread-safe."""
+ import threading
+
+ results = {}
+
+ def check_user_in_thread(user_id: str, index: int):
+ with app.test_request_context():
+ mock_user = MockUser(user_id)
+ with patch("libs.login._get_user", return_value=mock_user):
+ results[index] = current_user.id
+
+ # Create multiple threads with different users
+ threads = []
+ for i in range(5):
+ thread = threading.Thread(target=check_user_in_thread, args=(f"user_{i}", i))
+ threads.append(thread)
+ thread.start()
+
+ # Wait for all threads to complete
+ for thread in threads:
+ thread.join()
+
+ # Verify each thread got its own user
+ for i in range(5):
+ assert results[i] == f"user_{i}"
diff --git a/api/tests/unit_tests/libs/test_passport.py b/api/tests/unit_tests/libs/test_passport.py
new file mode 100644
index 0000000000..f33484c18d
--- /dev/null
+++ b/api/tests/unit_tests/libs/test_passport.py
@@ -0,0 +1,205 @@
+from datetime import UTC, datetime, timedelta
+from unittest.mock import patch
+
+import jwt
+import pytest
+from werkzeug.exceptions import Unauthorized
+
+from libs.passport import PassportService
+
+
+class TestPassportService:
+ """Test PassportService JWT operations"""
+
+ @pytest.fixture
+ def passport_service(self):
+ """Create PassportService instance with test secret key"""
+ with patch("libs.passport.dify_config") as mock_config:
+ mock_config.SECRET_KEY = "test-secret-key-for-testing"
+ return PassportService()
+
+ @pytest.fixture
+ def another_passport_service(self):
+ """Create another PassportService instance with different secret key"""
+ with patch("libs.passport.dify_config") as mock_config:
+ mock_config.SECRET_KEY = "another-secret-key-for-testing"
+ return PassportService()
+
+ # Core functionality tests
+ def test_should_issue_and_verify_token(self, passport_service):
+ """Test complete JWT lifecycle: issue and verify"""
+ payload = {"user_id": "123", "app_code": "test-app"}
+ token = passport_service.issue(payload)
+
+ # Verify token format
+ assert isinstance(token, str)
+ assert len(token.split(".")) == 3 # JWT format: header.payload.signature
+
+ # Verify token content
+ decoded = passport_service.verify(token)
+ assert decoded == payload
+
+ def test_should_handle_different_payload_types(self, passport_service):
+ """Test issuing and verifying tokens with different payload types"""
+ test_cases = [
+ {"string": "value"},
+ {"number": 42},
+ {"float": 3.14},
+ {"boolean": True},
+ {"null": None},
+ {"array": [1, 2, 3]},
+ {"nested": {"key": "value"}},
+ {"unicode": "中文测试"},
+ {"emoji": "🔐"},
+ {}, # Empty payload
+ ]
+
+ for payload in test_cases:
+ token = passport_service.issue(payload)
+ decoded = passport_service.verify(token)
+ assert decoded == payload
+
+ # Security tests
+ def test_should_reject_modified_token(self, passport_service):
+ """Test that any modification to token invalidates it"""
+ token = passport_service.issue({"user": "test"})
+
+ # Test multiple modification points
+ test_positions = [0, len(token) // 3, len(token) // 2, len(token) - 1]
+
+ for pos in test_positions:
+ if pos < len(token) and token[pos] != ".":
+ # Change one character
+ tampered = token[:pos] + ("X" if token[pos] != "X" else "Y") + token[pos + 1 :]
+ with pytest.raises(Unauthorized):
+ passport_service.verify(tampered)
+
+ def test_should_reject_token_with_different_secret_key(self, passport_service, another_passport_service):
+ """Test key isolation - token from one service should not work with another"""
+ payload = {"user_id": "123", "app_code": "test-app"}
+ token = passport_service.issue(payload)
+
+ with pytest.raises(Unauthorized) as exc_info:
+ another_passport_service.verify(token)
+ assert str(exc_info.value) == "401 Unauthorized: Invalid token signature."
+
+ def test_should_use_hs256_algorithm(self, passport_service):
+ """Test that HS256 algorithm is used for signing"""
+ payload = {"test": "data"}
+ token = passport_service.issue(payload)
+
+ # Decode header without relying on JWT internals
+ # Use jwt.get_unverified_header which is a public API
+ header = jwt.get_unverified_header(token)
+ assert header["alg"] == "HS256"
+
+ def test_should_reject_token_with_wrong_algorithm(self, passport_service):
+ """Test rejection of token signed with different algorithm"""
+ payload = {"user_id": "123"}
+
+ # Create token with different algorithm
+ with patch("libs.passport.dify_config") as mock_config:
+ mock_config.SECRET_KEY = "test-secret-key-for-testing"
+ # Create token with HS512 instead of HS256
+ wrong_alg_token = jwt.encode(payload, mock_config.SECRET_KEY, algorithm="HS512")
+
+ # Should fail because service expects HS256
+ # InvalidAlgorithmError is now caught by PyJWTError handler
+ with pytest.raises(Unauthorized) as exc_info:
+ passport_service.verify(wrong_alg_token)
+ assert str(exc_info.value) == "401 Unauthorized: Invalid token."
+
+ # Exception handling tests
+ def test_should_handle_invalid_tokens(self, passport_service):
+ """Test handling of various invalid token formats"""
+ invalid_tokens = [
+ ("not.a.token", "Invalid token."),
+ ("invalid-jwt-format", "Invalid token."),
+ ("xxx.yyy.zzz", "Invalid token."),
+ ("a.b", "Invalid token."), # Missing signature
+ ("", "Invalid token."), # Empty string
+ (" ", "Invalid token."), # Whitespace
+ (None, "Invalid token."), # None value
+ # Malformed base64
+ ("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.INVALID_BASE64!@#$.signature", "Invalid token."),
+ ]
+
+ for invalid_token, expected_message in invalid_tokens:
+ with pytest.raises(Unauthorized) as exc_info:
+ passport_service.verify(invalid_token)
+ assert expected_message in str(exc_info.value)
+
+ def test_should_reject_expired_token(self, passport_service):
+ """Test rejection of expired token"""
+ past_time = datetime.now(UTC) - timedelta(hours=1)
+ payload = {"user_id": "123", "exp": past_time.timestamp()}
+
+ with patch("libs.passport.dify_config") as mock_config:
+ mock_config.SECRET_KEY = "test-secret-key-for-testing"
+ token = jwt.encode(payload, mock_config.SECRET_KEY, algorithm="HS256")
+
+ with pytest.raises(Unauthorized) as exc_info:
+ passport_service.verify(token)
+ assert str(exc_info.value) == "401 Unauthorized: Token has expired."
+
+ # Configuration tests
+ def test_should_handle_empty_secret_key(self):
+ """Test behavior when SECRET_KEY is empty"""
+ with patch("libs.passport.dify_config") as mock_config:
+ mock_config.SECRET_KEY = ""
+ service = PassportService()
+
+ # Empty secret key should still work but is insecure
+ payload = {"test": "data"}
+ token = service.issue(payload)
+ decoded = service.verify(token)
+ assert decoded == payload
+
+ def test_should_handle_none_secret_key(self):
+ """Test behavior when SECRET_KEY is None"""
+ with patch("libs.passport.dify_config") as mock_config:
+ mock_config.SECRET_KEY = None
+ service = PassportService()
+
+ payload = {"test": "data"}
+ # JWT library will raise TypeError when secret is None
+ with pytest.raises((TypeError, jwt.exceptions.InvalidKeyError)):
+ service.issue(payload)
+
+ # Boundary condition tests
+ def test_should_handle_large_payload(self, passport_service):
+ """Test handling of large payload"""
+ # Test with 100KB instead of 1MB for faster tests
+ large_data = "x" * (100 * 1024)
+ payload = {"data": large_data}
+
+ token = passport_service.issue(payload)
+ decoded = passport_service.verify(token)
+
+ assert decoded["data"] == large_data
+
+ def test_should_handle_special_characters_in_payload(self, passport_service):
+ """Test handling of special characters in payload"""
+ special_payloads = [
+ {"special": "!@#$%^&*()"},
+ {"quotes": 'He said "Hello"'},
+ {"backslash": "path\\to\\file"},
+ {"newline": "line1\nline2"},
+ {"unicode": "🔐🔑🛡️"},
+ {"mixed": "Test123!@#中文🔐"},
+ ]
+
+ for payload in special_payloads:
+ token = passport_service.issue(payload)
+ decoded = passport_service.verify(token)
+ assert decoded == payload
+
+ def test_should_catch_generic_pyjwt_errors(self, passport_service):
+ """Test that generic PyJWTError exceptions are caught and converted to Unauthorized"""
+ # Mock jwt.decode to raise a generic PyJWTError
+ with patch("libs.passport.jwt.decode") as mock_decode:
+ mock_decode.side_effect = jwt.exceptions.PyJWTError("Generic JWT error")
+
+ with pytest.raises(Unauthorized) as exc_info:
+ passport_service.verify("some-token")
+ assert str(exc_info.value) == "401 Unauthorized: Invalid token."
diff --git a/api/tests/unit_tests/services/services_test_help.py b/api/tests/unit_tests/services/services_test_help.py
new file mode 100644
index 0000000000..c6b962f7fc
--- /dev/null
+++ b/api/tests/unit_tests/services/services_test_help.py
@@ -0,0 +1,59 @@
+from unittest.mock import MagicMock
+
+
+class ServiceDbTestHelper:
+ """
+ Helper class for service database query tests.
+ """
+
+ @staticmethod
+ def setup_db_query_filter_by_mock(mock_db, query_results):
+ """
+ Smart database query mock that responds based on model type and query parameters.
+
+ Args:
+ mock_db: Mock database session
+ query_results: Dict mapping (model_name, filter_key, filter_value) to return value
+ Example: {('Account', 'email', 'test@example.com'): mock_account}
+ """
+
+ def query_side_effect(model):
+ mock_query = MagicMock()
+
+ def filter_by_side_effect(**kwargs):
+ mock_filter_result = MagicMock()
+
+ def first_side_effect():
+ # Find matching result based on model and filter parameters
+ for (model_name, filter_key, filter_value), result in query_results.items():
+ if model.__name__ == model_name and filter_key in kwargs and kwargs[filter_key] == filter_value:
+ return result
+ return None
+
+ mock_filter_result.first.side_effect = first_side_effect
+
+ # Handle order_by calls for complex queries
+ def order_by_side_effect(*args, **kwargs):
+ mock_order_result = MagicMock()
+
+ def order_first_side_effect():
+ # Look for order_by results in the same query_results dict
+ for (model_name, filter_key, filter_value), result in query_results.items():
+ if (
+ model.__name__ == model_name
+ and filter_key == "order_by"
+ and filter_value == "first_available"
+ ):
+ return result
+ return None
+
+ mock_order_result.first.side_effect = order_first_side_effect
+ return mock_order_result
+
+ mock_filter_result.order_by.side_effect = order_by_side_effect
+ return mock_filter_result
+
+ mock_query.filter_by.side_effect = filter_by_side_effect
+ return mock_query
+
+ mock_db.session.query.side_effect = query_side_effect
diff --git a/api/tests/unit_tests/services/test_account_service.py b/api/tests/unit_tests/services/test_account_service.py
new file mode 100644
index 0000000000..13900ab6d1
--- /dev/null
+++ b/api/tests/unit_tests/services/test_account_service.py
@@ -0,0 +1,1545 @@
+import json
+from datetime import datetime, timedelta
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from configs import dify_config
+from models.account import Account
+from services.account_service import AccountService, RegisterService, TenantService
+from services.errors.account import (
+ AccountAlreadyInTenantError,
+ AccountLoginError,
+ AccountNotFoundError,
+ AccountPasswordError,
+ AccountRegisterError,
+ CurrentPasswordIncorrectError,
+)
+from tests.unit_tests.services.services_test_help import ServiceDbTestHelper
+
+
+class TestAccountAssociatedDataFactory:
+ """Factory class for creating test data and mock objects for account service tests."""
+
+ @staticmethod
+ def create_account_mock(
+ account_id: str = "user-123",
+ email: str = "test@example.com",
+ name: str = "Test User",
+ status: str = "active",
+ password: str = "hashed_password",
+ password_salt: str = "salt",
+ interface_language: str = "en-US",
+ interface_theme: str = "light",
+ timezone: str = "UTC",
+ **kwargs,
+ ) -> MagicMock:
+ """Create a mock account with specified attributes."""
+ account = MagicMock(spec=Account)
+ account.id = account_id
+ account.email = email
+ account.name = name
+ account.status = status
+ account.password = password
+ account.password_salt = password_salt
+ account.interface_language = interface_language
+ account.interface_theme = interface_theme
+ account.timezone = timezone
+ # Set last_active_at to a datetime object that's older than 10 minutes
+ account.last_active_at = datetime.now() - timedelta(minutes=15)
+ account.initialized_at = None
+ for key, value in kwargs.items():
+ setattr(account, key, value)
+ return account
+
+ @staticmethod
+ def create_tenant_join_mock(
+ tenant_id: str = "tenant-456",
+ account_id: str = "user-123",
+ current: bool = True,
+ role: str = "normal",
+ **kwargs,
+ ) -> MagicMock:
+ """Create a mock tenant account join record."""
+ tenant_join = MagicMock()
+ tenant_join.tenant_id = tenant_id
+ tenant_join.account_id = account_id
+ tenant_join.current = current
+ tenant_join.role = role
+ for key, value in kwargs.items():
+ setattr(tenant_join, key, value)
+ return tenant_join
+
+ @staticmethod
+ def create_feature_service_mock(allow_register: bool = True):
+ """Create a mock feature service."""
+ mock_service = MagicMock()
+ mock_service.get_system_features.return_value.is_allow_register = allow_register
+ return mock_service
+
+ @staticmethod
+ def create_billing_service_mock(email_frozen: bool = False):
+ """Create a mock billing service."""
+ mock_service = MagicMock()
+ mock_service.is_email_in_freeze.return_value = email_frozen
+ return mock_service
+
+
+class TestAccountService:
+ """
+ Comprehensive unit tests for AccountService methods.
+
+ This test suite covers all account-related operations including:
+ - Authentication and login
+ - Account creation and registration
+ - Password management
+ - JWT token generation
+ - User loading and tenant management
+ - Error conditions and edge cases
+ """
+
+ @pytest.fixture
+ def mock_db_dependencies(self):
+ """Common mock setup for database dependencies."""
+ with patch("services.account_service.db") as mock_db:
+ mock_db.session.add = MagicMock()
+ mock_db.session.commit = MagicMock()
+ yield {
+ "db": mock_db,
+ }
+
+ @pytest.fixture
+ def mock_password_dependencies(self):
+ """Mock setup for password-related functions."""
+ with (
+ patch("services.account_service.compare_password") as mock_compare_password,
+ patch("services.account_service.hash_password") as mock_hash_password,
+ patch("services.account_service.valid_password") as mock_valid_password,
+ ):
+ yield {
+ "compare_password": mock_compare_password,
+ "hash_password": mock_hash_password,
+ "valid_password": mock_valid_password,
+ }
+
+ @pytest.fixture
+ def mock_external_service_dependencies(self):
+ """Mock setup for external service dependencies."""
+ with (
+ patch("services.account_service.FeatureService") as mock_feature_service,
+ patch("services.account_service.BillingService") as mock_billing_service,
+ patch("services.account_service.PassportService") as mock_passport_service,
+ ):
+ yield {
+ "feature_service": mock_feature_service,
+ "billing_service": mock_billing_service,
+ "passport_service": mock_passport_service,
+ }
+
+ @pytest.fixture
+ def mock_db_with_autospec(self):
+ """
+ Mock database with autospec for more realistic behavior.
+ This approach preserves the actual method signatures and behavior.
+ """
+ with patch("services.account_service.db", autospec=True) as mock_db:
+ # Create a more realistic session mock
+ mock_session = MagicMock()
+ mock_db.session = mock_session
+
+ # Setup basic session methods
+ mock_session.add = MagicMock()
+ mock_session.commit = MagicMock()
+ mock_session.query = MagicMock()
+
+ yield mock_db
+
+ def _assert_database_operations_called(self, mock_db):
+ """Helper method to verify database operations were called."""
+ mock_db.session.commit.assert_called()
+
+ def _assert_database_operations_not_called(self, mock_db):
+ """Helper method to verify database operations were not called."""
+ mock_db.session.commit.assert_not_called()
+
+ def _assert_exception_raised(self, exception_type, callable_func, *args, **kwargs):
+ """Helper method to verify that specific exception is raised."""
+ with pytest.raises(exception_type):
+ callable_func(*args, **kwargs)
+
+ # ==================== Authentication Tests ====================
+
+ def test_authenticate_success(self, mock_db_dependencies, mock_password_dependencies):
+ """Test successful authentication with correct email and password."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+
+ # Setup smart database query mock
+ query_results = {("Account", "email", "test@example.com"): mock_account}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ mock_password_dependencies["compare_password"].return_value = True
+
+ # Execute test
+ result = AccountService.authenticate("test@example.com", "password")
+
+ # Verify results
+ assert result == mock_account
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_authenticate_account_not_found(self, mock_db_dependencies):
+ """Test authentication when account does not exist."""
+ # Setup smart database query mock - no matching results
+ query_results = {("Account", "email", "notfound@example.com"): None}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ AccountNotFoundError, AccountService.authenticate, "notfound@example.com", "password"
+ )
+
+ def test_authenticate_account_banned(self, mock_db_dependencies):
+ """Test authentication when account is banned."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock(status="banned")
+
+ # Setup smart database query mock
+ query_results = {("Account", "email", "banned@example.com"): mock_account}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Execute test and verify exception
+ self._assert_exception_raised(AccountLoginError, AccountService.authenticate, "banned@example.com", "password")
+
+ def test_authenticate_password_error(self, mock_db_dependencies, mock_password_dependencies):
+ """Test authentication with wrong password."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+
+ # Setup smart database query mock
+ query_results = {("Account", "email", "test@example.com"): mock_account}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ mock_password_dependencies["compare_password"].return_value = False
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ AccountPasswordError, AccountService.authenticate, "test@example.com", "wrongpassword"
+ )
+
+ def test_authenticate_pending_account_activates(self, mock_db_dependencies, mock_password_dependencies):
+ """Test authentication for a pending account, which should activate on login."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock(status="pending")
+
+ # Setup smart database query mock
+ query_results = {("Account", "email", "pending@example.com"): mock_account}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ mock_password_dependencies["compare_password"].return_value = True
+
+ # Execute test
+ result = AccountService.authenticate("pending@example.com", "password")
+
+ # Verify results
+ assert result == mock_account
+ assert mock_account.status == "active"
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ # ==================== Account Creation Tests ====================
+
+ def test_create_account_success(
+ self, mock_db_dependencies, mock_password_dependencies, mock_external_service_dependencies
+ ):
+ """Test successful account creation with all required parameters."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+ mock_password_dependencies["hash_password"].return_value = b"hashed_password"
+
+ # Execute test
+ result = AccountService.create_account(
+ email="test@example.com",
+ name="Test User",
+ interface_language="en-US",
+ password="password123",
+ interface_theme="light",
+ )
+
+ # Verify results
+ assert result.email == "test@example.com"
+ assert result.name == "Test User"
+ assert result.interface_language == "en-US"
+ assert result.interface_theme == "light"
+ assert result.password is not None
+ assert result.password_salt is not None
+ assert result.timezone is not None
+
+ # Verify database operations
+ mock_db_dependencies["db"].session.add.assert_called_once()
+ added_account = mock_db_dependencies["db"].session.add.call_args[0][0]
+ assert added_account.email == "test@example.com"
+ assert added_account.name == "Test User"
+ assert added_account.interface_language == "en-US"
+ assert added_account.interface_theme == "light"
+ assert added_account.password is not None
+ assert added_account.password_salt is not None
+ assert added_account.timezone is not None
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_create_account_registration_disabled(self, mock_external_service_dependencies):
+ """Test account creation when registration is disabled."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = False
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ Exception, # AccountNotFound
+ AccountService.create_account,
+ email="test@example.com",
+ name="Test User",
+ interface_language="en-US",
+ )
+
+ def test_create_account_email_frozen(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test account creation with frozen email address."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = True
+ dify_config.BILLING_ENABLED = True
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ AccountRegisterError,
+ AccountService.create_account,
+ email="frozen@example.com",
+ name="Test User",
+ interface_language="en-US",
+ )
+ dify_config.BILLING_ENABLED = False
+
+ def test_create_account_without_password(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test account creation without password (for invite-based registration)."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Execute test
+ result = AccountService.create_account(
+ email="test@example.com",
+ name="Test User",
+ interface_language="zh-CN",
+ password=None,
+ interface_theme="dark",
+ )
+
+ # Verify results
+ assert result.email == "test@example.com"
+ assert result.name == "Test User"
+ assert result.interface_language == "zh-CN"
+ assert result.interface_theme == "dark"
+ assert result.password is None
+ assert result.password_salt is None
+ assert result.timezone is not None
+
+ # Verify database operations
+ mock_db_dependencies["db"].session.add.assert_called_once()
+ added_account = mock_db_dependencies["db"].session.add.call_args[0][0]
+ assert added_account.email == "test@example.com"
+ assert added_account.name == "Test User"
+ assert added_account.interface_language == "zh-CN"
+ assert added_account.interface_theme == "dark"
+ assert added_account.password is None
+ assert added_account.password_salt is None
+ assert added_account.timezone is not None
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ # ==================== Password Management Tests ====================
+
+ def test_update_account_password_success(self, mock_db_dependencies, mock_password_dependencies):
+ """Test successful password update with correct current password and valid new password."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ mock_password_dependencies["compare_password"].return_value = True
+ mock_password_dependencies["valid_password"].return_value = None
+ mock_password_dependencies["hash_password"].return_value = b"new_hashed_password"
+
+ # Execute test
+ result = AccountService.update_account_password(mock_account, "old_password", "new_password123")
+
+ # Verify results
+ assert result == mock_account
+ assert mock_account.password is not None
+ assert mock_account.password_salt is not None
+
+ # Verify password validation was called
+ mock_password_dependencies["compare_password"].assert_called_once_with(
+ "old_password", "hashed_password", "salt"
+ )
+ mock_password_dependencies["valid_password"].assert_called_once_with("new_password123")
+
+ # Verify database operations
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_update_account_password_current_password_incorrect(self, mock_password_dependencies):
+ """Test password update with incorrect current password."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ mock_password_dependencies["compare_password"].return_value = False
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ CurrentPasswordIncorrectError,
+ AccountService.update_account_password,
+ mock_account,
+ "wrong_password",
+ "new_password123",
+ )
+
+ # Verify password comparison was called
+ mock_password_dependencies["compare_password"].assert_called_once_with(
+ "wrong_password", "hashed_password", "salt"
+ )
+
+ def test_update_account_password_invalid_new_password(self, mock_password_dependencies):
+ """Test password update with invalid new password."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ mock_password_dependencies["compare_password"].return_value = True
+ mock_password_dependencies["valid_password"].side_effect = ValueError("Password too short")
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ ValueError, AccountService.update_account_password, mock_account, "old_password", "short"
+ )
+
+ # Verify password validation was called
+ mock_password_dependencies["valid_password"].assert_called_once_with("short")
+
+ # ==================== User Loading Tests ====================
+
+ def test_load_user_success(self, mock_db_dependencies):
+ """Test successful user loading with current tenant."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ mock_tenant_join = TestAccountAssociatedDataFactory.create_tenant_join_mock()
+
+ # Setup smart database query mock
+ query_results = {
+ ("Account", "id", "user-123"): mock_account,
+ ("TenantAccountJoin", "account_id", "user-123"): mock_tenant_join,
+ }
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Mock datetime
+ with patch("services.account_service.datetime") as mock_datetime:
+ mock_now = datetime.now()
+ mock_datetime.now.return_value = mock_now
+ mock_datetime.UTC = "UTC"
+
+ # Execute test
+ result = AccountService.load_user("user-123")
+
+ # Verify results
+ assert result == mock_account
+ assert mock_account.set_tenant_id.called
+
+ def test_load_user_not_found(self, mock_db_dependencies):
+ """Test user loading when user does not exist."""
+ # Setup smart database query mock - no matching results
+ query_results = {("Account", "id", "non-existent-user"): None}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Execute test
+ result = AccountService.load_user("non-existent-user")
+
+ # Verify results
+ assert result is None
+
+ def test_load_user_banned(self, mock_db_dependencies):
+ """Test user loading when user is banned."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock(status="banned")
+
+ # Setup smart database query mock
+ query_results = {("Account", "id", "user-123"): mock_account}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ Exception, # Unauthorized
+ AccountService.load_user,
+ "user-123",
+ )
+
+ def test_load_user_no_current_tenant(self, mock_db_dependencies):
+ """Test user loading when user has no current tenant but has available tenants."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ mock_available_tenant = TestAccountAssociatedDataFactory.create_tenant_join_mock(current=False)
+
+ # Setup smart database query mock for complex scenario
+ query_results = {
+ ("Account", "id", "user-123"): mock_account,
+ ("TenantAccountJoin", "account_id", "user-123"): None, # No current tenant
+ ("TenantAccountJoin", "order_by", "first_available"): mock_available_tenant, # First available tenant
+ }
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Mock datetime
+ with patch("services.account_service.datetime") as mock_datetime:
+ mock_now = datetime.now()
+ mock_datetime.now.return_value = mock_now
+ mock_datetime.UTC = "UTC"
+
+ # Execute test
+ result = AccountService.load_user("user-123")
+
+ # Verify results
+ assert result == mock_account
+ assert mock_available_tenant.current is True
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_load_user_no_tenants(self, mock_db_dependencies):
+ """Test user loading when user has no tenants at all."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+
+ # Setup smart database query mock for no tenants scenario
+ query_results = {
+ ("Account", "id", "user-123"): mock_account,
+ ("TenantAccountJoin", "account_id", "user-123"): None, # No current tenant
+ ("TenantAccountJoin", "order_by", "first_available"): None, # No available tenants
+ }
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Mock datetime
+ with patch("services.account_service.datetime") as mock_datetime:
+ mock_now = datetime.now()
+ mock_datetime.now.return_value = mock_now
+ mock_datetime.UTC = "UTC"
+
+ # Execute test
+ result = AccountService.load_user("user-123")
+
+ # Verify results
+ assert result is None
+
+
+class TestTenantService:
+ """
+ Comprehensive unit tests for TenantService methods.
+
+ This test suite covers all tenant-related operations including:
+ - Tenant creation and management
+ - Member management and permissions
+ - Tenant switching
+ - Role updates and permission checks
+ - Error conditions and edge cases
+ """
+
+ @pytest.fixture
+ def mock_db_dependencies(self):
+ """Common mock setup for database dependencies."""
+ with patch("services.account_service.db") as mock_db:
+ mock_db.session.add = MagicMock()
+ mock_db.session.commit = MagicMock()
+ yield {
+ "db": mock_db,
+ }
+
+ @pytest.fixture
+ def mock_rsa_dependencies(self):
+ """Mock setup for RSA-related functions."""
+ with patch("services.account_service.generate_key_pair") as mock_generate_key_pair:
+ yield mock_generate_key_pair
+
+ @pytest.fixture
+ def mock_external_service_dependencies(self):
+ """Mock setup for external service dependencies."""
+ with (
+ patch("services.account_service.FeatureService") as mock_feature_service,
+ patch("services.account_service.BillingService") as mock_billing_service,
+ ):
+ yield {
+ "feature_service": mock_feature_service,
+ "billing_service": mock_billing_service,
+ }
+
+ def _assert_database_operations_called(self, mock_db):
+ """Helper method to verify database operations were called."""
+ mock_db.session.commit.assert_called()
+
+ def _assert_exception_raised(self, exception_type, callable_func, *args, **kwargs):
+ """Helper method to verify that specific exception is raised."""
+ with pytest.raises(exception_type):
+ callable_func(*args, **kwargs)
+
+ # ==================== Tenant Creation Tests ====================
+
+ def test_create_owner_tenant_if_not_exist_new_user(
+ self, mock_db_dependencies, mock_rsa_dependencies, mock_external_service_dependencies
+ ):
+ """Test creating owner tenant for new user without existing tenants."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+
+ # Setup smart database query mock - no existing tenant joins
+ query_results = {
+ ("TenantAccountJoin", "account_id", "user-123"): None,
+ ("TenantAccountJoin", "tenant_id", "tenant-456"): None, # For has_roles check
+ }
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Setup external service mocks
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.is_allow_create_workspace = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.license.workspaces.is_available.return_value = True
+
+ # Mock tenant creation
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_tenant.name = "Test User's Workspace"
+
+ # Mock database operations
+ mock_db_dependencies["db"].session.add = MagicMock()
+
+ # Mock RSA key generation
+ mock_rsa_dependencies.return_value = "mock_public_key"
+
+ # Mock has_roles method to return False (no existing owner)
+ with patch("services.account_service.TenantService.has_roles") as mock_has_roles:
+ mock_has_roles.return_value = False
+
+ # Mock Tenant creation to set proper ID
+ with patch("services.account_service.Tenant") as mock_tenant_class:
+ mock_tenant_instance = MagicMock()
+ mock_tenant_instance.id = "tenant-456"
+ mock_tenant_instance.name = "Test User's Workspace"
+ mock_tenant_class.return_value = mock_tenant_instance
+
+ # Execute test
+ TenantService.create_owner_tenant_if_not_exist(mock_account)
+
+ # Verify tenant was created with correct parameters
+ mock_db_dependencies["db"].session.add.assert_called()
+
+ # Get all calls to session.add
+ add_calls = mock_db_dependencies["db"].session.add.call_args_list
+
+ # Should have at least 2 calls: one for Tenant, one for TenantAccountJoin
+ assert len(add_calls) >= 2
+
+ # Verify Tenant was added with correct name
+ tenant_added = False
+ tenant_account_join_added = False
+
+ for call in add_calls:
+ added_object = call[0][0] # First argument of the call
+
+ # Check if it's a Tenant object
+ if hasattr(added_object, "name") and hasattr(added_object, "id"):
+ # This should be a Tenant object
+ assert added_object.name == "Test User's Workspace"
+ tenant_added = True
+
+ # Check if it's a TenantAccountJoin object
+ elif (
+ hasattr(added_object, "tenant_id")
+ and hasattr(added_object, "account_id")
+ and hasattr(added_object, "role")
+ ):
+ # This should be a TenantAccountJoin object
+ assert added_object.tenant_id is not None
+ assert added_object.account_id == "user-123"
+ assert added_object.role == "owner"
+ tenant_account_join_added = True
+
+ assert tenant_added, "Tenant object was not added to database"
+ assert tenant_account_join_added, "TenantAccountJoin object was not added to database"
+
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+ assert mock_rsa_dependencies.called, "RSA key generation was not called"
+
+ # ==================== Member Management Tests ====================
+
+ def test_create_tenant_member_success(self, mock_db_dependencies):
+ """Test successful tenant member creation."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+
+ # Setup smart database query mock - no existing member
+ query_results = {("TenantAccountJoin", "tenant_id", "tenant-456"): None}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Mock database operations
+ mock_db_dependencies["db"].session.add = MagicMock()
+
+ # Execute test
+ result = TenantService.create_tenant_member(mock_tenant, mock_account, "normal")
+
+ # Verify member was created with correct parameters
+ assert result is not None
+ mock_db_dependencies["db"].session.add.assert_called_once()
+
+ # Verify the TenantAccountJoin object was added with correct parameters
+ added_tenant_account_join = mock_db_dependencies["db"].session.add.call_args[0][0]
+ assert added_tenant_account_join.tenant_id == "tenant-456"
+ assert added_tenant_account_join.account_id == "user-123"
+ assert added_tenant_account_join.role == "normal"
+
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ # ==================== Tenant Switching Tests ====================
+
+ def test_switch_tenant_success(self):
+ """Test successful tenant switching."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ mock_tenant_join = TestAccountAssociatedDataFactory.create_tenant_join_mock(
+ tenant_id="tenant-456", account_id="user-123", current=False
+ )
+
+ # Mock the complex query in switch_tenant method
+ with patch("services.account_service.db") as mock_db:
+ # Mock the join query that returns the tenant_account_join
+ mock_query = MagicMock()
+ mock_filter = MagicMock()
+ mock_filter.first.return_value = mock_tenant_join
+ mock_query.filter.return_value = mock_filter
+ mock_query.join.return_value = mock_query
+ mock_db.session.query.return_value = mock_query
+
+ # Execute test
+ TenantService.switch_tenant(mock_account, "tenant-456")
+
+ # Verify tenant was switched
+ assert mock_tenant_join.current is True
+ self._assert_database_operations_called(mock_db)
+
+ def test_switch_tenant_no_tenant_id(self):
+ """Test tenant switching without providing tenant ID."""
+ # Setup test data
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+
+ # Execute test and verify exception
+ self._assert_exception_raised(ValueError, TenantService.switch_tenant, mock_account, None)
+
+ # ==================== Role Management Tests ====================
+
+ def test_update_member_role_success(self):
+ """Test successful member role update."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_member = TestAccountAssociatedDataFactory.create_account_mock(account_id="member-789")
+ mock_operator = TestAccountAssociatedDataFactory.create_account_mock(account_id="operator-123")
+ mock_target_join = TestAccountAssociatedDataFactory.create_tenant_join_mock(
+ tenant_id="tenant-456", account_id="member-789", role="normal"
+ )
+ mock_operator_join = TestAccountAssociatedDataFactory.create_tenant_join_mock(
+ tenant_id="tenant-456", account_id="operator-123", role="owner"
+ )
+
+ # Mock the database queries in update_member_role method
+ with patch("services.account_service.db") as mock_db:
+ # Mock the first query for operator permission check
+ mock_query1 = MagicMock()
+ mock_filter1 = MagicMock()
+ mock_filter1.first.return_value = mock_operator_join
+ mock_query1.filter_by.return_value = mock_filter1
+
+ # Mock the second query for target member
+ mock_query2 = MagicMock()
+ mock_filter2 = MagicMock()
+ mock_filter2.first.return_value = mock_target_join
+ mock_query2.filter_by.return_value = mock_filter2
+
+ # Make the query method return different mocks for different calls
+ mock_db.session.query.side_effect = [mock_query1, mock_query2]
+
+ # Execute test
+ TenantService.update_member_role(mock_tenant, mock_member, "admin", mock_operator)
+
+ # Verify role was updated
+ assert mock_target_join.role == "admin"
+ self._assert_database_operations_called(mock_db)
+
+ # ==================== Permission Check Tests ====================
+
+ def test_check_member_permission_success(self, mock_db_dependencies):
+ """Test successful member permission check."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_operator = TestAccountAssociatedDataFactory.create_account_mock(account_id="operator-123")
+ mock_member = TestAccountAssociatedDataFactory.create_account_mock(account_id="member-789")
+ mock_operator_join = TestAccountAssociatedDataFactory.create_tenant_join_mock(
+ tenant_id="tenant-456", account_id="operator-123", role="owner"
+ )
+
+ # Setup smart database query mock
+ query_results = {("TenantAccountJoin", "tenant_id", "tenant-456"): mock_operator_join}
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Execute test - should not raise exception
+ TenantService.check_member_permission(mock_tenant, mock_operator, mock_member, "add")
+
+ def test_check_member_permission_operate_self(self):
+ """Test member permission check when operator tries to operate self."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_operator = TestAccountAssociatedDataFactory.create_account_mock(account_id="operator-123")
+
+ # Execute test and verify exception
+ from services.errors.account import CannotOperateSelfError
+
+ self._assert_exception_raised(
+ CannotOperateSelfError,
+ TenantService.check_member_permission,
+ mock_tenant,
+ mock_operator,
+ mock_operator, # Same as operator
+ "add",
+ )
+
+
+class TestRegisterService:
+ """
+ Comprehensive unit tests for RegisterService methods.
+
+ This test suite covers all registration-related operations including:
+ - System setup
+ - Account registration
+ - Member invitation
+ - Token management
+ - Invitation validation
+ - Error conditions and edge cases
+ """
+
+ @pytest.fixture
+ def mock_db_dependencies(self):
+ """Common mock setup for database dependencies."""
+ with patch("services.account_service.db") as mock_db:
+ mock_db.session.add = MagicMock()
+ mock_db.session.commit = MagicMock()
+ mock_db.session.begin_nested = MagicMock()
+ mock_db.session.rollback = MagicMock()
+ yield {
+ "db": mock_db,
+ }
+
+ @pytest.fixture
+ def mock_redis_dependencies(self):
+ """Mock setup for Redis-related functions."""
+ with patch("services.account_service.redis_client") as mock_redis:
+ yield mock_redis
+
+ @pytest.fixture
+ def mock_external_service_dependencies(self):
+ """Mock setup for external service dependencies."""
+ with (
+ patch("services.account_service.FeatureService") as mock_feature_service,
+ patch("services.account_service.BillingService") as mock_billing_service,
+ patch("services.account_service.PassportService") as mock_passport_service,
+ ):
+ yield {
+ "feature_service": mock_feature_service,
+ "billing_service": mock_billing_service,
+ "passport_service": mock_passport_service,
+ }
+
+ @pytest.fixture
+ def mock_task_dependencies(self):
+ """Mock setup for task dependencies."""
+ with patch("services.account_service.send_invite_member_mail_task") as mock_send_mail:
+ yield mock_send_mail
+
+ def _assert_database_operations_called(self, mock_db):
+ """Helper method to verify database operations were called."""
+ mock_db.session.commit.assert_called()
+
+ def _assert_database_operations_not_called(self, mock_db):
+ """Helper method to verify database operations were not called."""
+ mock_db.session.commit.assert_not_called()
+
+ def _assert_exception_raised(self, exception_type, callable_func, *args, **kwargs):
+ """Helper method to verify that specific exception is raised."""
+ with pytest.raises(exception_type):
+ callable_func(*args, **kwargs)
+
+ # ==================== Setup Tests ====================
+
+ def test_setup_success(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test successful system setup."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ with patch("services.account_service.AccountService.create_account") as mock_create_account:
+ mock_create_account.return_value = mock_account
+
+ # Mock TenantService.create_owner_tenant_if_not_exist
+ with patch("services.account_service.TenantService.create_owner_tenant_if_not_exist") as mock_create_tenant:
+ # Mock DifySetup
+ with patch("services.account_service.DifySetup") as mock_dify_setup:
+ mock_dify_setup_instance = MagicMock()
+ mock_dify_setup.return_value = mock_dify_setup_instance
+
+ # Execute test
+ RegisterService.setup("admin@example.com", "Admin User", "password123", "192.168.1.1")
+
+ # Verify results
+ mock_create_account.assert_called_once_with(
+ email="admin@example.com",
+ name="Admin User",
+ interface_language="en-US",
+ password="password123",
+ is_setup=True,
+ )
+ mock_create_tenant.assert_called_once_with(account=mock_account, is_setup=True)
+ mock_dify_setup.assert_called_once()
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_setup_failure_rollback(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test setup failure with proper rollback."""
+ # Setup mocks to simulate failure
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account to raise exception
+ with patch("services.account_service.AccountService.create_account") as mock_create_account:
+ mock_create_account.side_effect = Exception("Database error")
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ ValueError,
+ RegisterService.setup,
+ "admin@example.com",
+ "Admin User",
+ "password123",
+ "192.168.1.1",
+ )
+
+ # Verify rollback operations were called
+ mock_db_dependencies["db"].session.query.assert_called()
+
+ # ==================== Registration Tests ====================
+
+ def test_register_success(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test successful account registration."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.is_allow_create_workspace = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.license.workspaces.is_available.return_value = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ with patch("services.account_service.AccountService.create_account") as mock_create_account:
+ mock_create_account.return_value = mock_account
+
+ # Mock TenantService.create_tenant and create_tenant_member
+ with (
+ patch("services.account_service.TenantService.create_tenant") as mock_create_tenant,
+ patch("services.account_service.TenantService.create_tenant_member") as mock_create_member,
+ patch("services.account_service.tenant_was_created") as mock_event,
+ ):
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_create_tenant.return_value = mock_tenant
+
+ # Execute test
+ result = RegisterService.register(
+ email="test@example.com",
+ name="Test User",
+ password="password123",
+ language="en-US",
+ )
+
+ # Verify results
+ assert result == mock_account
+ assert result.status == "active"
+ assert result.initialized_at is not None
+ mock_create_account.assert_called_once_with(
+ email="test@example.com",
+ name="Test User",
+ interface_language="en-US",
+ password="password123",
+ is_setup=False,
+ )
+ mock_create_tenant.assert_called_once_with("Test User's Workspace")
+ mock_create_member.assert_called_once_with(mock_tenant, mock_account, role="owner")
+ mock_event.send.assert_called_once_with(mock_tenant)
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_register_with_oauth(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test account registration with OAuth integration."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.is_allow_create_workspace = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.license.workspaces.is_available.return_value = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account and link_account_integrate
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ with (
+ patch("services.account_service.AccountService.create_account") as mock_create_account,
+ patch("services.account_service.AccountService.link_account_integrate") as mock_link_account,
+ ):
+ mock_create_account.return_value = mock_account
+
+ # Mock TenantService methods
+ with (
+ patch("services.account_service.TenantService.create_tenant") as mock_create_tenant,
+ patch("services.account_service.TenantService.create_tenant_member") as mock_create_member,
+ patch("services.account_service.tenant_was_created") as mock_event,
+ ):
+ mock_tenant = MagicMock()
+ mock_create_tenant.return_value = mock_tenant
+
+ # Execute test
+ result = RegisterService.register(
+ email="test@example.com",
+ name="Test User",
+ password=None,
+ open_id="oauth123",
+ provider="google",
+ language="en-US",
+ )
+
+ # Verify results
+ assert result == mock_account
+ mock_link_account.assert_called_once_with("google", "oauth123", mock_account)
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_register_with_pending_status(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test account registration with pending status."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.is_allow_create_workspace = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.license.workspaces.is_available.return_value = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ with patch("services.account_service.AccountService.create_account") as mock_create_account:
+ mock_create_account.return_value = mock_account
+
+ # Mock TenantService methods
+ with (
+ patch("services.account_service.TenantService.create_tenant") as mock_create_tenant,
+ patch("services.account_service.TenantService.create_tenant_member") as mock_create_member,
+ patch("services.account_service.tenant_was_created") as mock_event,
+ ):
+ mock_tenant = MagicMock()
+ mock_create_tenant.return_value = mock_tenant
+
+ # Execute test with pending status
+ from models.account import AccountStatus
+
+ result = RegisterService.register(
+ email="test@example.com",
+ name="Test User",
+ password="password123",
+ language="en-US",
+ status=AccountStatus.PENDING,
+ )
+
+ # Verify results
+ assert result == mock_account
+ assert result.status == "pending"
+ self._assert_database_operations_called(mock_db_dependencies["db"])
+
+ def test_register_workspace_not_allowed(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test registration when workspace creation is not allowed."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.is_allow_create_workspace = True
+ mock_external_service_dependencies[
+ "feature_service"
+ ].get_system_features.return_value.license.workspaces.is_available.return_value = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock()
+ with patch("services.account_service.AccountService.create_account") as mock_create_account:
+ mock_create_account.return_value = mock_account
+
+ # Execute test and verify exception
+ from services.errors.workspace import WorkSpaceNotAllowedCreateError
+
+ with patch("services.account_service.TenantService.create_tenant") as mock_create_tenant:
+ mock_create_tenant.side_effect = WorkSpaceNotAllowedCreateError()
+
+ self._assert_exception_raised(
+ AccountRegisterError,
+ RegisterService.register,
+ email="test@example.com",
+ name="Test User",
+ password="password123",
+ language="en-US",
+ )
+
+ # Verify rollback was called
+ mock_db_dependencies["db"].session.rollback.assert_called()
+
+ def test_register_general_exception(self, mock_db_dependencies, mock_external_service_dependencies):
+ """Test registration with general exception handling."""
+ # Setup mocks
+ mock_external_service_dependencies["feature_service"].get_system_features.return_value.is_allow_register = True
+ mock_external_service_dependencies["billing_service"].is_email_in_freeze.return_value = False
+
+ # Mock AccountService.create_account to raise exception
+ with patch("services.account_service.AccountService.create_account") as mock_create_account:
+ mock_create_account.side_effect = Exception("Unexpected error")
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ AccountRegisterError,
+ RegisterService.register,
+ email="test@example.com",
+ name="Test User",
+ password="password123",
+ language="en-US",
+ )
+
+ # Verify rollback was called
+ mock_db_dependencies["db"].session.rollback.assert_called()
+
+ # ==================== Member Invitation Tests ====================
+
+ def test_invite_new_member_new_account(self, mock_db_dependencies, mock_redis_dependencies, mock_task_dependencies):
+ """Test inviting a new member who doesn't have an account."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_tenant.name = "Test Workspace"
+ mock_inviter = TestAccountAssociatedDataFactory.create_account_mock(account_id="inviter-123", name="Inviter")
+
+ # Mock database queries - need to mock the Session query
+ mock_session = MagicMock()
+ mock_session.query.return_value.filter_by.return_value.first.return_value = None # No existing account
+
+ with patch("services.account_service.Session") as mock_session_class:
+ mock_session_class.return_value.__enter__.return_value = mock_session
+ mock_session_class.return_value.__exit__.return_value = None
+
+ # Mock RegisterService.register
+ mock_new_account = TestAccountAssociatedDataFactory.create_account_mock(
+ account_id="new-user-456", email="newuser@example.com", name="newuser", status="pending"
+ )
+ with patch("services.account_service.RegisterService.register") as mock_register:
+ mock_register.return_value = mock_new_account
+
+ # Mock TenantService methods
+ with (
+ patch("services.account_service.TenantService.check_member_permission") as mock_check_permission,
+ patch("services.account_service.TenantService.create_tenant_member") as mock_create_member,
+ patch("services.account_service.TenantService.switch_tenant") as mock_switch_tenant,
+ patch("services.account_service.RegisterService.generate_invite_token") as mock_generate_token,
+ ):
+ mock_generate_token.return_value = "invite-token-123"
+
+ # Execute test
+ result = RegisterService.invite_new_member(
+ tenant=mock_tenant,
+ email="newuser@example.com",
+ language="en-US",
+ role="normal",
+ inviter=mock_inviter,
+ )
+
+ # Verify results
+ assert result == "invite-token-123"
+ mock_register.assert_called_once_with(
+ email="newuser@example.com",
+ name="newuser",
+ language="en-US",
+ status="pending",
+ is_setup=True,
+ )
+ mock_create_member.assert_called_once_with(mock_tenant, mock_new_account, "normal")
+ mock_switch_tenant.assert_called_once_with(mock_new_account, mock_tenant.id)
+ mock_generate_token.assert_called_once_with(mock_tenant, mock_new_account)
+ mock_task_dependencies.delay.assert_called_once()
+
+ def test_invite_new_member_existing_account(
+ self, mock_db_dependencies, mock_redis_dependencies, mock_task_dependencies
+ ):
+ """Test inviting a new member who already has an account."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_tenant.name = "Test Workspace"
+ mock_inviter = TestAccountAssociatedDataFactory.create_account_mock(account_id="inviter-123", name="Inviter")
+ mock_existing_account = TestAccountAssociatedDataFactory.create_account_mock(
+ account_id="existing-user-456", email="existing@example.com", status="pending"
+ )
+
+ # Mock database queries - need to mock the Session query
+ mock_session = MagicMock()
+ mock_session.query.return_value.filter_by.return_value.first.return_value = mock_existing_account
+
+ with patch("services.account_service.Session") as mock_session_class:
+ mock_session_class.return_value.__enter__.return_value = mock_session
+ mock_session_class.return_value.__exit__.return_value = None
+
+ # Mock the db.session.query for TenantAccountJoin
+ mock_db_query = MagicMock()
+ mock_db_query.filter_by.return_value.first.return_value = None # No existing member
+ mock_db_dependencies["db"].session.query.return_value = mock_db_query
+
+ # Mock TenantService methods
+ with (
+ patch("services.account_service.TenantService.check_member_permission") as mock_check_permission,
+ patch("services.account_service.TenantService.create_tenant_member") as mock_create_member,
+ patch("services.account_service.RegisterService.generate_invite_token") as mock_generate_token,
+ ):
+ mock_generate_token.return_value = "invite-token-123"
+
+ # Execute test
+ result = RegisterService.invite_new_member(
+ tenant=mock_tenant,
+ email="existing@example.com",
+ language="en-US",
+ role="normal",
+ inviter=mock_inviter,
+ )
+
+ # Verify results
+ assert result == "invite-token-123"
+ mock_create_member.assert_called_once_with(mock_tenant, mock_existing_account, "normal")
+ mock_generate_token.assert_called_once_with(mock_tenant, mock_existing_account)
+ mock_task_dependencies.delay.assert_called_once()
+
+ def test_invite_new_member_already_in_tenant(self, mock_db_dependencies, mock_redis_dependencies):
+ """Test inviting a member who is already in the tenant."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_inviter = TestAccountAssociatedDataFactory.create_account_mock(account_id="inviter-123", name="Inviter")
+ mock_existing_account = TestAccountAssociatedDataFactory.create_account_mock(
+ account_id="existing-user-456", email="existing@example.com", status="active"
+ )
+
+ # Mock database queries
+ query_results = {
+ ("Account", "email", "existing@example.com"): mock_existing_account,
+ (
+ "TenantAccountJoin",
+ "tenant_id",
+ "tenant-456",
+ ): TestAccountAssociatedDataFactory.create_tenant_join_mock(),
+ }
+ ServiceDbTestHelper.setup_db_query_filter_by_mock(mock_db_dependencies["db"], query_results)
+
+ # Mock TenantService methods
+ with patch("services.account_service.TenantService.check_member_permission") as mock_check_permission:
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ AccountAlreadyInTenantError,
+ RegisterService.invite_new_member,
+ tenant=mock_tenant,
+ email="existing@example.com",
+ language="en-US",
+ role="normal",
+ inviter=mock_inviter,
+ )
+
+ def test_invite_new_member_no_inviter(self):
+ """Test inviting a member without providing an inviter."""
+ # Setup test data
+ mock_tenant = MagicMock()
+
+ # Execute test and verify exception
+ self._assert_exception_raised(
+ ValueError,
+ RegisterService.invite_new_member,
+ tenant=mock_tenant,
+ email="test@example.com",
+ language="en-US",
+ role="normal",
+ inviter=None,
+ )
+
+ # ==================== Token Management Tests ====================
+
+ def test_generate_invite_token_success(self, mock_redis_dependencies):
+ """Test successful invite token generation."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock(
+ account_id="user-123", email="test@example.com"
+ )
+
+ # Mock uuid generation
+ with patch("services.account_service.uuid.uuid4") as mock_uuid:
+ mock_uuid.return_value = "test-uuid-123"
+
+ # Execute test
+ result = RegisterService.generate_invite_token(mock_tenant, mock_account)
+
+ # Verify results
+ assert result == "test-uuid-123"
+ mock_redis_dependencies.setex.assert_called_once()
+
+ # Verify the stored data
+ call_args = mock_redis_dependencies.setex.call_args
+ assert call_args[0][0] == "member_invite:token:test-uuid-123"
+ stored_data = json.loads(call_args[0][2])
+ assert stored_data["account_id"] == "user-123"
+ assert stored_data["email"] == "test@example.com"
+ assert stored_data["workspace_id"] == "tenant-456"
+
+ def test_is_valid_invite_token_valid(self, mock_redis_dependencies):
+ """Test checking valid invite token."""
+ # Setup mock
+ mock_redis_dependencies.get.return_value = b'{"test": "data"}'
+
+ # Execute test
+ result = RegisterService.is_valid_invite_token("valid-token")
+
+ # Verify results
+ assert result is True
+ mock_redis_dependencies.get.assert_called_once_with("member_invite:token:valid-token")
+
+ def test_is_valid_invite_token_invalid(self, mock_redis_dependencies):
+ """Test checking invalid invite token."""
+ # Setup mock
+ mock_redis_dependencies.get.return_value = None
+
+ # Execute test
+ result = RegisterService.is_valid_invite_token("invalid-token")
+
+ # Verify results
+ assert result is False
+ mock_redis_dependencies.get.assert_called_once_with("member_invite:token:invalid-token")
+
+ def test_revoke_token_with_workspace_and_email(self, mock_redis_dependencies):
+ """Test revoking token with workspace ID and email."""
+ # Execute test
+ RegisterService.revoke_token("workspace-123", "test@example.com", "token-123")
+
+ # Verify results
+ mock_redis_dependencies.delete.assert_called_once()
+ call_args = mock_redis_dependencies.delete.call_args
+ assert "workspace-123" in call_args[0][0]
+ # The email is hashed, so we check for the hash pattern instead
+ assert "member_invite_token:" in call_args[0][0]
+
+ def test_revoke_token_without_workspace_and_email(self, mock_redis_dependencies):
+ """Test revoking token without workspace ID and email."""
+ # Execute test
+ RegisterService.revoke_token("", "", "token-123")
+
+ # Verify results
+ mock_redis_dependencies.delete.assert_called_once_with("member_invite:token:token-123")
+
+ # ==================== Invitation Validation Tests ====================
+
+ def test_get_invitation_if_token_valid_success(self, mock_db_dependencies, mock_redis_dependencies):
+ """Test successful invitation validation."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_tenant.status = "normal"
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock(
+ account_id="user-123", email="test@example.com"
+ )
+
+ with patch("services.account_service.RegisterService._get_invitation_by_token") as mock_get_invitation_by_token:
+ # Mock the invitation data returned by _get_invitation_by_token
+ invitation_data = {
+ "account_id": "user-123",
+ "email": "test@example.com",
+ "workspace_id": "tenant-456",
+ }
+ mock_get_invitation_by_token.return_value = invitation_data
+
+ # Mock database queries - complex query mocking
+ mock_query1 = MagicMock()
+ mock_query1.filter.return_value.first.return_value = mock_tenant
+
+ mock_query2 = MagicMock()
+ mock_query2.join.return_value.filter.return_value.first.return_value = (mock_account, "normal")
+
+ mock_db_dependencies["db"].session.query.side_effect = [mock_query1, mock_query2]
+
+ # Execute test
+ result = RegisterService.get_invitation_if_token_valid("tenant-456", "test@example.com", "token-123")
+
+ # Verify results
+ assert result is not None
+ assert result["account"] == mock_account
+ assert result["tenant"] == mock_tenant
+ assert result["data"] == invitation_data
+
+ def test_get_invitation_if_token_valid_no_token_data(self, mock_redis_dependencies):
+ """Test invitation validation with no token data."""
+ # Setup mock
+ mock_redis_dependencies.get.return_value = None
+
+ # Execute test
+ result = RegisterService.get_invitation_if_token_valid("tenant-456", "test@example.com", "token-123")
+
+ # Verify results
+ assert result is None
+
+ def test_get_invitation_if_token_valid_tenant_not_found(self, mock_db_dependencies, mock_redis_dependencies):
+ """Test invitation validation when tenant is not found."""
+ # Setup mock Redis data
+ invitation_data = {
+ "account_id": "user-123",
+ "email": "test@example.com",
+ "workspace_id": "tenant-456",
+ }
+ mock_redis_dependencies.get.return_value = json.dumps(invitation_data).encode()
+
+ # Mock database queries - no tenant found
+ mock_query = MagicMock()
+ mock_query.filter.return_value.first.return_value = None
+ mock_db_dependencies["db"].session.query.return_value = mock_query
+
+ # Execute test
+ result = RegisterService.get_invitation_if_token_valid("tenant-456", "test@example.com", "token-123")
+
+ # Verify results
+ assert result is None
+
+ def test_get_invitation_if_token_valid_account_not_found(self, mock_db_dependencies, mock_redis_dependencies):
+ """Test invitation validation when account is not found."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_tenant.status = "normal"
+
+ # Mock Redis data
+ invitation_data = {
+ "account_id": "user-123",
+ "email": "test@example.com",
+ "workspace_id": "tenant-456",
+ }
+ mock_redis_dependencies.get.return_value = json.dumps(invitation_data).encode()
+
+ # Mock database queries
+ mock_query1 = MagicMock()
+ mock_query1.filter.return_value.first.return_value = mock_tenant
+
+ mock_query2 = MagicMock()
+ mock_query2.join.return_value.filter.return_value.first.return_value = None # No account found
+
+ mock_db_dependencies["db"].session.query.side_effect = [mock_query1, mock_query2]
+
+ # Execute test
+ result = RegisterService.get_invitation_if_token_valid("tenant-456", "test@example.com", "token-123")
+
+ # Verify results
+ assert result is None
+
+ def test_get_invitation_if_token_valid_account_id_mismatch(self, mock_db_dependencies, mock_redis_dependencies):
+ """Test invitation validation when account ID doesn't match."""
+ # Setup test data
+ mock_tenant = MagicMock()
+ mock_tenant.id = "tenant-456"
+ mock_tenant.status = "normal"
+ mock_account = TestAccountAssociatedDataFactory.create_account_mock(
+ account_id="different-user-456", email="test@example.com"
+ )
+
+ # Mock Redis data with different account ID
+ invitation_data = {
+ "account_id": "user-123",
+ "email": "test@example.com",
+ "workspace_id": "tenant-456",
+ }
+ mock_redis_dependencies.get.return_value = json.dumps(invitation_data).encode()
+
+ # Mock database queries
+ mock_query1 = MagicMock()
+ mock_query1.filter.return_value.first.return_value = mock_tenant
+
+ mock_query2 = MagicMock()
+ mock_query2.join.return_value.filter.return_value.first.return_value = (mock_account, "normal")
+
+ mock_db_dependencies["db"].session.query.side_effect = [mock_query1, mock_query2]
+
+ # Execute test
+ result = RegisterService.get_invitation_if_token_valid("tenant-456", "test@example.com", "token-123")
+
+ # Verify results
+ assert result is None
+
+ # ==================== Helper Method Tests ====================
+
+ def test_get_invitation_token_key(self):
+ """Test the _get_invitation_token_key helper method."""
+ # Execute test
+ result = RegisterService._get_invitation_token_key("test-token")
+
+ # Verify results
+ assert result == "member_invite:token:test-token"
+
+ def test_get_invitation_by_token_with_workspace_and_email(self, mock_redis_dependencies):
+ """Test _get_invitation_by_token with workspace ID and email."""
+ # Setup mock
+ mock_redis_dependencies.get.return_value = b"user-123"
+
+ # Execute test
+ result = RegisterService._get_invitation_by_token("token-123", "workspace-456", "test@example.com")
+
+ # Verify results
+ assert result is not None
+ assert result["account_id"] == "user-123"
+ assert result["email"] == "test@example.com"
+ assert result["workspace_id"] == "workspace-456"
+
+ def test_get_invitation_by_token_without_workspace_and_email(self, mock_redis_dependencies):
+ """Test _get_invitation_by_token without workspace ID and email."""
+ # Setup mock
+ invitation_data = {
+ "account_id": "user-123",
+ "email": "test@example.com",
+ "workspace_id": "tenant-456",
+ }
+ mock_redis_dependencies.get.return_value = json.dumps(invitation_data).encode()
+
+ # Execute test
+ result = RegisterService._get_invitation_by_token("token-123")
+
+ # Verify results
+ assert result is not None
+ assert result == invitation_data
+
+ def test_get_invitation_by_token_no_data(self, mock_redis_dependencies):
+ """Test _get_invitation_by_token with no data."""
+ # Setup mock
+ mock_redis_dependencies.get.return_value = None
+
+ # Execute test
+ result = RegisterService._get_invitation_by_token("token-123")
+
+ # Verify results
+ assert result is None
diff --git a/api/tests/unit_tests/utils/structured_output_parser/test_structured_output_parser.py b/api/tests/unit_tests/utils/structured_output_parser/test_structured_output_parser.py
index 728c58fc5b..93284eed4b 100644
--- a/api/tests/unit_tests/utils/structured_output_parser/test_structured_output_parser.py
+++ b/api/tests/unit_tests/utils/structured_output_parser/test_structured_output_parser.py
@@ -27,11 +27,11 @@ def create_mock_usage(prompt_tokens: int = 10, completion_tokens: int = 5) -> LL
return LLMUsage(
prompt_tokens=prompt_tokens,
prompt_unit_price=Decimal("0.001"),
- prompt_price_unit=Decimal("1"),
+ prompt_price_unit=Decimal(1),
prompt_price=Decimal(str(prompt_tokens)) * Decimal("0.001"),
completion_tokens=completion_tokens,
completion_unit_price=Decimal("0.002"),
- completion_price_unit=Decimal("1"),
+ completion_price_unit=Decimal(1),
completion_price=Decimal(str(completion_tokens)) * Decimal("0.002"),
total_tokens=prompt_tokens + completion_tokens,
total_price=Decimal(str(prompt_tokens)) * Decimal("0.001") + Decimal(str(completion_tokens)) * Decimal("0.002"),
diff --git a/api/uv.lock b/api/uv.lock
index e108e0c445..21b6b20f53 100644
--- a/api/uv.lock
+++ b/api/uv.lock
@@ -1498,7 +1498,7 @@ dev = [
{ name = "pytest-cov", specifier = "~=4.1.0" },
{ name = "pytest-env", specifier = "~=1.1.3" },
{ name = "pytest-mock", specifier = "~=3.14.0" },
- { name = "ruff", specifier = "~=0.11.5" },
+ { name = "ruff", specifier = "~=0.12.3" },
{ name = "scipy-stubs", specifier = ">=1.15.3.0" },
{ name = "types-aiofiles", specifier = "~=24.1.0" },
{ name = "types-beautifulsoup4", specifier = "~=4.12.0" },
@@ -5088,27 +5088,27 @@ wheels = [
[[package]]
name = "ruff"
-version = "0.11.13"
+version = "0.12.3"
source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ed/da/9c6f995903b4d9474b39da91d2d626659af3ff1eeb43e9ae7c119349dba6/ruff-0.11.13.tar.gz", hash = "sha256:26fa247dc68d1d4e72c179e08889a25ac0c7ba4d78aecfc835d49cbfd60bf514", size = 4282054, upload-time = "2025-06-05T21:00:15.721Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/2a/43955b530c49684d3c38fcda18c43caf91e99204c2a065552528e0552d4f/ruff-0.12.3.tar.gz", hash = "sha256:f1b5a4b6668fd7b7ea3697d8d98857390b40c1320a63a178eee6be0899ea2d77", size = 4459341, upload-time = "2025-07-11T13:21:16.086Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/7d/ce/a11d381192966e0b4290842cc8d4fac7dc9214ddf627c11c1afff87da29b/ruff-0.11.13-py3-none-linux_armv6l.whl", hash = "sha256:4bdfbf1240533f40042ec00c9e09a3aade6f8c10b6414cf11b519488d2635d46", size = 10292516, upload-time = "2025-06-05T20:59:32.944Z" },
- { url = "https://files.pythonhosted.org/packages/78/db/87c3b59b0d4e753e40b6a3b4a2642dfd1dcaefbff121ddc64d6c8b47ba00/ruff-0.11.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:aef9c9ed1b5ca28bb15c7eac83b8670cf3b20b478195bd49c8d756ba0a36cf48", size = 11106083, upload-time = "2025-06-05T20:59:37.03Z" },
- { url = "https://files.pythonhosted.org/packages/77/79/d8cec175856ff810a19825d09ce700265f905c643c69f45d2b737e4a470a/ruff-0.11.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:53b15a9dfdce029c842e9a5aebc3855e9ab7771395979ff85b7c1dedb53ddc2b", size = 10436024, upload-time = "2025-06-05T20:59:39.741Z" },
- { url = "https://files.pythonhosted.org/packages/8b/5b/f6d94f2980fa1ee854b41568368a2e1252681b9238ab2895e133d303538f/ruff-0.11.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab153241400789138d13f362c43f7edecc0edfffce2afa6a68434000ecd8f69a", size = 10646324, upload-time = "2025-06-05T20:59:42.185Z" },
- { url = "https://files.pythonhosted.org/packages/6c/9c/b4c2acf24ea4426016d511dfdc787f4ce1ceb835f3c5fbdbcb32b1c63bda/ruff-0.11.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c51f93029d54a910d3d24f7dd0bb909e31b6cd989a5e4ac513f4eb41629f0dc", size = 10174416, upload-time = "2025-06-05T20:59:44.319Z" },
- { url = "https://files.pythonhosted.org/packages/f3/10/e2e62f77c65ede8cd032c2ca39c41f48feabedb6e282bfd6073d81bb671d/ruff-0.11.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1808b3ed53e1a777c2ef733aca9051dc9bf7c99b26ece15cb59a0320fbdbd629", size = 11724197, upload-time = "2025-06-05T20:59:46.935Z" },
- { url = "https://files.pythonhosted.org/packages/bb/f0/466fe8469b85c561e081d798c45f8a1d21e0b4a5ef795a1d7f1a9a9ec182/ruff-0.11.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:d28ce58b5ecf0f43c1b71edffabe6ed7f245d5336b17805803312ec9bc665933", size = 12511615, upload-time = "2025-06-05T20:59:49.534Z" },
- { url = "https://files.pythonhosted.org/packages/17/0e/cefe778b46dbd0cbcb03a839946c8f80a06f7968eb298aa4d1a4293f3448/ruff-0.11.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55e4bc3a77842da33c16d55b32c6cac1ec5fb0fbec9c8c513bdce76c4f922165", size = 12117080, upload-time = "2025-06-05T20:59:51.654Z" },
- { url = "https://files.pythonhosted.org/packages/5d/2c/caaeda564cbe103bed145ea557cb86795b18651b0f6b3ff6a10e84e5a33f/ruff-0.11.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:633bf2c6f35678c56ec73189ba6fa19ff1c5e4807a78bf60ef487b9dd272cc71", size = 11326315, upload-time = "2025-06-05T20:59:54.469Z" },
- { url = "https://files.pythonhosted.org/packages/75/f0/782e7d681d660eda8c536962920c41309e6dd4ebcea9a2714ed5127d44bd/ruff-0.11.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ffbc82d70424b275b089166310448051afdc6e914fdab90e08df66c43bb5ca9", size = 11555640, upload-time = "2025-06-05T20:59:56.986Z" },
- { url = "https://files.pythonhosted.org/packages/5d/d4/3d580c616316c7f07fb3c99dbecfe01fbaea7b6fd9a82b801e72e5de742a/ruff-0.11.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4a9ddd3ec62a9a89578c85842b836e4ac832d4a2e0bfaad3b02243f930ceafcc", size = 10507364, upload-time = "2025-06-05T20:59:59.154Z" },
- { url = "https://files.pythonhosted.org/packages/5a/dc/195e6f17d7b3ea6b12dc4f3e9de575db7983db187c378d44606e5d503319/ruff-0.11.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d237a496e0778d719efb05058c64d28b757c77824e04ffe8796c7436e26712b7", size = 10141462, upload-time = "2025-06-05T21:00:01.481Z" },
- { url = "https://files.pythonhosted.org/packages/f4/8e/39a094af6967faa57ecdeacb91bedfb232474ff8c3d20f16a5514e6b3534/ruff-0.11.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:26816a218ca6ef02142343fd24c70f7cd8c5aa6c203bca284407adf675984432", size = 11121028, upload-time = "2025-06-05T21:00:04.06Z" },
- { url = "https://files.pythonhosted.org/packages/5a/c0/b0b508193b0e8a1654ec683ebab18d309861f8bd64e3a2f9648b80d392cb/ruff-0.11.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:51c3f95abd9331dc5b87c47ac7f376db5616041173826dfd556cfe3d4977f492", size = 11602992, upload-time = "2025-06-05T21:00:06.249Z" },
- { url = "https://files.pythonhosted.org/packages/7c/91/263e33ab93ab09ca06ce4f8f8547a858cc198072f873ebc9be7466790bae/ruff-0.11.13-py3-none-win32.whl", hash = "sha256:96c27935418e4e8e77a26bb05962817f28b8ef3843a6c6cc49d8783b5507f250", size = 10474944, upload-time = "2025-06-05T21:00:08.459Z" },
- { url = "https://files.pythonhosted.org/packages/46/f4/7c27734ac2073aae8efb0119cae6931b6fb48017adf048fdf85c19337afc/ruff-0.11.13-py3-none-win_amd64.whl", hash = "sha256:29c3189895a8a6a657b7af4e97d330c8a3afd2c9c8f46c81e2fc5a31866517e3", size = 11548669, upload-time = "2025-06-05T21:00:11.147Z" },
- { url = "https://files.pythonhosted.org/packages/ec/bf/b273dd11673fed8a6bd46032c0ea2a04b2ac9bfa9c628756a5856ba113b0/ruff-0.11.13-py3-none-win_arm64.whl", hash = "sha256:b4385285e9179d608ff1d2fb9922062663c658605819a6876d8beef0c30b7f3b", size = 10683928, upload-time = "2025-06-05T21:00:13.758Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/fd/b44c5115539de0d598d75232a1cc7201430b6891808df111b8b0506aae43/ruff-0.12.3-py3-none-linux_armv6l.whl", hash = "sha256:47552138f7206454eaf0c4fe827e546e9ddac62c2a3d2585ca54d29a890137a2", size = 10430499, upload-time = "2025-07-11T13:20:26.321Z" },
+ { url = "https://files.pythonhosted.org/packages/43/c5/9eba4f337970d7f639a37077be067e4ec80a2ad359e4cc6c5b56805cbc66/ruff-0.12.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0a9153b000c6fe169bb307f5bd1b691221c4286c133407b8827c406a55282041", size = 11213413, upload-time = "2025-07-11T13:20:30.017Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/2c/fac3016236cf1fe0bdc8e5de4f24c76ce53c6dd9b5f350d902549b7719b2/ruff-0.12.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fa6b24600cf3b750e48ddb6057e901dd5b9aa426e316addb2a1af185a7509882", size = 10586941, upload-time = "2025-07-11T13:20:33.046Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/0f/41fec224e9dfa49a139f0b402ad6f5d53696ba1800e0f77b279d55210ca9/ruff-0.12.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2506961bf6ead54887ba3562604d69cb430f59b42133d36976421bc8bd45901", size = 10783001, upload-time = "2025-07-11T13:20:35.534Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/ca/dd64a9ce56d9ed6cad109606ac014860b1c217c883e93bf61536400ba107/ruff-0.12.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c4faaff1f90cea9d3033cbbcdf1acf5d7fb11d8180758feb31337391691f3df0", size = 10269641, upload-time = "2025-07-11T13:20:38.459Z" },
+ { url = "https://files.pythonhosted.org/packages/63/5c/2be545034c6bd5ce5bb740ced3e7014d7916f4c445974be11d2a406d5088/ruff-0.12.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40dced4a79d7c264389de1c59467d5d5cefd79e7e06d1dfa2c75497b5269a5a6", size = 11875059, upload-time = "2025-07-11T13:20:41.517Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/d4/a74ef1e801ceb5855e9527dae105eaff136afcb9cc4d2056d44feb0e4792/ruff-0.12.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:0262d50ba2767ed0fe212aa7e62112a1dcbfd46b858c5bf7bbd11f326998bafc", size = 12658890, upload-time = "2025-07-11T13:20:44.442Z" },
+ { url = "https://files.pythonhosted.org/packages/13/c8/1057916416de02e6d7c9bcd550868a49b72df94e3cca0aeb77457dcd9644/ruff-0.12.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12371aec33e1a3758597c5c631bae9a5286f3c963bdfb4d17acdd2d395406687", size = 12232008, upload-time = "2025-07-11T13:20:47.374Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/59/4f7c130cc25220392051fadfe15f63ed70001487eca21d1796db46cbcc04/ruff-0.12.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:560f13b6baa49785665276c963edc363f8ad4b4fc910a883e2625bdb14a83a9e", size = 11499096, upload-time = "2025-07-11T13:20:50.348Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/01/a0ad24a5d2ed6be03a312e30d32d4e3904bfdbc1cdbe63c47be9d0e82c79/ruff-0.12.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:023040a3499f6f974ae9091bcdd0385dd9e9eb4942f231c23c57708147b06311", size = 11688307, upload-time = "2025-07-11T13:20:52.945Z" },
+ { url = "https://files.pythonhosted.org/packages/93/72/08f9e826085b1f57c9a0226e48acb27643ff19b61516a34c6cab9d6ff3fa/ruff-0.12.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:883d844967bffff5ab28bba1a4d246c1a1b2933f48cb9840f3fdc5111c603b07", size = 10661020, upload-time = "2025-07-11T13:20:55.799Z" },
+ { url = "https://files.pythonhosted.org/packages/80/a0/68da1250d12893466c78e54b4a0ff381370a33d848804bb51279367fc688/ruff-0.12.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2120d3aa855ff385e0e562fdee14d564c9675edbe41625c87eeab744a7830d12", size = 10246300, upload-time = "2025-07-11T13:20:58.222Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/22/5f0093d556403e04b6fd0984fc0fb32fbb6f6ce116828fd54306a946f444/ruff-0.12.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6b16647cbb470eaf4750d27dddc6ebf7758b918887b56d39e9c22cce2049082b", size = 11263119, upload-time = "2025-07-11T13:21:01.503Z" },
+ { url = "https://files.pythonhosted.org/packages/92/c9/f4c0b69bdaffb9968ba40dd5fa7df354ae0c73d01f988601d8fac0c639b1/ruff-0.12.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e1417051edb436230023575b149e8ff843a324557fe0a265863b7602df86722f", size = 11746990, upload-time = "2025-07-11T13:21:04.524Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/84/7cc7bd73924ee6be4724be0db5414a4a2ed82d06b30827342315a1be9e9c/ruff-0.12.3-py3-none-win32.whl", hash = "sha256:dfd45e6e926deb6409d0616078a666ebce93e55e07f0fb0228d4b2608b2c248d", size = 10589263, upload-time = "2025-07-11T13:21:07.148Z" },
+ { url = "https://files.pythonhosted.org/packages/07/87/c070f5f027bd81f3efee7d14cb4d84067ecf67a3a8efb43aadfc72aa79a6/ruff-0.12.3-py3-none-win_amd64.whl", hash = "sha256:a946cf1e7ba3209bdef039eb97647f1c77f6f540e5845ec9c114d3af8df873e7", size = 11695072, upload-time = "2025-07-11T13:21:11.004Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/30/f3eaf6563c637b6e66238ed6535f6775480db973c836336e4122161986fc/ruff-0.12.3-py3-none-win_arm64.whl", hash = "sha256:5f9c7c9c8f84c2d7f27e93674d27136fbf489720251544c4da7fb3d742e011b1", size = 10805855, upload-time = "2025-07-11T13:21:13.547Z" },
]
[[package]]
diff --git a/web/app/(shareLayout)/webapp-reset-password/set-password/page.tsx b/web/app/(shareLayout)/webapp-reset-password/set-password/page.tsx
index 9f9a8ad4e3..5e3f6fff1d 100644
--- a/web/app/(shareLayout)/webapp-reset-password/set-password/page.tsx
+++ b/web/app/(shareLayout)/webapp-reset-password/set-password/page.tsx
@@ -9,8 +9,7 @@ import Button from '@/app/components/base/button'
import { changeWebAppPasswordWithToken } from '@/service/common'
import Toast from '@/app/components/base/toast'
import Input from '@/app/components/base/input'
-
-const validPassword = /^(?=.*[a-zA-Z])(?=.*\d).{8,}$/
+import { validPassword } from '@/config'
const ChangePasswordForm = () => {
const { t } = useTranslation()
diff --git a/web/app/account/account-page/index.tsx b/web/app/account/account-page/index.tsx
index 19c1e44236..ffaecb79ef 100644
--- a/web/app/account/account-page/index.tsx
+++ b/web/app/account/account-page/index.tsx
@@ -21,6 +21,7 @@ import { IS_CE_EDITION } from '@/config'
import Input from '@/app/components/base/input'
import PremiumBadge from '@/app/components/base/premium-badge'
import { useGlobalPublicStore } from '@/context/global-public-context'
+import { validPassword } from '@/config'
const titleClassName = `
system-sm-semibold text-text-secondary
@@ -29,8 +30,6 @@ const descriptionClassName = `
mt-1 body-xs-regular text-text-tertiary
`
-const validPassword = /^(?=.*[a-zA-Z])(?=.*\d).{8,}$/
-
export default function AccountPage() {
const { t } = useTranslation()
const { systemFeatures } = useGlobalPublicStore()
diff --git a/web/app/components/app-sidebar/app-info.tsx b/web/app/components/app-sidebar/app-info.tsx
index c28cc20df5..3817ebf5a4 100644
--- a/web/app/components/app-sidebar/app-info.tsx
+++ b/web/app/components/app-sidebar/app-info.tsx
@@ -308,13 +308,11 @@ const AppInfo = ({ expand, onlyShowDetail = false, openState = false, onDetailEx
operations={operations}
/>
- Search
@@ -170,7 +170,7 @@ const EmojiPickerInner: FC