Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
"""Unit tests for the email-registration Flask adapter."""
from __future__ import annotations
from collections.abc import Callable, Generator
from contextlib import contextmanager
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from pydantic import ValidationError
from pytest_mock import MockerFixture
from sqlalchemy.orm import Session, sessionmaker
from controllers.console import bp as console_bp
from controllers.console.auth.email_register import (
EmailRegisterCheckApi,
EmailRegisterResetApi,
EmailRegisterResetPayload,
EmailRegisterSendEmailApi,
)
from controllers.console.auth.error import (
EmailAlreadyInUseError,
EmailCodeError,
EmailRegisterLimitError,
EmailRegisterRateLimitExceededError,
InvalidEmailError,
InvalidTokenError,
NormalizedEmailAlreadyInUseError,
PasswordMismatchError,
)
from controllers.console.error import (
AccountInFreezeError,
EmailDomainSuspendedError,
EmailSendIpLimitError,
SeatsLimitExceeded,
)
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_redis import RedisClientWrapper
from services.account.email_registration_service import AccountEmailRegistrationService
from services.account_errors import (
AccountEmailAlreadyInUseError,
AccountEmailDomainSuspendedError,
AccountEmailFrozenError,
AccountNormalizedEmailAlreadyInUseError,
EmailRegistrationPasswordMismatchError,
EmailRegistrationSeatsLimitError,
EmailRegistrationSendIPLimitedError,
EmailRegistrationSendRateLimitError,
EmailRegistrationVerificationLimitError,
InvalidEmailRegistrationAddressError,
InvalidEmailRegistrationCodeError,
InvalidEmailRegistrationTokenError,
)
from services.entities.account_entities import AccountEmailRegistrationVerification, AccountSessionTokens
@pytest.fixture(autouse=True)
def _cloud_edition(config_overrides: Callable[..., None]) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
@contextmanager
def _request(
app: Flask,
service: AccountEmailRegistrationService,
*,
path: str,
payload: dict[str, str],
) -> Generator[None]:
services = SimpleNamespace(accounts=SimpleNamespace(email_registration=service))
with (
patch("controllers.console.auth.email_register.application_services", return_value=services),
patch(
"controllers.console.flask_admission.SystemFeatureService.is_email_password_login_enabled",
return_value=True,
),
patch(
"controllers.console.flask_admission.SystemFeatureService.is_registration_allowed",
return_value=True,
),
patch("controllers.console.auth.email_register.extract_remote_ip", return_value="127.0.0.1"),
app.test_request_context(path, method="POST", json=payload),
):
yield
@pytest.fixture
def service(
sqlite_session_factory: sessionmaker[Session],
redis_transport: tuple[RedisClientWrapper, MagicMock],
mocker: MockerFixture,
) -> AccountEmailRegistrationService:
service = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis_transport[0],
).accounts.email_registration
mocker.patch.object(service, "send_code")
mocker.patch.object(service, "verify_code")
mocker.patch.object(service, "register")
return service
def test_normalized_email_conflict_exposes_a_distinct_error_code() -> None:
error = NormalizedEmailAlreadyInUseError()
assert error.code == 400
assert error.data is not None
assert error.data["code"] == "normalized_email_already_in_use"
def test_send_email_delegates_with_remote_ip(app: Flask, service: AccountEmailRegistrationService) -> None:
service.send_code.return_value = "token-123"
with _request(
app,
service,
path="/email-register/send-email",
payload={"email": "[email protected]", "language": "zh-Hans"},
):
response = EmailRegisterSendEmailApi().post()
assert response == {"result": "success", "data": "token-123"}
assert service.send_code.call_args.kwargs == {
"remote_ip": "127.0.0.1",
"requested_email": "[email protected]",
"requested_language": "zh-Hans",
}
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(EmailRegistrationSendIPLimitedError(), EmailSendIpLimitError, id="ip-limit"),
pytest.param(EmailRegistrationSendRateLimitError(1), EmailRegisterRateLimitExceededError, id="send-limit"),
pytest.param(AccountEmailFrozenError(), AccountInFreezeError, id="frozen"),
pytest.param(AccountEmailDomainSuspendedError(), EmailDomainSuspendedError, id="suspended-domain"),
],
)
def test_send_email_translates_application_errors(
app: Flask,
service: AccountEmailRegistrationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
service.send_code.side_effect = service_error
with _request(
app,
service,
path="/email-register/send-email",
payload={"email": "[email protected]"},
):
with pytest.raises(http_error):
EmailRegisterSendEmailApi().post()
def test_verify_email_code_serializes_application_result(app: Flask, service: AccountEmailRegistrationService) -> None:
service.verify_code.return_value = AccountEmailRegistrationVerification(
email="[email protected]",
token="verified-token",
)
with _request(
app,
service,
path="/email-register/validity",
payload={"email": "[email protected]", "code": "123456", "token": "pending-token"},
):
response = EmailRegisterCheckApi().post()
assert response == {"is_valid": True, "email": "[email protected]", "token": "verified-token"}
service.verify_code.assert_called_once_with(
email="[email protected]",
code="123456",
token="pending-token",
)
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(EmailRegistrationVerificationLimitError(), EmailRegisterLimitError, id="attempt-limit"),
pytest.param(InvalidEmailRegistrationTokenError(), InvalidTokenError, id="token"),
pytest.param(InvalidEmailRegistrationAddressError(), InvalidEmailError, id="email"),
pytest.param(InvalidEmailRegistrationCodeError(), EmailCodeError, id="code"),
],
)
def test_verify_email_code_translates_application_errors(
app: Flask,
service: AccountEmailRegistrationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
service.verify_code.side_effect = service_error
with _request(
app,
service,
path="/email-register/validity",
payload={"email": "[email protected]", "code": "wrong", "token": "pending-token"},
):
with pytest.raises(http_error):
EmailRegisterCheckApi().post()
def test_register_delegates_and_serializes_tokens(app: Flask, service: AccountEmailRegistrationService) -> None:
service.register.return_value = AccountSessionTokens(
access_token="access",
refresh_token="refresh",
csrf_token="csrf",
)
with _request(
app,
service,
path="/email-register",
payload={
"token": "verified-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
"language": "zh-Hans",
"timezone": "Asia/Shanghai",
},
):
response = EmailRegisterResetApi().post()
assert response == {
"result": "success",
"data": {"access_token": "access", "refresh_token": "refresh", "csrf_token": "csrf"},
}
assert service.register.call_args.kwargs == {
"remote_ip": "127.0.0.1",
"token": "verified-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
"language": "zh-Hans",
"timezone": "Asia/Shanghai",
}
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(EmailRegistrationPasswordMismatchError(), PasswordMismatchError, id="password"),
pytest.param(InvalidEmailRegistrationTokenError(), InvalidTokenError, id="token"),
pytest.param(
AccountNormalizedEmailAlreadyInUseError(),
NormalizedEmailAlreadyInUseError,
id="normalized-email-in-use",
),
pytest.param(AccountEmailAlreadyInUseError(), EmailAlreadyInUseError, id="email-in-use"),
pytest.param(EmailRegistrationSeatsLimitError(), SeatsLimitExceeded, id="seat-limit"),
pytest.param(AccountEmailFrozenError(), AccountInFreezeError, id="frozen"),
pytest.param(AccountEmailDomainSuspendedError(), EmailDomainSuspendedError, id="suspended-domain"),
],
)
def test_register_translates_application_errors(
app: Flask,
service: AccountEmailRegistrationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
service.register.side_effect = service_error
with _request(
app,
service,
path="/email-register",
payload={
"token": "verified-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
},
):
with pytest.raises(http_error):
EmailRegisterResetApi().post()
def test_reset_payload_rejects_invalid_timezone() -> None:
with pytest.raises(ValidationError):
EmailRegisterResetPayload.model_validate(
{
"token": "token-123",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
"timezone": "",
}
)
def test_invalid_password_is_sanitized_by_real_error_handler(caplog: pytest.LogCaptureFixture) -> None:
app = Flask(__name__)
app.config["TESTING"] = True
app.register_blueprint(console_bp)
password_marker = "SecretMarker"
with (
patch(
"controllers.console.flask_admission.SystemFeatureService.is_email_password_login_enabled",
return_value=True,
),
patch(
"controllers.console.flask_admission.SystemFeatureService.is_registration_allowed",
return_value=True,
),
):
response = app.test_client().post(
"/console/api/email-register",
json={
"token": "verified-token",
"new_password": password_marker,
"password_confirm": password_marker,
},
)
assert response.status_code == 422
assert password_marker not in response.get_data(as_text=True)
assert password_marker not in caplog.text