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.

7.1 KB
Raw Blame
"""Invitation issuance and activation through real PostgreSQL and Redis adapters."""

import json
from hashlib import sha256
from unittest.mock import create_autospec
from uuid import uuid4

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

from configs import dify_config
from enums import DeploymentEdition
from extensions.ext_application_services import application_services
from extensions.ext_redis import redis_client
from machinery.context import RequestContext
from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole, TenantStatus
from services.account.adapters import RedisInvitationTokenStore
from services.account_errors import InvalidInvitationError
from services.entities.account_activation_entities import ActivationCommand, InvitationLookup, InvitationToken
from services.workspace import gateways


@pytest.fixture
def workspace(db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch) -> tuple[Tenant, Account, Account]:
    monkeypatch.setattr(dify_config, "DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY)
    monkeypatch.setattr(dify_config, "RBAC_ENABLED", False)
    tenant = Tenant(name="Inviting workspace", status=TenantStatus.NORMAL)
    owner = Account(name="Owner", email=f"owner-{uuid4()}@example.com", status=AccountStatus.ACTIVE)
    invited = Account(name="Invited", email=f"invited-{uuid4()}@example.com", status=AccountStatus.PENDING)
    db_session_with_containers.add_all(
        [
            tenant,
            owner,
            invited,
            TenantAccountJoin(tenant_id=tenant.id, account_id=owner.id, role=TenantAccountRole.OWNER, current=True),
        ]
    )
    db_session_with_containers.commit()
    return tenant, owner, invited


@pytest.mark.parametrize("status", [AccountStatus.PENDING, AccountStatus.ACTIVE])
def test_invitation_token_round_trip_and_acceptance(
    workspace: tuple[Tenant, Account, Account],
    db_session_with_containers: Session,
    monkeypatch: pytest.MonkeyPatch,
    status: AccountStatus,
) -> None:
    tenant, owner, invited = workspace
    invited.status = status
    db_session_with_containers.commit()
    send = create_autospec(gateways.send_invite_member_mail_task.delay, instance=True)
    monkeypatch.setattr(gateways.send_invite_member_mail_task, "delay", send)
    services = application_services()

    invitation = services.workspaces.invitations.invite(
        RequestContext("request", None, owner.id, tenant.id), invited.email, "en-US", "admin"
    )
    token = invitation.token
    assert invitation.account_id == invited.id

    token_key = f"member_invite:token:{token}"
    payload = redis_client.get(token_key)
    assert payload is not None
    assert json.loads(payload) == {
        "account_id": invited.id,
        "email": invited.email,
        "workspace_id": tenant.id,
        "role": "admin",
        "requires_setup": status == AccountStatus.PENDING,
    }
    assert 0 < redis_client.ttl(token_key) <= dify_config.INVITE_EXPIRY_HOURS * 3600
    send.assert_called_once_with(
        language="en-US", to=invited.email, token=token, inviter_name=owner.name, workspace_name=tenant.name
    )
    assert services.workspaces.members.get_role(tenant.id, invited.id) == (
        TenantAccountRole.ADMIN if status == AccountStatus.PENDING else None
    )
    lookup = InvitationLookup(workspace_id=None, email=None, token=token)
    checked = services.accounts.activation.check(lookup)
    assert checked.is_valid
    assert checked.data is not None
    assert checked.data.email == invited.email
    assert checked.data.workspace_id == tenant.id
    assert checked.data.workspace_name == tenant.name
    assert checked.data.account_status == status
    assert checked.data.requires_setup is (status == AccountStatus.PENDING)

    services.accounts.activation.activate(
        ActivationCommand(invitation=lookup, name="Accepted", interface_language="en-US", timezone="UTC"),
        authenticated_account_id=invited.id,
    )

    db_session_with_containers.expire_all()
    assert invited.status == AccountStatus.ACTIVE
    assert services.workspaces.members.get_role(tenant.id, invited.id) == TenantAccountRole.ADMIN
    membership = db_session_with_containers.scalar(
        select(TenantAccountJoin).where(
            TenantAccountJoin.tenant_id == tenant.id, TenantAccountJoin.account_id == invited.id
        )
    )
    assert membership is not None
    assert membership.current
    assert redis_client.get(token_key) is None
    assert not services.accounts.activation.check(lookup).is_valid
    with pytest.raises(InvalidInvitationError):
        services.accounts.activation.activate(ActivationCommand(invitation=lookup), authenticated_account_id=invited.id)


@pytest.mark.parametrize("mixed_case", [False, True])
def test_previous_workspace_scoped_token_format_can_be_accepted_and_revoked(
    workspace: tuple[Tenant, Account, Account], mixed_case: bool
) -> None:
    tenant, _, invited = workspace
    token = str(uuid4())
    email_hash = sha256(invited.email.encode()).hexdigest()
    key = f"member_invite_token:{tenant.id}, {email_hash}:{token}"
    redis_client.setex(key, 3600, invited.id)
    lookup = InvitationLookup(
        workspace_id=tenant.id, email=invited.email.upper() if mixed_case else invited.email, token=token
    )
    services = application_services()

    checked = services.accounts.activation.check(lookup)
    assert checked.is_valid
    assert checked.data is not None
    assert checked.data.requires_setup
    assert checked.data.email == invited.email
    services.accounts.activation.activate(
        ActivationCommand(invitation=lookup, name="Accepted", interface_language="en-US", timezone="UTC"),
        authenticated_account_id=None,
    )

    assert redis_client.get(key) is None
    assert not services.accounts.activation.check(lookup).is_valid
    assert services.workspaces.members.get_role(tenant.id, invited.id) == TenantAccountRole.NORMAL


@pytest.mark.parametrize("reason", ["expired", "missing-account", "missing-workspace", "archived", "wrong-email"])
def test_invalid_invitation_state_is_rejected(
    workspace: tuple[Tenant, Account, Account], db_session_with_containers: Session, reason: str
) -> None:
    tenant, _, invited = workspace
    if reason == "archived":
        tenant.status = TenantStatus.ARCHIVE
        db_session_with_containers.commit()
    token = RedisInvitationTokenStore(redis=redis_client).create(
        InvitationToken(
            account_id=str(uuid4()) if reason == "missing-account" else invited.id,
            email="[email protected]" if reason == "wrong-email" else invited.email,
            workspace_id=str(uuid4()) if reason == "missing-workspace" else tenant.id,
        )
    )
    if reason == "expired":
        redis_client.pexpire(f"member_invite:token:{token}", 0)
    lookup = InvitationLookup(workspace_id=None, email=None, token=token)
    activation = application_services().accounts.activation

    assert not activation.check(lookup).is_valid
    with pytest.raises(InvalidInvitationError):
        activation.activate(ActivationCommand(invitation=lookup), authenticated_account_id=invited.id)