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.

19.4 KB
Raw Blame
from collections.abc import Callable
from datetime import datetime
from http import HTTPStatus
from importlib import import_module
from inspect import unwrap
from typing import NamedTuple, override
from unittest.mock import Mock, create_autospec

import pytest
from flask import Flask
from flask_restx import Api, Resource
from pydantic import ValidationError
from werkzeug.exceptions import Forbidden, NotFound

from controllers.console.auth.error import (
    CannotTransferOwnerToSelfError,
    EmailCodeError,
    InvalidEmailError,
    InvalidTokenError,
    NotOwnerError,
    OwnerTransferLimitError,
    OwnerTransferRateLimitExceededError,
)
from controllers.console.auth.error import (
    MemberNotInTenantError as MemberNotInTenantRequestError,
)
from controllers.console.error import EmailSendIpLimitError, SeatsLimitExceeded, WorkspaceMembersLimitExceeded
from controllers.console.workspace.members import (
    DatasetOperatorMemberListApi,
    MemberCancelInviteApi,
    MemberInviteEmailApi,
    MemberListApi,
    MemberUpdateRoleApi,
    OwnerTransfer,
    OwnerTransferCheckApi,
    SendOwnerTransferEmailApi,
)
from libs.external_api import register_external_error_handlers
from machinery.context import RequestContext
from services.account_errors import AccountNotFoundError
from services.errors.base import NoPermissionError
from services.errors.workspace import (
    CannotOperateSelfError,
    InvalidOwnerTransferCodeError,
    InvalidOwnerTransferEmailError,
    InvalidOwnerTransferTokenError,
    InvalidWorkspaceMemberRoleError,
    MemberNotInTenantError,
    OwnerTransferSendIPLimitedError,
    OwnerTransferSendRateLimitError,
    OwnerTransferVerificationLimitError,
    RoleAlreadyAssignedError,
    WorkspaceNotFoundError,
    WorkspaceNotLinkedError,
)
from services.workspace.contracts import WorkspaceMemberRecord, WorkspaceMemberRole, WorkspaceMemberSummary
from services.workspace.member_service import WorkspaceMemberQueryService, WorkspaceMemberService
from tests.helpers.unit.controllers.error_body import raised_error


class _RecordingWorkspaceMemberQueryService(WorkspaceMemberQueryService):
    def __init__(self, result: tuple[WorkspaceMemberSummary, ...]) -> None:
        self._result = result
        self.contexts: list[RequestContext] = []
        self.languages: list[str | None] = []

    @override
    def list_current(
        self, context: RequestContext, *, language: str | None = None
    ) -> tuple[WorkspaceMemberSummary, ...]:
        self.contexts.append(context)
        self.languages.append(language)
        return self._result


class _WorkspaceServicesStub(NamedTuple):
    member_queries: WorkspaceMemberQueryService


class _ApplicationServicesStub(NamedTuple):
    workspaces: _WorkspaceServicesStub


class TestMemberListApi:
    @pytest.mark.parametrize(("language", "expected"), [("", None), (" JA ", "ja"), ("unknown", None)])
    def test_get_passes_context_and_serializes_application_result(
        self, app: Flask, monkeypatch: pytest.MonkeyPatch, language: str, expected: str | None
    ) -> None:
        api = MemberListApi()
        method = unwrap(api.get)
        request_context = RequestContext(
            request_id="request-1",
            trace_id="trace-1",
            account_id="actor-1",
            active_workspace_id="workspace-1",
        )
        timestamp = datetime(2026, 1, 1)
        workspace_member_queries = _RecordingWorkspaceMemberQueryService(
            (
                WorkspaceMemberSummary(
                    id="member-1",
                    name="Member",
                    email="[email protected]",
                    avatar=None,
                    last_login_at=None,
                    last_active_at=timestamp,
                    created_at=timestamp,
                    role="owner",
                    roles=(
                        WorkspaceMemberRole(id="workspace.owner", name="Owner"),
                        WorkspaceMemberRole(id="workspace.editor", name="Editor"),
                    ),
                    status="active",
                ),
            )
        )
        application_services_stub = _ApplicationServicesStub(_WorkspaceServicesStub(workspace_member_queries))

        monkeypatch.setattr(
            import_module("controllers.console.workspace.members"),
            "application_services",
            lambda: application_services_stub,
        )
        with app.test_request_context("/", query_string={"language": language}):
            result, status = method(api, request_context=request_context)

        assert status == HTTPStatus.OK
        assert result == {
            "accounts": [
                {
                    "id": "member-1",
                    "name": "Member",
                    "email": "[email protected]",
                    "avatar": None,
                    "avatar_url": None,
                    "last_login_at": None,
                    "last_active_at": int(timestamp.timestamp()),
                    "created_at": int(timestamp.timestamp()),
                    "role": "owner",
                    "roles": [
                        {"id": "workspace.owner", "name": "Owner"},
                        {"id": "workspace.editor", "name": "Editor"},
                    ],
                    "status": "active",
                }
            ]
        }
        assert workspace_member_queries.contexts == [request_context]
        assert workspace_member_queries.languages == [expected]


@pytest.fixture
def services(monkeypatch: pytest.MonkeyPatch) -> Mock:
    from extensions.application_services.workspace import WorkspaceServices
    from extensions.ext_application_services import AccountServices, ApplicationServices
    from services.workspace.member_service import WorkspaceInvitationService, WorkspaceOwnerTransferService

    services = create_autospec(ApplicationServices, instance=True)
    services.accounts = create_autospec(AccountServices, instance=True)
    services.workspaces = create_autospec(WorkspaceServices, instance=True)
    services.workspaces.invitations = create_autospec(WorkspaceInvitationService, instance=True)
    services.workspaces.owner_transfer = create_autospec(WorkspaceOwnerTransferService, instance=True)
    services.workspaces.members = create_autospec(WorkspaceMemberService, instance=True)
    services.workspaces.member_queries = create_autospec(WorkspaceMemberQueryService, instance=True)
    import importlib

    monkeypatch.setattr(
        importlib.import_module("controllers.console.workspace.members"), "application_services", lambda: services
    )
    return services


@pytest.mark.parametrize("operation", ["remove", "update_role"])
def test_member_mutation_delegates_admitted_ids(app: Flask, services: Mock, operation: str) -> None:
    context = RequestContext("request", None, "actor", "workspace")
    with app.test_request_context("/", json={"role": "editor"}):
        if operation == "remove":
            api = MemberCancelInviteApi()
            response, status = unwrap(api.delete)(api, context, "member")
            assert status == 200
            assert response == {"result": "success", "tenant_id": "workspace"}
            services.workspaces.members.remove.assert_called_once_with("workspace", "member", "actor")
        else:
            api = MemberUpdateRoleApi()
            assert unwrap(api.put)(api, context, "member") == {"result": "success"}
            services.workspaces.members.update_role.assert_called_once_with("workspace", "member", "editor", "actor")


@pytest.mark.parametrize("operation", ["remove", "update_role"])
@pytest.mark.parametrize(
    ("error", "code", "status"),
    [
        (CannotOperateSelfError("self"), "cannot_operate_self", 400),
        (NoPermissionError("denied"), "forbidden", 403),
        (MemberNotInTenantError("missing"), "member_not_found", 404),
    ],
)
def test_member_mutation_maps_errors(
    app: Flask, services: Mock, operation: str, error: Exception, code: str, status: int
) -> None:
    service_method = (
        services.workspaces.members.remove if operation == "remove" else services.workspaces.members.update_role
    )
    service_method.side_effect = error
    api = MemberCancelInviteApi() if operation == "remove" else MemberUpdateRoleApi()
    method = api.delete if isinstance(api, MemberCancelInviteApi) else api.put
    with app.test_request_context("/", json={"role": "editor"}):
        result = raised_error(
            lambda: unwrap(method)(api, RequestContext("request", None, "actor", "workspace"), "member")
        )
    assert result == ({"code": code, "message": str(error)}, status)


@pytest.mark.parametrize("operation", ["remove", "update_role"])
def test_member_mutation_maps_missing_account(app: Flask, services: Mock, operation: str) -> None:
    service_method = (
        services.workspaces.members.remove if operation == "remove" else services.workspaces.members.update_role
    )
    service_method.side_effect = AccountNotFoundError()
    api = MemberCancelInviteApi() if operation == "remove" else MemberUpdateRoleApi()
    method = api.delete if isinstance(api, MemberCancelInviteApi) else api.put
    with app.test_request_context("/", json={"role": "editor"}), pytest.raises(NotFound):
        unwrap(method)(api, RequestContext("request", None, "actor", "workspace"), "missing")


@pytest.mark.parametrize(
    ("error", "code", "message"),
    [
        (InvalidWorkspaceMemberRoleError(), "invalid_role", "Invalid role."),
        (RoleAlreadyAssignedError("unchanged"), "role_already_assigned", "unchanged"),
    ],
)
def test_update_role_maps_role_errors(app: Flask, services: Mock, error: Exception, code: str, message: str) -> None:
    services.workspaces.members.update_role.side_effect = error
    api = MemberUpdateRoleApi()
    with app.test_request_context("/", json={"role": "editor"}):
        result = raised_error(
            lambda: unwrap(api.put)(api, RequestContext("request", None, "actor", "workspace"), "member")
        )
    assert result == ({"code": code, "message": message}, 400)


def test_dataset_operator_list_uses_admitted_workspace(app: Flask, services: Mock) -> None:
    services.workspaces.member_queries.list_members.return_value = ()
    api = DatasetOperatorMemberListApi()
    with app.test_request_context("/"):
        result = unwrap(api.get)(api, RequestContext("request", None, "actor", "workspace"))
    assert result == ({"accounts": []}, 200)
    services.workspaces.member_queries.list_members.assert_called_once_with("workspace", dataset_operators_only=True)


def test_dataset_operator_list_serializes_membership_snapshot(app: Flask, services: Mock) -> None:
    timestamp = datetime(2026, 1, 1)
    services.workspaces.member_queries.list_members.return_value = (
        WorkspaceMemberRecord(
            id="operator",
            name="Operator",
            email="[email protected]",
            avatar=None,
            last_login_at=None,
            last_active_at=timestamp,
            created_at=timestamp,
            status="active",
            legacy_role="dataset_operator",
        ),
    )
    api = DatasetOperatorMemberListApi()
    with app.test_request_context("/"):
        result, status = unwrap(api.get)(api, RequestContext("request", None, "actor", "workspace"))
    assert status == 200
    assert result["accounts"] == [
        {
            "id": "operator",
            "name": "Operator",
            "email": "[email protected]",
            "avatar": None,
            "avatar_url": None,
            "last_login_at": None,
            "last_active_at": int(timestamp.timestamp()),
            "created_at": int(timestamp.timestamp()),
            "role": "dataset_operator",
            "roles": [],
            "status": "active",
        }
    ]


def test_invitation_policy_denial_preserves_http_status(app: Flask, services: Mock) -> None:
    services.workspaces.invitations.invite_many.side_effect = NoPermissionError(
        "Workspace policy prohibits member invitations"
    )
    api = MemberInviteEmailApi()
    with (
        app.test_request_context("/", method="POST", json={"emails": ["[email protected]"], "role": "normal"}),
        pytest.raises(Forbidden, match="Workspace policy prohibits member invitations"),
    ):
        unwrap(api.post)(api, RequestContext("request", None, "owner", "workspace"))


def test_bulk_invite_serializes_results_and_normalizes_input(app: Flask, services: Mock) -> None:
    from services.workspace.contracts import WorkspaceInvitationResult

    services.workspaces.invitations.invite_many.return_value = (
        WorkspaceInvitationResult("[email protected]", "success", token="token"),
        WorkspaceInvitationResult("[email protected]", "already_member", message="Account already in workspace."),
        WorkspaceInvitationResult("[email protected]", "failed", message="Registration failed"),
    )
    context = RequestContext("request", None, "owner", "workspace")
    with app.test_request_context(
        "/",
        method="POST",
        json={"emails": ["[email protected]", "[email protected]", "[email protected]", "[email protected]"], "role": "normal"},
    ):
        api = MemberInviteEmailApi()
        result, status = unwrap(api.post)(api, context)
    assert status == 201
    assert result["tenant_id"] == "workspace"
    assert [item["status"] for item in result["invitation_results"]] == ["success", "already_member", "failed"]
    assert "email=a%40example.com&token=token" in result["invitation_results"][0]["url"]
    services.workspaces.invitations.invite_many.assert_called_once_with(
        context, emails=["[email protected]", "[email protected]", "[email protected]"], language=None, role="normal"
    )


@pytest.mark.parametrize(
    "invalid_email",
    ["", "invalid-email", "@example.com", "user@", "user@example", "[email protected]\n", "[email protected]\r\n"],
)
def test_bulk_invite_rejects_invalid_email_before_inviting(app: Flask, services: Mock, invalid_email: str) -> None:
    api = MemberInviteEmailApi()
    with (
        app.test_request_context(
            "/", method="POST", json={"emails": ["[email protected]", invalid_email], "role": "normal"}
        ),
        pytest.raises(ValidationError, match="not a valid email") as error,
    ):
        unwrap(api.post)(api, RequestContext("request", None, "owner", "workspace"))

    assert error.value.errors()[0]["loc"] == ("emails", 1)
    services.workspaces.invitations.invite_many.assert_not_called()


@pytest.mark.parametrize(("seats", "expected"), [(True, SeatsLimitExceeded), (False, WorkspaceMembersLimitExceeded)])
def test_invite_maps_capacity_error(app: Flask, services: Mock, seats: bool, expected: type[Exception]) -> None:
    from services.errors.workspace import WorkspaceInvitationQuotaError

    services.workspaces.invitations.invite_many.side_effect = WorkspaceInvitationQuotaError(seats=seats)
    api = MemberInviteEmailApi()
    with (
        app.test_request_context("/", method="POST", json={"emails": ["[email protected]"], "role": "normal"}),
        pytest.raises(expected),
    ):
        unwrap(api.post)(api, RequestContext("request", None, "owner", "workspace"))


@pytest.mark.parametrize(
    ("error", "expected"),
    [
        (NoPermissionError(), NotOwnerError),
        (AccountNotFoundError(), NotFound),
        (WorkspaceNotFoundError(), NotFound),
        (OwnerTransferSendIPLimitedError(), EmailSendIpLimitError),
        (OwnerTransferSendRateLimitError(3), OwnerTransferRateLimitExceededError),
        (OwnerTransferVerificationLimitError(), OwnerTransferLimitError),
        (InvalidOwnerTransferTokenError(), InvalidTokenError),
        (InvalidOwnerTransferEmailError(), InvalidEmailError),
        (InvalidOwnerTransferCodeError(), EmailCodeError),
        (CannotOperateSelfError(), CannotTransferOwnerToSelfError),
        (MemberNotInTenantError(), MemberNotInTenantRequestError),
    ],
)
def test_owner_verification_maps_errors(
    app: Flask, services: Mock, error: Exception, expected: type[Exception]
) -> None:
    services.workspaces.owner_transfer.verify_code.side_effect = error
    api = OwnerTransferCheckApi()
    with (
        app.test_request_context("/", method="POST", json={"token": "token", "code": "123456"}),
        pytest.raises(expected) as raised,
    ):
        unwrap(api.post)(api, RequestContext("request", None, "owner", "workspace"))
    assert raised.value.__cause__ is error
    if isinstance(error, OwnerTransferSendRateLimitError):
        assert "3" in str(raised.value)


def test_owner_verification_serializes_promoted_token(app: Flask, services: Mock) -> None:
    services.workspaces.owner_transfer.verify_code.return_value = ("[email protected]", "promoted")
    with app.test_request_context("/", method="POST", json={"token": "token", "code": "123456"}):
        api = OwnerTransferCheckApi()
        response = unwrap(api.post)(api, RequestContext("request", None, "owner", "workspace"))
    assert response == {"is_valid": True, "email": "[email protected]", "token": "promoted"}


@pytest.mark.parametrize(
    ("service_method", "resource_type", "handler", "has_member_id"),
    [
        pytest.param(
            lambda services: services.workspaces.members.remove,
            MemberCancelInviteApi,
            MemberCancelInviteApi.delete,
            True,
            id="remove",
        ),
        pytest.param(
            lambda services: services.workspaces.members.update_role,
            MemberUpdateRoleApi,
            MemberUpdateRoleApi.put,
            True,
            id="update_role",
        ),
        pytest.param(
            lambda services: services.workspaces.owner_transfer.send_code,
            SendOwnerTransferEmailApi,
            SendOwnerTransferEmailApi.post,
            False,
            id="send_code",
        ),
        pytest.param(
            lambda services: services.workspaces.owner_transfer.verify_code,
            OwnerTransferCheckApi,
            OwnerTransferCheckApi.post,
            False,
            id="verify_code",
        ),
        pytest.param(
            lambda services: services.workspaces.owner_transfer.transfer,
            OwnerTransfer,
            OwnerTransfer.post,
            True,
            id="transfer",
        ),
    ],
)
@pytest.mark.parametrize(
    ("error", "status", "code"),
    [
        (RuntimeError("backend unavailable"), 500, "unknown"),
        (WorkspaceNotLinkedError("unmapped workspace failure"), 500, "unknown"),
        (WorkspaceNotFoundError(), 404, "not_found"),
        (AccountNotFoundError(), 404, "not_found"),
    ],
)
def test_member_errors_reach_the_http_boundary(
    services: Mock,
    service_method: Callable[[Mock], Mock],
    resource_type: type[Resource],
    handler: Callable[..., object],
    has_member_id: bool,
    error: Exception,
    status: int,
    code: str,
) -> None:
    service_method(services).side_effect = error
    resource = resource_type()
    method = unwrap(handler)
    context = RequestContext("request", None, "owner", "workspace")
    http_app = Flask(__name__)
    http_api = Api(http_app, doc=False)
    register_external_error_handlers(http_api)

    class Endpoint(Resource):
        def post(self) -> object:
            if has_member_id:
                return method(resource, context, "member")
            return method(resource, context)

    http_api.add_resource(Endpoint, "/members")
    response = http_app.test_client().post("/members", json={"role": "editor", "token": "token", "code": "123456"})
    assert response.status_code == status
    payload = response.get_json()
    assert isinstance(payload, dict)
    assert payload["code"] == code
    if status == 500:
        assert payload["message"] == "Internal Server Error"