Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import datetime
import pytest
from services import account_errors
from services.account.login_service import ConsoleAuthenticationService
from services.entities.account_entities import AccountPasswordDigest, AccountSessionTokens
from services.entities.account_login_entities import (
AccountSessionPreparation,
EmailCodeChallengeStatus,
EmailCodeLoginCommand,
EmailCodeSendCommand,
LoginAccountSnapshot,
LoginInvitation,
PasswordLoginCommand,
PasswordLoginCompletion,
RefreshAccountStatus,
)
from services.entities.auth_audit_entities import LoginFailureReason
TOKENS = AccountSessionTokens(access_token="access", refresh_token="refresh", csrf_token="csrf")
LOGIN_TIME = datetime(2026, 8, 24, 12, 0, 0)
@dataclass
class FakeAccounts:
candidates: list[LoginAccountSnapshot] = field(default_factory=list)
lookup_email: str | None = None
session_prepared: bool = True
completions: list[PasswordLoginCompletion] = field(default_factory=list)
session_preparations: list[tuple[str, AccountSessionPreparation]] = field(default_factory=list)
def list_for_login(self, email: str) -> tuple[LoginAccountSnapshot, ...]:
self.lookup_email = email
return tuple(self.candidates)
def complete_password_login(self, completion: PasswordLoginCompletion) -> bool:
self.completions.append(completion)
return any(completion.account_id == account.id for account in self.candidates)
def prepare_session(self, account_id: str, preparation: AccountSessionPreparation) -> bool:
self.session_preparations.append((account_id, preparation))
return self.session_prepared
@dataclass
class FakeWorkspaces:
active: bool = False
checks: list[str] = field(default_factory=list)
def has_active_for_account(self, account_id: str) -> bool:
self.checks.append(account_id)
return self.active
@dataclass
class FakeInvitations:
invitation: LoginInvitation | None = None
ensured: list[tuple[str, str, str]] = field(default_factory=list)
restored_workspace: FakeWorkspaces | None = None
def resolve(self, *, email: str, token: str) -> LoginInvitation | None:
_ = email, token
return self.invitation
def ensure_membership(self, *, account_id: str, email: str, token: str) -> bool:
self.ensured.append((account_id, email, token))
if self.restored_workspace is None:
return False
self.restored_workspace.active = True
return True
@dataclass
class FakePolicies:
freeze_type: str | None = None
registration_allowed: bool = True
workspace_creation_allowed: bool = True
workspace_capacity: bool = True
account_capacity: bool = True
def get_email_freeze_type(self, email: str) -> str | None:
_ = email
return self.freeze_type
def is_registration_allowed(self) -> bool:
return self.registration_allowed
def is_workspace_creation_allowed(self) -> bool:
return self.workspace_creation_allowed
def has_workspace_capacity(self) -> bool:
return self.workspace_capacity
def has_account_capacity(self) -> bool:
return self.account_capacity
@dataclass
class FakeSecurity:
login_limited: bool = False
ip_limited: bool = False
failures: list[str] = field(default_factory=list)
resets: list[str] = field(default_factory=list)
def is_login_limited(self, email: str) -> bool:
_ = email
return self.login_limited
def record_login_failure(self, email: str) -> None:
self.failures.append(email)
def reset_login_failures(self, email: str) -> None:
self.resets.append(email)
def is_email_send_ip_limited(self, ip_address: str) -> bool:
_ = ip_address
return self.ip_limited
@dataclass
class FakePasswords:
valid: bool = True
valid_password_hashes: set[str] | None = None
hash_error: account_errors.InvalidAccountPasswordError | None = None
hashed_passwords: list[str] = field(default_factory=list)
def verify(self, password: str, *, password_hash: str, password_salt: str) -> bool:
_ = password, password_hash, password_salt
if self.valid_password_hashes is not None:
return password_hash in self.valid_password_hashes
return self.valid
def hash(self, password: str) -> AccountPasswordDigest:
self.hashed_passwords.append(password)
if self.hash_error is not None:
raise self.hash_error
return AccountPasswordDigest(password_hash=f"hashed:{password}", password_salt="salt")
@dataclass
class FakeHumanVerification:
calls: list[tuple[str | None, str, str]] = field(default_factory=list)
def verify(self, *, token: str | None, remote_ip: str, action: str) -> None:
self.calls.append((token, remote_ip, action))
@dataclass
class FakeSessions:
issued: list[str] = field(default_factory=list)
revoked: list[str] = field(default_factory=list)
refresh_account_id: str | None = "account-1"
rotations: list[tuple[str, str]] = field(default_factory=list)
def issue(self, account_id: str) -> AccountSessionTokens:
self.issued.append(account_id)
return TOKENS
def revoke(self, account_id: str) -> None:
self.revoked.append(account_id)
def resolve_refresh_token(self, refresh_token: str) -> str | None:
assert refresh_token == "old-refresh"
return self.refresh_account_id
def rotate(self, *, refresh_token: str, account_id: str) -> AccountSessionTokens:
self.rotations.append((refresh_token, account_id))
return TOKENS
@dataclass
class FakeRefreshPreparation:
status: RefreshAccountStatus = RefreshAccountStatus.READY
account_ids: list[str] = field(default_factory=list)
def prepare(self, account_id: str) -> RefreshAccountStatus:
self.account_ids.append(account_id)
return self.status
@dataclass
class FakeAccountProvisioning:
calls: list[dict[str, str]] = field(default_factory=list)
def create_with_owner_workspace(
self,
*,
email: str,
name: str,
interface_language: str,
timezone: str,
ip_address: str,
) -> str:
self.calls.append(
{
"email": email,
"name": name,
"interface_language": interface_language,
"timezone": timezone,
"ip_address": ip_address,
}
)
return "new-account"
@dataclass
class FakeWorkspaceProvisioning:
account_ids: list[str] = field(default_factory=list)
def ensure_owner_workspace(self, account_id: str) -> None:
self.account_ids.append(account_id)
@dataclass
class FakeEmailCodes:
status: EmailCodeChallengeStatus = EmailCodeChallengeStatus.VERIFIED
sent: list[tuple[str | None, str, str, str, bool]] = field(default_factory=list)
def send(
self,
*,
account_id: str | None,
normalized_email: str,
recipient_email: str,
language: str,
registration_allowed: bool,
) -> str:
self.sent.append((account_id, normalized_email, recipient_email, language, registration_allowed))
return "email-token"
def verify(self, *, normalized_email: str, code: str, token: str) -> EmailCodeChallengeStatus:
_ = normalized_email, code, token
return self.status
@dataclass
class FakeResetPasswordEmails:
sent: list[tuple[str | None, str, str, bool]] = field(default_factory=list)
def send(
self,
*,
account_id: str | None,
email: str,
language: str,
registration_allowed: bool,
) -> str:
self.sent.append((account_id, email, language, registration_allowed))
return "reset-token"
@dataclass
class FakeAudit:
failures: list[tuple[str, LoginFailureReason, str]] = field(default_factory=list)
def login_failed(self, *, email: str, reason: LoginFailureReason, ip_address: str) -> None:
self.failures.append((email, reason, ip_address))
@dataclass
class Dependencies:
accounts: FakeAccounts = field(default_factory=FakeAccounts)
workspaces: FakeWorkspaces = field(default_factory=FakeWorkspaces)
invitations: FakeInvitations = field(default_factory=FakeInvitations)
policies: FakePolicies = field(default_factory=FakePolicies)
security: FakeSecurity = field(default_factory=FakeSecurity)
passwords: FakePasswords = field(default_factory=FakePasswords)
human: FakeHumanVerification = field(default_factory=FakeHumanVerification)
sessions: FakeSessions = field(default_factory=FakeSessions)
refresh_preparation: FakeRefreshPreparation = field(default_factory=FakeRefreshPreparation)
accounts_provisioning: FakeAccountProvisioning = field(default_factory=FakeAccountProvisioning)
workspaces_provisioning: FakeWorkspaceProvisioning = field(default_factory=FakeWorkspaceProvisioning)
email_codes: FakeEmailCodes = field(default_factory=FakeEmailCodes)
reset_emails: FakeResetPasswordEmails = field(default_factory=FakeResetPasswordEmails)
audit: FakeAudit = field(default_factory=FakeAudit)
def service(
self,
*,
turnstile_enabled: bool = False,
turnstile_verify_required: bool = False,
) -> ConsoleAuthenticationService:
return ConsoleAuthenticationService(
accounts=self.accounts,
workspaces=self.workspaces,
invitations=self.invitations,
policies=self.policies,
security=self.security,
passwords=self.passwords,
human_verification=self.human,
sessions=self.sessions,
refresh_preparation=self.refresh_preparation,
account_provisioning=self.accounts_provisioning,
workspace_provisioning=self.workspaces_provisioning,
email_codes=self.email_codes,
reset_password_emails=self.reset_emails,
audit=self.audit,
now=lambda: LOGIN_TIME,
turnstile_enabled=turnstile_enabled,
turnstile_verify_required=turnstile_verify_required,
)
def _account(
*,
account_id: str = "account-1",
password: bool = True,
password_hash: str = "hash",
status: str = "active",
email: str = "[email protected]",
) -> LoginAccountSnapshot:
return LoginAccountSnapshot(
id=account_id,
email=email,
status=status,
password_hash=password_hash if password else None,
password_salt="salt" if password else None,
)
def _password_command(**changes: str | None) -> PasswordLoginCommand:
values = {
"email": "[email protected]",
"password": "password",
"invite_token": None,
"ip_address": "127.0.0.1",
}
values.update(changes)
return PasswordLoginCommand(**values) # type: ignore[arg-type]
def _email_code_command(**changes: str | None) -> EmailCodeLoginCommand:
values = {
"email": "[email protected]",
"code": "123456",
"token": "challenge-token",
"turnstile_token": None,
"language": "zh-Hans",
"timezone": "Asia/Singapore",
"ip_address": "127.0.0.1",
}
values.update(changes)
return EmailCodeLoginCommand(**values) # type: ignore[arg-type]
def test_password_login_issues_session_and_resets_failures() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.workspaces.active = True
result = dependencies.service().login_with_password(_password_command())
assert result.tokens == TOKENS
assert dependencies.accounts.lookup_email == "[email protected]"
assert dependencies.accounts.completions == [
PasswordLoginCompletion(
account_id="account-1",
password=None,
activate_pending_account=False,
initialized_at=None,
)
]
assert dependencies.accounts.session_preparations == [
(
"account-1",
AccountSessionPreparation(
logged_in_at=LOGIN_TIME,
ip_address="127.0.0.1",
activate_pending_account=False,
),
)
]
assert dependencies.sessions.issued == ["account-1"]
assert dependencies.security.resets == ["[email protected]"]
def test_password_login_rejects_account_removed_during_session_preparation() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.accounts.session_prepared = False
dependencies.workspaces.active = True
with pytest.raises(account_errors.AccountNotFoundError):
dependencies.service().login_with_password(_password_command())
assert dependencies.sessions.issued == []
assert dependencies.security.resets == []
def test_invitation_login_sets_missing_password() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(password=False, status="pending")]
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
dependencies.workspaces.active = True
dependencies.service().login_with_password(_password_command(password="password123", invite_token="invite"))
assert dependencies.accounts.completions == [
PasswordLoginCompletion(
account_id="account-1",
password=AccountPasswordDigest(password_hash="hashed:password123", password_salt="salt"),
activate_pending_account=True,
initialized_at=LOGIN_TIME,
)
]
def test_invitation_login_rejects_empty_password_without_completing_account() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(password=False, status="pending")]
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
with pytest.raises(account_errors.InvalidLoginCredentialsError):
dependencies.service().login_with_password(_password_command(password="", invite_token="invite"))
assert dependencies.passwords.hashed_passwords == []
assert dependencies.accounts.completions == []
assert dependencies.security.failures == ["[email protected]"]
assert dependencies.invitations.ensured == []
def test_invitation_login_does_not_initialize_password_when_token_is_unknown() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(password=False, status="pending")]
with pytest.raises(account_errors.InvalidLoginCredentialsError):
dependencies.service().login_with_password(_password_command(invite_token="unknown-invite"))
assert dependencies.passwords.hashed_passwords == []
assert dependencies.accounts.completions == []
assert dependencies.invitations.ensured == []
def test_invitation_login_applies_new_password_policy_before_completion() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(password=False, status="pending")]
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
dependencies.passwords.hash_error = account_errors.InvalidAccountPasswordError(
"Password must contain letters and numbers"
)
with pytest.raises(account_errors.InvalidAccountPasswordError, match="letters and numbers"):
dependencies.service().login_with_password(_password_command(password="letters-only", invite_token="invite"))
assert dependencies.passwords.hashed_passwords == ["letters-only"]
assert dependencies.accounts.completions == []
assert dependencies.invitations.ensured == []
def test_invalid_password_records_rate_limit_and_audit() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.passwords.valid = False
with pytest.raises(account_errors.InvalidLoginCredentialsError):
dependencies.service().login_with_password(_password_command())
assert dependencies.security.failures == ["[email protected]"]
assert dependencies.audit.failures == [("[email protected]", LoginFailureReason.INVALID_CREDENTIALS, "127.0.0.1")]
assert dependencies.invitations.ensured == []
def test_wrong_password_does_not_restore_invited_membership() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
dependencies.passwords.valid = False
with pytest.raises(account_errors.InvalidLoginCredentialsError):
dependencies.service().login_with_password(_password_command(invite_token="invite"))
assert dependencies.invitations.ensured == []
assert dependencies.security.failures == ["[email protected]"]
def test_password_login_rejects_locked_account_before_loading_candidates() -> None:
dependencies = Dependencies()
dependencies.security.login_limited = True
with pytest.raises(account_errors.LoginRateLimitError):
dependencies.service().login_with_password(_password_command())
assert dependencies.accounts.lookup_email is None
assert dependencies.audit.failures == [("[email protected]", LoginFailureReason.LOGIN_RATE_LIMITED, "127.0.0.1")]
@pytest.mark.parametrize(
("freeze_type", "error_type"),
[
("freeze", account_errors.AccountEmailFrozenError),
("email_domain_suspended", account_errors.AccountEmailDomainSuspendedError),
],
)
def test_password_login_enforces_email_freeze_policy(
freeze_type: str,
error_type: type[account_errors.AccountApplicationError],
) -> None:
dependencies = Dependencies()
dependencies.policies.freeze_type = freeze_type
with pytest.raises(error_type):
dependencies.service().login_with_password(_password_command())
assert dependencies.accounts.lookup_email is None
assert dependencies.audit.failures == [("[email protected]", LoginFailureReason.ACCOUNT_IN_FREEZE, "127.0.0.1")]
def test_password_login_rejects_banned_account() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(status="banned")]
with pytest.raises(account_errors.LoginAccountBannedError):
dependencies.service().login_with_password(_password_command())
assert dependencies.accounts.completions == []
assert dependencies.audit.failures == [("[email protected]", LoginFailureReason.ACCOUNT_BANNED, "127.0.0.1")]
def test_password_login_rejects_invitation_for_another_email() -> None:
dependencies = Dependencies()
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
with pytest.raises(account_errors.InvalidLoginInvitationEmailError):
dependencies.service().login_with_password(_password_command(invite_token="invite"))
assert dependencies.accounts.lookup_email is None
assert dependencies.audit.failures == [
("[email protected]", LoginFailureReason.INVALID_INVITATION_EMAIL, "127.0.0.1")
]
assert dependencies.invitations.ensured == []
def test_password_login_tries_lowercase_candidate_after_exact_candidate_password_fails() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [
_account(account_id="mixed-case", email="[email protected]", password_hash="mixed-hash"),
_account(account_id="lowercase", email="[email protected]", password_hash="lower-hash"),
]
dependencies.passwords.valid_password_hashes = {"lower-hash"}
dependencies.workspaces.active = True
result = dependencies.service().login_with_password(_password_command(email="[email protected]"))
assert result.tokens == TOKENS
assert [completion.account_id for completion in dependencies.accounts.completions] == ["lowercase"]
assert dependencies.sessions.issued == ["lowercase"]
assert dependencies.security.failures == []
def test_password_login_returns_no_workspace_without_creating_one() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
result = dependencies.service().login_with_password(_password_command())
assert not result.workspace_found
assert result.tokens is None
assert dependencies.workspaces_provisioning.account_ids == []
assert dependencies.invitations.ensured == []
def test_password_login_restores_invited_membership_when_account_has_no_workspace() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
dependencies.invitations.restored_workspace = dependencies.workspaces
dependencies.policies.workspace_capacity = False
result = dependencies.service().login_with_password(_password_command(invite_token="invite"))
assert dependencies.invitations.ensured == [("account-1", "[email protected]", "invite")]
assert dependencies.workspaces.checks == ["account-1", "account-1"]
assert result.workspace_found
assert result.tokens == TOKENS
assert dependencies.sessions.issued == ["account-1"]
assert dependencies.security.resets == ["[email protected]"]
@pytest.mark.parametrize("invite_token", [None, "invite"])
def test_password_login_does_not_restore_membership_for_an_existing_workspace(invite_token: str | None) -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.workspaces.active = True
if invite_token is not None:
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
result = dependencies.service().login_with_password(_password_command(invite_token=invite_token))
assert result.workspace_found
assert result.tokens == TOKENS
assert dependencies.invitations.ensured == []
assert dependencies.workspaces.checks == ["account-1"]
def test_password_login_enforces_workspace_capacity() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.policies.workspace_capacity = False
with pytest.raises(account_errors.LoginWorkspaceLimitError):
dependencies.service().login_with_password(_password_command())
assert dependencies.invitations.ensured == []
def test_password_login_enforces_workspace_capacity_when_invitation_does_not_restore_membership() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.invitations.invitation = LoginInvitation(email="[email protected]")
dependencies.policies.workspace_capacity = False
with pytest.raises(account_errors.LoginWorkspaceLimitError):
dependencies.service().login_with_password(_password_command(invite_token="invite"))
assert dependencies.invitations.ensured == [("account-1", "[email protected]", "invite")]
assert dependencies.workspaces.checks == ["account-1", "account-1"]
assert dependencies.sessions.issued == []
def test_send_email_code_normalizes_identity_and_preserves_account_recipient_address() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(email="[email protected]")]
token = dependencies.service(turnstile_enabled=True).send_email_code(
EmailCodeSendCommand(
email="[email protected]",
language="zh-Hans",
turnstile_token="turnstile",
ip_address="127.0.0.1",
)
)
assert token == "email-token"
assert dependencies.human.calls == [("turnstile", "127.0.0.1", "signin_code")]
assert dependencies.email_codes.sent == [("account-1", "[email protected]", "[email protected]", "zh-Hans", True)]
@pytest.mark.parametrize("account_exists", [False, True])
@pytest.mark.parametrize("registration_allowed", [False, True])
def test_send_email_code_returns_challenge_regardless_of_account_existence(
account_exists: bool, registration_allowed: bool
) -> None:
dependencies = Dependencies()
dependencies.policies.registration_allowed = registration_allowed
if account_exists:
dependencies.accounts.candidates = [_account()]
token = dependencies.service().send_email_code(
EmailCodeSendCommand(
email="[email protected]",
language=None,
turnstile_token=None,
ip_address="127.0.0.1",
)
)
assert token == "email-token"
assert dependencies.email_codes.sent == [
(
"account-1" if account_exists else None,
"[email protected]",
"[email protected]",
"en-US",
account_exists or registration_allowed,
)
]
def test_send_email_code_for_existing_account_does_not_load_registration_policy(
monkeypatch: pytest.MonkeyPatch,
) -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
def unavailable_policy() -> bool:
raise AssertionError("Registration policy is irrelevant to an existing account")
monkeypatch.setattr(dependencies.policies, "is_registration_allowed", unavailable_policy)
token = dependencies.service().send_email_code(
EmailCodeSendCommand(email="[email protected]", language=None, turnstile_token=None, ip_address="127.0.0.1")
)
assert token == "email-token"
def test_send_email_code_rejects_ip_rate_limit_before_human_verification() -> None:
dependencies = Dependencies()
dependencies.security.ip_limited = True
with pytest.raises(account_errors.EmailCodeSendIPLimitedError):
dependencies.service(turnstile_enabled=True).send_email_code(
EmailCodeSendCommand(
email="[email protected]",
language=None,
turnstile_token="turnstile",
ip_address="127.0.0.1",
)
)
assert dependencies.human.calls == []
assert dependencies.email_codes.sent == []
def test_send_email_code_skips_turnstile_when_disabled() -> None:
dependencies = Dependencies()
dependencies.service(turnstile_enabled=False).send_email_code(
EmailCodeSendCommand(
email="[email protected]",
language=None,
turnstile_token="ignored-token",
ip_address="127.0.0.1",
)
)
assert dependencies.human.calls == []
@pytest.mark.parametrize("code", ["12345", "1234567", "abcdef", "١٢٣٤٥٦"])
def test_email_code_login_rejects_malformed_codes(code: str) -> None:
dependencies = Dependencies()
with pytest.raises(account_errors.InvalidEmailCodeError):
dependencies.service().login_with_email_code(_email_code_command(code=code))
assert dependencies.audit.failures[0][1] == LoginFailureReason.INVALID_EMAIL_CODE
@pytest.mark.parametrize(
("status", "error_type", "reason"),
[
(
EmailCodeChallengeStatus.INVALID_TOKEN,
account_errors.InvalidEmailCodeTokenError,
LoginFailureReason.INVALID_EMAIL_CODE_TOKEN,
),
(
EmailCodeChallengeStatus.EMAIL_MISMATCH,
account_errors.EmailCodeEmailMismatchError,
LoginFailureReason.EMAIL_CODE_EMAIL_MISMATCH,
),
(
EmailCodeChallengeStatus.INVALID_CODE,
account_errors.InvalidEmailCodeError,
LoginFailureReason.INVALID_EMAIL_CODE,
),
(
EmailCodeChallengeStatus.EXHAUSTED,
account_errors.InvalidEmailCodeError,
LoginFailureReason.INVALID_EMAIL_CODE,
),
],
)
def test_email_code_login_maps_challenge_status(
status: EmailCodeChallengeStatus,
error_type: type[account_errors.AccountApplicationError],
reason: LoginFailureReason,
) -> None:
dependencies = Dependencies()
dependencies.email_codes.status = status
with pytest.raises(error_type):
dependencies.service().login_with_email_code(_email_code_command())
assert dependencies.audit.failures == [("[email protected]", reason, "127.0.0.1")]
@pytest.mark.parametrize(
("turnstile_enabled", "verify_required", "turnstile_token", "expected_calls"),
[
(False, True, "provided-token", []),
(True, False, None, []),
(True, False, "provided-token", [("provided-token", "127.0.0.1", "signin_code_verify")]),
(True, True, None, [(None, "127.0.0.1", "signin_code_verify")]),
],
)
def test_email_code_login_applies_turnstile_switches(
turnstile_enabled: bool,
verify_required: bool,
turnstile_token: str | None,
expected_calls: list[tuple[str | None, str, str]],
) -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.workspaces.active = True
dependencies.service(
turnstile_enabled=turnstile_enabled,
turnstile_verify_required=verify_required,
).login_with_email_code(_email_code_command(turnstile_token=turnstile_token))
assert dependencies.human.calls == expected_calls
def test_email_code_login_rejects_banned_account() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account(status="banned")]
with pytest.raises(account_errors.LoginAccountBannedError):
dependencies.service().login_with_email_code(_email_code_command())
assert dependencies.audit.failures == [("[email protected]", LoginFailureReason.ACCOUNT_BANNED, "127.0.0.1")]
@pytest.mark.parametrize(
("workspace_capacity", "workspace_creation_allowed", "error_type"),
[
(False, True, account_errors.LoginWorkspaceLimitError),
(True, False, account_errors.LoginWorkspaceCreationNotAllowedError),
],
)
def test_email_code_login_enforces_workspace_policy(
workspace_capacity: bool,
workspace_creation_allowed: bool,
error_type: type[account_errors.AccountApplicationError],
) -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
dependencies.policies.workspace_capacity = workspace_capacity
dependencies.policies.workspace_creation_allowed = workspace_creation_allowed
with pytest.raises(error_type):
dependencies.service().login_with_email_code(_email_code_command())
assert dependencies.workspaces_provisioning.account_ids == []
assert dependencies.sessions.issued == []
def test_email_code_login_rejects_registration_when_account_is_missing() -> None:
dependencies = Dependencies()
dependencies.policies.registration_allowed = False
with pytest.raises(account_errors.AccountNotFoundError):
dependencies.service().login_with_email_code(_email_code_command())
assert dependencies.accounts_provisioning.calls == []
assert dependencies.sessions.issued == []
@pytest.mark.parametrize(
("account_capacity", "workspace_creation_allowed", "workspace_capacity", "error_type"),
[
(False, True, True, account_errors.LoginSeatLimitError),
(True, False, True, account_errors.LoginWorkspaceCreationNotAllowedError),
(True, True, False, account_errors.LoginWorkspaceLimitError),
],
)
def test_email_code_login_enforces_new_account_provisioning_policy(
account_capacity: bool,
workspace_creation_allowed: bool,
workspace_capacity: bool,
error_type: type[account_errors.AccountApplicationError],
) -> None:
dependencies = Dependencies()
dependencies.policies.account_capacity = account_capacity
dependencies.policies.workspace_creation_allowed = workspace_creation_allowed
dependencies.policies.workspace_capacity = workspace_capacity
with pytest.raises(error_type):
dependencies.service().login_with_email_code(_email_code_command())
assert dependencies.accounts_provisioning.calls == []
assert dependencies.sessions.issued == []
def test_email_code_login_creates_workspace_for_existing_account() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
result = dependencies.service().login_with_email_code(_email_code_command())
assert result == TOKENS
assert dependencies.workspaces_provisioning.account_ids == ["account-1"]
def test_email_code_login_provisions_new_account() -> None:
dependencies = Dependencies()
result = dependencies.service().login_with_email_code(_email_code_command())
assert result == TOKENS
assert dependencies.accounts_provisioning.calls == [
{
"email": "[email protected]",
"name": "[email protected]",
"interface_language": "zh-Hans",
"timezone": "Asia/Singapore",
"ip_address": "127.0.0.1",
}
]
assert dependencies.sessions.issued == ["new-account"]
def test_reset_password_email_uses_shared_account_snapshot() -> None:
dependencies = Dependencies()
dependencies.accounts.candidates = [_account()]
token = dependencies.service().send_reset_password_email(
email="[email protected]",
language="fr-FR",
ip_address="127.0.0.1",
)
assert token == "reset-token"
assert dependencies.reset_emails.sent == [("account-1", "[email protected]", "en-US", True)]
def test_logout_and_refresh_delegate_to_session_gateway() -> None:
dependencies = Dependencies()
service = dependencies.service()
service.logout("account-1")
assert dependencies.sessions.revoked == ["account-1"]
assert service.refresh("old-refresh") == TOKENS
assert dependencies.refresh_preparation.account_ids == ["account-1"]
assert dependencies.sessions.rotations == [("old-refresh", "account-1")]
@pytest.mark.parametrize(
("refresh_account_id", "refresh_status", "message"),
[
(None, RefreshAccountStatus.READY, "Invalid refresh token"),
("account-1", RefreshAccountStatus.NOT_FOUND, "Invalid account"),
("account-1", RefreshAccountStatus.BANNED, "Account is banned"),
],
)
def test_refresh_rejects_invalid_account_state(
refresh_account_id: str | None,
refresh_status: RefreshAccountStatus,
message: str,
) -> None:
dependencies = Dependencies()
dependencies.sessions.refresh_account_id = refresh_account_id
dependencies.refresh_preparation.status = refresh_status
with pytest.raises(account_errors.InvalidRefreshTokenError, match=message):
dependencies.service().refresh("old-refresh")
assert dependencies.sessions.rotations == []