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.

6.2 KB
Raw Blame
"""Workspace orchestration without Flask or ORM dependencies."""

from dataclasses import replace
from datetime import datetime
from unittest.mock import Mock, create_autospec

import pytest

from enums import CloudPlan
from machinery.context import RequestContext
from services.errors.file import UnsupportedFileTypeError
from services.errors.workspace import WorkspaceArchivedError, WorkspaceNotFoundError
from services.workspace.contracts import (
    EffectiveCreditPool,
    WorkspaceCustomConfig,
    WorkspaceCustomConfigChanges,
    WorkspaceFeatures,
    WorkspaceSnapshot,
)
from services.workspace.service import (
    WorkspaceFeatureGateway,
    WorkspaceLogoGateway,
    WorkspaceService,
    WorkspaceStore,
)

CONTEXT = RequestContext("request", None, "account", "workspace")
WORKSPACE = WorkspaceSnapshot(
    "workspace", "Test", "normal", datetime(2026, 1, 1), "editor", WorkspaceCustomConfig(True, "stored-logo"), True
)


@pytest.fixture
def dependencies() -> tuple[WorkspaceService, Mock, Mock, Mock]:
    store = create_autospec(WorkspaceStore, instance=True)
    features = create_autospec(WorkspaceFeatureGateway, instance=True)
    logos = create_autospec(WorkspaceLogoGateway, instance=True)
    store.get_for_account.return_value = WORKSPACE
    features.logo_url.return_value = "https://files/workspaces/workspace/webapp-logo"
    features.get_features.return_value = WorkspaceFeatures(True, EffectiveCreditPool())
    return (WorkspaceService(workspaces=store, features=features, logos=logos), store, features, logos)


@pytest.mark.parametrize(
    ("plan", "limit", "used", "remaining"),
    [
        (CloudPlan.SANDBOX, 100, 30, 70),
        (CloudPlan.TEAM, -1, 999, -1),
        (CloudPlan.TEAM, 10, 20, 0),
        (None, None, None, None),
    ],
)
def test_summary_uses_context_identity_and_credit_snapshot(
    dependencies: tuple[WorkspaceService, Mock, Mock, Mock],
    plan: CloudPlan | None,
    limit: int | None,
    used: int | None,
    remaining: int | None,
) -> None:
    service, store, features, _ = dependencies
    features.get_effective_credit_pool.return_value = EffectiveCreditPool(plan=plan, quota_limit=limit, quota_used=used)
    assert service.current_summary(CONTEXT) == {
        "id": "workspace",
        "name": "Test",
        "role": "editor",
        "plan": plan,
        "credits": remaining,
    }
    store.get_for_account.assert_called_once_with("workspace", "account")


def test_archived_workspace_does_not_read_billing(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
    service, store, features, _ = dependencies
    store.get_for_account.return_value = replace(WORKSPACE, status="archive")
    with pytest.raises(WorkspaceArchivedError):
        service.current_summary(CONTEXT)
    features.get_effective_credit_pool.assert_not_called()


def test_missing_workspace(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
    service, store, _, _ = dependencies
    store.get_for_account.return_value = None
    with pytest.raises(WorkspaceNotFoundError):
        service.custom_config(CONTEXT)


@pytest.mark.parametrize(
    ("changes", "expected"),
    [
        (WorkspaceCustomConfigChanges(None, None), WorkspaceCustomConfig(True, "stored-logo")),
        (WorkspaceCustomConfigChanges(False, None), WorkspaceCustomConfig(False, "stored-logo")),
        (WorkspaceCustomConfigChanges(None, ""), WorkspaceCustomConfig(True, "")),
        (WorkspaceCustomConfigChanges(None, "new-logo"), WorkspaceCustomConfig(True, "new-logo")),
    ],
)
def test_config_patch_preserves_omitted_fields_and_honors_false_and_empty(
    dependencies: tuple[WorkspaceService, Mock, Mock, Mock],
    changes: WorkspaceCustomConfigChanges,
    expected: WorkspaceCustomConfig,
) -> None:
    service, store, _, _ = dependencies
    store.update_custom_config.return_value = replace(WORKSPACE, custom_config=expected)
    service.update_custom_config(CONTEXT, changes)
    store.update_custom_config.assert_called_once_with(workspace_id="workspace", account_id="account", changes=expected)


@pytest.mark.parametrize(
    ("can_replace", "has_manager", "includes_config"), [(True, True, True), (True, False, False), (False, True, False)]
)
def test_tenant_info_preserves_workspace_brand_visibility(
    dependencies: tuple[WorkspaceService, Mock, Mock, Mock], can_replace: bool, has_manager: bool, includes_config: bool
) -> None:
    service, store, features, _ = dependencies
    store.rename.return_value = replace(WORKSPACE, has_privileged_member=has_manager)
    features.get_features.return_value = WorkspaceFeatures(can_replace, EffectiveCreditPool())
    result = service.rename(CONTEXT, "New")
    assert ("custom_config" in result) is includes_config
    assert result["plan"] is None
    assert "trial_credits" not in result


def test_switch_serializes_effective_exhausted_pool(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
    service, store, features, _ = dependencies
    store.switch.return_value = WORKSPACE
    features.get_features.return_value = WorkspaceFeatures(
        True, EffectiveCreditPool(CloudPlan.TEAM, "trial", 100, 100, 1770000000, 1780000000)
    )
    result = service.switch(CONTEXT, "target")
    assert result["trial_credits"] == 100
    assert result["trial_credits_used"] == 100
    assert result["trial_credits_exhausted_at"] == 1770000000
    assert result["next_credit_reset_date"] == 1780000000
    store.switch.assert_called_once_with(account_id="account", workspace_id="target")


@pytest.mark.parametrize("filename", ["logo.jpg", "file.txt", "logo"])
def test_invalid_logo_never_reaches_storage(
    dependencies: tuple[WorkspaceService, Mock, Mock, Mock], filename: str
) -> None:
    service, _, _, logos = dependencies
    with pytest.raises(UnsupportedFileTypeError):
        service.upload_logo(CONTEXT, filename=filename, content=b"data", mimetype="image/jpeg")
    logos.upload.assert_not_called()


def test_logo_delegation(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
    service, _, _, logos = dependencies
    logos.upload.return_value = "file-id"
    assert service.upload_logo(CONTEXT, filename="logo.SVG", content=b"<svg/>", mimetype="image/svg+xml") == "file-id"
    logos.upload.assert_called_once_with(CONTEXT, filename="logo.SVG", content=b"<svg/>", mimetype="image/svg+xml")