Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

11.3 KB
Raw Blame
"""Account lifecycle regressions through application ports and real SQLite Sessions."""

from collections.abc import Callable
from datetime import datetime
from unittest.mock import Mock

import pytest
from sqlalchemy import select
from sqlalchemy.orm import Session, sessionmaker

from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole, TenantStatus
from models.human_input_v2 import ContactSubjectType, HumanInputContactIdentity
from models.model import DifySetup
from repositories.human_input_v2.contact import ContactError, ContactErrorCode
from repositories.human_input_v2.sqlalchemy_contact_repository import SQLAlchemyContactRepository
from repositories.installation_state_repository import InstallationStateRepository
from services.account.contracts import SetupInput
from services.account.service import AccountSetupProvisioner
from services.account_errors import (
    AccountEmailDomainSuspendedError,
    AccountLoginError,
    AccountNormalizedEmailAlreadyInUseError,
    AccountNotFoundError,
    AccountPasswordError,
    AccountRegisterError,
    SeatsLimitExceededError,
)
from services.entities.account_entities import AccountSessionTokens
from services.errors.workspace import WorkSpaceNotAllowedCreateError
from tests.helpers.unit.account_domain import AccountDomain


def test_creation_hashes_password_and_keeps_registration_ip(
    account_domain: AccountDomain, sqlite_session: Session
) -> None:
    account = account_domain.accounts.create_account(
        "[email protected]", "New", "en-US", password="Valid123!", ip_address="203.0.113.1"
    )
    stored = sqlite_session.get(Account, account.id)
    assert stored is not None
    assert stored.email == "[email protected]"
    assert stored.normalized_email == "[email protected]"
    assert stored.password != "Valid123!"
    assert stored.last_login_ip == "203.0.113.1"
    contact = sqlite_session.scalars(
        select(HumanInputContactIdentity).where(HumanInputContactIdentity.account_id == account.id)
    ).one()
    assert contact.subject_type == ContactSubjectType.ACCOUNT
    assert account.status == "active"
    assert account.initialized_at is None
    assert account_domain.accounts.authenticate("[email protected]", "Valid123!").id == account.id
    with pytest.raises(AccountPasswordError):
        account_domain.accounts.authenticate(account.email, "wrong")


def test_creation_rolls_back_account_when_contact_creation_fails(
    account_domain: AccountDomain,
    sqlite_session: Session,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    def fail_contact(*_args: object, **_kwargs: object) -> None:
        raise ContactError(ContactErrorCode.CONFLICT, "Contact creation failed")

    monkeypatch.setattr(SQLAlchemyContactRepository, "provision_account_backed_contact", fail_contact)
    with pytest.raises(ContactError, match="Contact creation failed"):
        account_domain.accounts.create_account("[email protected]", "New", "en-US")
    assert sqlite_session.scalar(select(Account.id)) is None
    assert sqlite_session.scalar(select(HumanInputContactIdentity.id)) is None


@pytest.mark.parametrize(
    ("setting", "value", "error"),
    [
        pytest.param(
            lambda policy: policy.is_registration_allowed, False, AccountNotFoundError, id="registration_disabled"
        ),
        pytest.param(lambda policy: policy.has_account_capacity, False, SeatsLimitExceededError, id="seat_limit"),
        pytest.param(
            lambda policy: policy.get_email_freeze_type,
            "email_domain_suspended",
            AccountEmailDomainSuspendedError,
            id="domain_suspended",
        ),
        pytest.param(lambda policy: policy.get_email_freeze_type, "deleted", AccountRegisterError, id="deleted"),
    ],
)
def test_creation_policy_prevents_persistence(
    account_domain: AccountDomain,
    sqlite_session: Session,
    setting: Callable[[Mock], Mock],
    value: object,
    error: type[Exception],
) -> None:
    setting(account_domain.policy).return_value = value
    with pytest.raises(error):
        account_domain.accounts.create_account("[email protected]", "New", "en-US")
    assert sqlite_session.scalar(select(Account.id)) is None


def test_setup_bypasses_registration_but_not_seat_limit(account_domain: AccountDomain) -> None:
    account_domain.policy.is_registration_allowed.return_value = False
    account_domain.accounts.create_account("[email protected]", "First", "en-US", is_setup=True)
    account_domain.policy.has_account_capacity.return_value = False
    with pytest.raises(SeatsLimitExceededError):
        account_domain.accounts.create_account("[email protected]", "Second", "en-US", is_setup=True)


def test_email_collision_is_checked_before_capacity(account_domain: AccountDomain) -> None:
    account_domain.accounts.create_account("[email protected]", "First", "en-US")
    account_domain.policy.has_account_capacity.return_value = False
    with pytest.raises(AccountNormalizedEmailAlreadyInUseError):
        account_domain.accounts.create_account("[email protected]", "Second", "en-US", check_normalized_email=True)


@pytest.mark.parametrize("timezone", [None, "Asia/Singapore"])
def test_registration_initializes_and_creates_owner_membership(
    account_domain: AccountDomain, sqlite_session: Session, timezone: str | None
) -> None:
    account = account_domain.accounts.register("[email protected]", "New", language="zh-Hans", timezone=timezone)
    assert account.initialized_at == datetime(2026, 1, 1)
    assert account.timezone == (timezone or "Asia/Shanghai")
    memberships = list(sqlite_session.scalars(select(TenantAccountJoin)))
    assert len(memberships) == 1
    assert memberships[0].account_id == account.id
    assert memberships[0].role == TenantAccountRole.OWNER
    assert not memberships[0].current
    contact = sqlite_session.scalars(
        select(HumanInputContactIdentity).where(HumanInputContactIdentity.account_id == account.id)
    ).one()
    assert contact.subject_type == ContactSubjectType.ACCOUNT
    account_domain.policy.try_join_default_workspace.assert_called_once_with(account.id)


@pytest.mark.parametrize(
    "setting",
    [
        pytest.param(lambda policy: policy.is_workspace_creation_allowed, id="creation_disabled"),
        pytest.param(lambda policy: policy.has_workspace_capacity, id="workspace_limit"),
    ],
)
def test_registration_without_personal_workspace_still_joins_default(
    account_domain: AccountDomain, sqlite_session: Session, setting: Callable[[Mock], Mock]
) -> None:
    setting(account_domain.policy).return_value = False
    account = account_domain.accounts.register("[email protected]", "New", status="pending")
    assert account.status == "pending"
    assert sqlite_session.scalar(select(Tenant.id)) is None
    account_domain.policy.try_join_default_workspace.assert_called_once_with(account.id)


def test_personal_workspace_failure_still_attempts_enterprise_join(account_domain: AccountDomain) -> None:
    account_domain.policy.is_workspace_creation_allowed.return_value = False
    with pytest.raises(WorkSpaceNotAllowedCreateError):
        account_domain.accounts.create_account_and_tenant("[email protected]", "New", "en-US")
    account_domain.policy.try_join_default_workspace.assert_called_once()


def test_existing_archived_membership_prevents_implicit_workspace_creation(
    account_domain: AccountDomain, sqlite_session: Session
) -> None:
    account = account_domain.accounts.create_account("[email protected]", "A", "en-US")
    tenant = Tenant(name="Archived", status=TenantStatus.ARCHIVE)
    sqlite_session.add_all(
        [tenant, TenantAccountJoin(account_id=account.id, tenant_id=tenant.id, role=TenantAccountRole.NORMAL)]
    )
    sqlite_session.commit()
    account_domain.provisioning.create_owner_workspace(account.id, if_missing=True)
    assert list(sqlite_session.scalars(select(Tenant.id))) == [tenant.id]


def test_login_activates_pending_and_issues_tokens_after_commit(
    account_domain: AccountDomain, sqlite_session: Session
) -> None:
    account = account_domain.accounts.create_account("[email protected]", "A", "en-US", status="pending")
    pair = AccountSessionTokens("access", "refresh", "csrf")

    def issue(account_id: str) -> AccountSessionTokens:
        stored = sqlite_session.get(Account, account_id)
        assert stored is not None
        assert stored.status == AccountStatus.ACTIVE
        assert stored.last_login_ip == "203.0.113.2"
        return pair

    account_domain.sessions.issue.side_effect = issue
    assert account_domain.accounts.login(account.id, ip_address="203.0.113.2") == pair
    with pytest.raises(AccountNotFoundError):
        account_domain.accounts.login("missing", ip_address="203.0.113.2")


def test_authentication_rejects_banned_account(account_domain: AccountDomain) -> None:
    account_domain.accounts.create_account("[email protected]", "B", "en-US", password="Valid123!", status="banned")
    with pytest.raises(AccountLoginError):
        account_domain.accounts.authenticate("[email protected]", "Valid123!")


def test_setup_cleans_partial_state_on_failure(
    account_domain: AccountDomain, sqlite_session_factory: sessionmaker[Session], sqlite_session: Session
) -> None:
    class Telemetry:
        def report(self) -> None:
            pytest.fail("Failed setup cannot report success")

    installation = InstallationStateRepository(session_factory=sqlite_session_factory)
    account_domain.policy.has_workspace_capacity.return_value = False
    provisioner = AccountSetupProvisioner(
        accounts=account_domain.accounts,
        workspaces=account_domain.provisioning,
        installation=installation,
        telemetry=Telemetry(),
    )
    with pytest.raises(ValueError, match="Setup failed"):
        provisioner.provision(
            SetupInput(email="[email protected]", name="A", password="Valid123!", ip_address="127.0.0.1", language="en-US")
        )
    assert sqlite_session.scalar(select(Account.id)) is None
    assert sqlite_session.scalar(select(Tenant.id)) is None
    assert sqlite_session.scalar(select(DifySetup.version)) is None
    assert sqlite_session.scalar(select(HumanInputContactIdentity.id)) is None


def test_setup_persists_initialized_owner_before_telemetry(
    account_domain: AccountDomain, sqlite_session_factory: sessionmaker[Session]
) -> None:
    reported: list[str] = []

    class Telemetry:
        def report(self) -> None:
            with sqlite_session_factory() as session:
                account = session.scalar(select(Account))
                assert account is not None
                assert account.initialized_at == datetime(2026, 1, 1)
                assert session.scalar(select(DifySetup.version)) is not None
                owner = session.scalar(select(TenantAccountJoin))
                assert owner is not None
                assert owner.account_id == account.id
                assert owner.role == TenantAccountRole.OWNER
                reported.append(account.id)

    account_domain.policy.is_registration_allowed.return_value = False
    account_domain.policy.is_workspace_creation_allowed.return_value = False
    provisioner = AccountSetupProvisioner(
        accounts=account_domain.accounts,
        workspaces=account_domain.provisioning,
        installation=InstallationStateRepository(session_factory=sqlite_session_factory),
        telemetry=Telemetry(),
    )
    provisioner.provision(
        SetupInput(email="[email protected]", name="A", password="Valid123!", ip_address="127.0.0.1", language="en-US")
    )
    assert len(reported) == 1