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
import io
from datetime import datetime
from inspect import unwrap
from typing import Any
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden
from controllers.console.workspace.plugin import (
ParserAsset,
ParserAutoUpgradeChange,
ParserAutoUpgradeFetch,
ParserExcludePlugin,
ParserGithubInstall,
ParserGithubUpgrade,
ParserGithubUpload,
ParserIcon,
ParserLatest,
ParserList,
ParserMarketplaceUpgrade,
ParserPermissionChange,
ParserPluginIdentifierQuery,
ParserPluginIdentifiers,
ParserReadme,
ParserTasks,
ParserUninstall,
PluginAssetApi,
PluginAutoUpgradeExcludePluginApi,
PluginCategoryListApi,
PluginChangeAutoUpgradeApi,
PluginChangePermissionApi,
PluginDebuggingKeyApi,
PluginDeleteAllInstallTaskItemsApi,
PluginDeleteInstallTaskApi,
PluginDeleteInstallTaskItemApi,
PluginFetchAutoUpgradeApi,
PluginFetchInstallTaskApi,
PluginFetchInstallTasksApi,
PluginFetchManifestApi,
PluginFetchMarketplacePkgApi,
PluginFetchPermissionApi,
PluginIconApi,
PluginInstalledIdsApi,
PluginInstalledIdsQuery,
PluginInstallFromGithubApi,
PluginInstallFromMarketplaceApi,
PluginInstallFromPkgApi,
PluginListApi,
PluginListInstallationsFromIdsApi,
PluginListLatestVersionsApi,
PluginReadmeApi,
PluginUninstallApi,
PluginUpgradeFromGithubApi,
PluginUpgradeFromMarketplaceApi,
PluginUploadFromBundleApi,
PluginUploadFromGithubApi,
PluginUploadFromPkgApi,
_list_hardcoded_builtin_tool_providers,
)
from core.plugin.entities.plugin import PluginCategory, PluginDeclaration, PluginEntity, PluginInstallation
from core.plugin.entities.plugin_daemon import PluginInstallTask
from core.plugin.impl.exc import PluginDaemonClientSideError
from core.plugin.plugin_service import PluginService
from core.tools.entities.api_entities import ToolProviderApiEntity
from core.tools.entities.common_entities import I18nObject
from core.tools.entities.tool_entities import ToolProviderType
from models.account import (
Account,
TenantAccountRole,
TenantPluginAutoUpgradeCategory,
TenantPluginAutoUpgradeMode,
TenantPluginAutoUpgradeStrategy,
TenantPluginAutoUpgradeStrategySetting,
TenantPluginDebugPermission,
TenantPluginInstallPermission,
)
from tests.helpers.unit.config_override import config_overrides_context
from tests.helpers.unit.controllers.error_body import raised_error
from tests.helpers.unit.model_factories import make_account
def _plugin_category_list_item(category: str = "tool") -> dict[str, Any]:
now = datetime(2023, 1, 1, 0, 0, 0)
return {
"id": "entity-1",
"created_at": now,
"updated_at": now,
"tenant_id": "t1",
"endpoints_setups": 0,
"endpoints_active": 0,
"runtime_type": "remote",
"source": "marketplace",
"meta": {},
"plugin_id": "test-author/test-plugin",
"plugin_unique_identifier": "test-author/test-plugin:1.0.0@checksum",
"version": "1.0.0",
"checksum": "checksum",
"name": "test-plugin",
"installation_id": "entity-1",
"declaration": {
"version": "1.0.0",
"author": "test-author",
"name": "test-plugin",
"description": {"en_US": "Test plugin"},
"icon": "icon.svg",
"label": {"en_US": "Test Plugin"},
"category": category,
"created_at": now,
"resource": {"memory": 268435456, "permission": None},
"plugins": {"tools": ["provider/test.yaml"]},
"meta": {"version": "1.0.0"},
"tool": {
"identity": {
"author": "test-author",
"name": "test-plugin",
"description": {"en_US": "Test plugin"},
"icon": "icon.svg",
"label": {"en_US": "Test Plugin"},
}
},
},
}
def _builtin_tool_provider_item() -> dict[str, Any]:
return {
"id": "builtin",
"author": "dify",
"name": "builtin",
"plugin_id": "",
"plugin_unique_identifier": "",
"description": {"en_US": "Builtin tool provider"},
"icon": "icon.svg",
"icon_dark": "",
"label": {"en_US": "Builtin"},
"type": "builtin",
"team_credentials": {},
"is_team_authorization": False,
"allow_delete": True,
"tools": [],
"labels": [],
}
def _plugin_declaration_payload() -> dict[str, Any]:
return {
"version": "1.2.3",
"author": "langgenius",
"name": "demo_plugin",
"description": {"en_US": "Demo plugin"},
"icon": "icon.svg",
"icon_dark": None,
"label": {"en_US": "Demo Plugin"},
"created_at": "2024-01-02T03:04:05",
"resource": {"memory": 268435456, "permission": None},
"plugins": {"tools": ["provider/demo.yaml"]},
"tags": ["search", "demo"],
"repo": "https://github.com/langgenius/demo",
"verified": True,
"meta": {"minimum_dify_version": "0.15.0", "version": "1.2.3"},
}
def _expected_i18n(en_us: str) -> dict[str, str]:
return {"en_US": en_us, "zh_Hans": en_us, "pt_BR": en_us, "ja_JP": en_us}
def _expected_plugin_declaration_dump() -> dict[str, Any]:
return {
"version": "1.2.3",
"author": "langgenius",
"name": "demo_plugin",
"description": _expected_i18n("Demo plugin"),
"icon": "icon.svg",
"icon_dark": None,
"label": _expected_i18n("Demo Plugin"),
"category": "extension",
"created_at": "2024-01-02T03:04:05",
"resource": {"memory": 268435456, "permission": None},
"plugins": {
"tools": ["provider/demo.yaml"],
"models": [],
"endpoints": [],
"datasources": [],
"triggers": [],
},
"tags": ["search", "demo"],
"repo": "https://github.com/langgenius/demo",
"verified": True,
"tool": None,
"model": None,
"endpoint": None,
"agent_strategy": None,
"datasource": None,
"trigger": None,
"meta": {"minimum_dify_version": "0.15.0", "version": "1.2.3"},
}
def _plugin_installation_payload() -> dict[str, Any]:
return {
"id": "installation-row-1",
"created_at": "2024-01-02T03:04:05",
"updated_at": "2024-01-03T04:05:06",
"tenant_id": "tenant-1",
"endpoints_setups": 2,
"endpoints_active": 1,
"runtime_type": "remote",
"source": "marketplace",
"meta": {"from": "marketplace"},
"plugin_id": "langgenius/demo_plugin",
"plugin_unique_identifier": "langgenius/demo_plugin:1.2.3@sha256:abc",
"version": "1.2.3",
"checksum": "sha256:abc",
"declaration": _plugin_declaration_payload(),
}
def _plugin_entity_payload() -> dict[str, Any]:
return {
**_plugin_installation_payload(),
"name": "demo_plugin",
"installation_id": "installation-row-1",
}
def _plugin_declaration() -> PluginDeclaration:
return PluginDeclaration.model_validate(_plugin_declaration_payload())
def _plugin_installation() -> PluginInstallation:
return PluginInstallation.model_validate(_plugin_installation_payload())
def _plugin_entity() -> PluginEntity:
return PluginEntity.model_validate(_plugin_entity_payload())
def _expected_plugin_installation_dump() -> dict[str, Any]:
return {
"id": "installation-row-1",
"created_at": "2024-01-02T03:04:05",
"updated_at": "2024-01-03T04:05:06",
"tenant_id": "tenant-1",
"endpoints_setups": 2,
"endpoints_active": 1,
"runtime_type": "remote",
"source": "marketplace",
"meta": {"from": "marketplace"},
"plugin_id": "langgenius/demo_plugin",
"plugin_unique_identifier": "langgenius/demo_plugin:1.2.3@sha256:abc",
"version": "1.2.3",
"checksum": "sha256:abc",
"declaration": _expected_plugin_declaration_dump(),
}
def _expected_plugin_entity_dump() -> dict[str, Any]:
return {
**_expected_plugin_installation_dump(),
"name": "demo_plugin",
"installation_id": "installation-row-1",
}
def _plugin_task_payload() -> dict[str, Any]:
return {
"id": "task-1",
"created_at": "2024-02-03T04:05:06",
"updated_at": "2024-02-03T04:06:07",
"status": "running",
"total_plugins": 2,
"completed_plugins": 1,
"plugins": [
{
"plugin_unique_identifier": "langgenius/demo_plugin:1.2.3@sha256:abc",
"plugin_id": "langgenius/demo_plugin",
"status": "success",
"message": "installed",
"icon": "icon.svg",
"labels": {"en_US": "Demo Plugin"},
"source": "marketplace",
}
],
}
def _plugin_task() -> PluginInstallTask:
return PluginInstallTask.model_validate(_plugin_task_payload())
def _expected_plugin_task_dump() -> dict[str, Any]:
return {
"id": "task-1",
"created_at": "2024-02-03T04:05:06",
"updated_at": "2024-02-03T04:06:07",
"status": "running",
"total_plugins": 2,
"completed_plugins": 1,
"plugins": [
{
"plugin_unique_identifier": "langgenius/demo_plugin:1.2.3@sha256:abc",
"plugin_id": "langgenius/demo_plugin",
"status": "success",
"message": "installed",
"icon": "icon.svg",
"labels": _expected_i18n("Demo Plugin"),
"source": "marketplace",
}
],
}
def _latest_plugin_cache() -> PluginService.LatestPluginCache:
return PluginService.LatestPluginCache(
plugin_id="langgenius/demo_plugin",
version="1.3.0",
unique_identifier="langgenius/demo_plugin:1.3.0@sha256:def",
status="active",
deprecated_reason="",
alternative_plugin_id="",
)
def _expected_latest_plugin_cache_dump() -> dict[str, str]:
return {
"plugin_id": "langgenius/demo_plugin",
"version": "1.3.0",
"unique_identifier": "langgenius/demo_plugin:1.3.0@sha256:def",
"status": "active",
"deprecated_reason": "",
"alternative_plugin_id": "",
}
def _account(role: TenantAccountRole = TenantAccountRole.OWNER) -> Account:
return make_account(account_id="u1", name="Test User", email="[email protected]", role=role)
@pytest.fixture
def user():
return _account()
@pytest.fixture
def tenant():
return "t1"
class TestPluginListLatestVersionsApi:
def test_success(self, app: Flask):
api = PluginListLatestVersionsApi()
method = unwrap(api.post)
payload = {"plugin_ids": ["langgenius/demo_plugin", "langgenius/missing_plugin"]}
versions = {
"langgenius/demo_plugin": _latest_plugin_cache(),
"langgenius/missing_plugin": None,
}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginService.list_latest_versions", return_value=versions),
):
result = method(api, ParserLatest.model_validate(payload))
assert result == {
"versions": {
"langgenius/demo_plugin": _expected_latest_plugin_cache_dump(),
"langgenius/missing_plugin": None,
}
}
def test_daemon_error(self, app: Flask):
api = PluginListLatestVersionsApi()
method = unwrap(api.post)
payload = {"plugin_ids": ["p1"]}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.list_latest_versions",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserLatest.model_validate(payload)))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginDebuggingKeyApi:
def test_debugging_key_success(self, app: Flask):
api = PluginDebuggingKeyApi()
method = unwrap(api.get)
with (
app.test_request_context("/"),
patch("controllers.console.workspace.plugin.PluginService.get_debugging_key", return_value="k"),
):
result = method(api, "t1")
assert result["key"] == "k"
def test_debugging_key_error(self, app: Flask):
api = PluginDebuggingKeyApi()
method = unwrap(api.get)
with (
app.test_request_context("/"),
patch(
"controllers.console.workspace.plugin.PluginService.get_debugging_key",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginListApi:
def test_plugin_list(self, app: Flask):
api = PluginListApi()
method = unwrap(api.get)
plugins_with_total = MagicMock(list=[_plugin_entity()], total=1)
with (
app.test_request_context("/?page=1&page_size=10"),
patch(
"controllers.console.workspace.plugin.PluginService.list_with_total",
return_value=plugins_with_total,
) as mock_list_with_total,
):
result = method(api, ParserList(page=1, page_size=10), "t1", "u1")
assert result == {"plugins": [_expected_plugin_entity_dump()], "total": 1}
mock_list_with_total.assert_called_once_with("t1", "u1", 1, 10)
class TestPluginCategoryListApi:
def test_plugin_category_list(self, app: Flask):
api = PluginCategoryListApi()
method = unwrap(api.get)
plugin_item = _plugin_category_list_item()
builtin_item = _builtin_tool_provider_item()
mock_list = MagicMock(list=[plugin_item], has_more=True)
with (
app.test_request_context("/?page=2&page_size=10&query=weather&tags=search&tags=rag&language=zh_Hans"),
patch(
"controllers.console.workspace.plugin.PluginService.list_by_category", return_value=mock_list
) as list_mock,
patch(
"controllers.console.workspace.plugin._list_hardcoded_builtin_tool_providers",
return_value=[builtin_item],
) as builtin_mock,
):
result = method(api, "t1", "tool")
list_mock.assert_called_once_with(
"t1",
"tool",
2,
10,
query="weather",
tags=["search", "rag"],
language="zh_Hans",
)
assert result["plugins"][0]["id"] == "entity-1"
assert result["plugins"][0]["plugin_unique_identifier"] == "test-author/test-plugin:1.0.0@checksum"
assert result["builtin_tools"][0]["id"] == "builtin"
assert result["builtin_tools"][0]["type"] == "builtin"
assert result["has_more"] is True
assert "total" not in result
builtin_mock.assert_called_once_with(
"t1",
query="weather",
tags=["search", "rag"],
language="zh_Hans",
)
def test_builtin_tool_providers_use_the_category_list_filters(self):
search_provider = ToolProviderApiEntity(
id="search-provider",
author="dify",
name="search-provider",
description=I18nObject(en_US="Search provider", zh_Hans="搜索工具"),
icon="icon.svg",
label=I18nObject(en_US="Search", zh_Hans="搜索"),
type=ToolProviderType.BUILT_IN,
labels=["search"],
)
rag_provider = ToolProviderApiEntity(
id="rag-provider",
author="dify",
name="rag-provider",
description=I18nObject(en_US="RAG provider", zh_Hans="知识库工具"),
icon="icon.svg",
label=I18nObject(en_US="RAG", zh_Hans="知识库"),
type=ToolProviderType.BUILT_IN,
labels=["rag"],
)
with (
patch("controllers.console.workspace.plugin.ToolManager.list_default_builtin_providers", return_value=[]),
patch(
"controllers.console.workspace.plugin.ToolManager.list_hardcoded_providers",
return_value=[MagicMock(), MagicMock()],
),
patch("controllers.console.workspace.plugin.is_filtered", return_value=False),
patch(
"controllers.console.workspace.plugin.ToolTransformService.builtin_provider_to_user_provider",
side_effect=[search_provider, rag_provider],
),
patch("controllers.console.workspace.plugin.ToolTransformService.repack_provider"),
patch(
"controllers.console.workspace.plugin.BuiltinToolProviderSort.sort",
side_effect=lambda providers: providers,
),
):
result = _list_hardcoded_builtin_tool_providers(
"t1",
query="搜索",
tags=["search", "weather"],
language="zh_Hans",
)
assert [provider["id"] for provider in result] == ["search-provider"]
def test_non_tool_category_does_not_include_builtin_tools(self, app: Flask):
api = PluginCategoryListApi()
method = unwrap(api.get)
mock_list = MagicMock(list=[_plugin_category_list_item(category="datasource")], has_more=False)
with (
app.test_request_context("/?page=1&page_size=10"),
patch("controllers.console.workspace.plugin.PluginService.list_by_category", return_value=mock_list),
patch("controllers.console.workspace.plugin._list_hardcoded_builtin_tool_providers") as builtin_mock,
):
result = method(api, "t1", "datasource")
assert result["plugins"][0]["id"] == "entity-1"
assert result["builtin_tools"] == []
assert result["has_more"] is False
builtin_mock.assert_not_called()
def test_invalid_category(self, app: Flask):
api = PluginCategoryListApi()
method = unwrap(api.get)
with (
app.test_request_context("/?page=1&page_size=10"),
):
result = raised_error(lambda: method(api, "t1", "unknown"))
assert result == ({"code": "invalid_param", "message": "invalid plugin category"}, 400)
def test_daemon_error(self, app: Flask):
api = PluginCategoryListApi()
method = unwrap(api.get)
with (
app.test_request_context("/?page=1&page_size=10"),
patch(
"controllers.console.workspace.plugin.PluginService.list_by_category",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, "t1", "tool"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginIconApi:
def test_plugin_icon(self, app: Flask):
api = PluginIconApi()
method = unwrap(api.get)
with (
app.test_request_context("/?tenant_id=t1&filename=a.png"),
patch("controllers.console.workspace.plugin.PluginService.get_asset", return_value=(b"x", "image/png")),
):
response = method(api, ParserIcon.model_validate({"tenant_id": "t1", "filename": "a.png"}))
assert response.mimetype == "image/png"
class TestPluginAssetApi:
def test_plugin_asset(self, app: Flask):
api = PluginAssetApi()
method = unwrap(api.get)
with (
app.test_request_context("/?plugin_unique_identifier=p&file_name=a.bin"),
patch("controllers.console.workspace.plugin.PluginService.extract_asset", return_value=b"x"),
):
response = method(
api, ParserAsset.model_validate({"plugin_unique_identifier": "p", "file_name": "a.bin"}), "t1"
)
assert response.mimetype == "application/octet-stream"
class TestPluginUploadFromPkgApi:
def test_upload_pkg_success(self, app: Flask):
api = PluginUploadFromPkgApi()
method = unwrap(api.post)
data = {
"pkg": (io.BytesIO(b"x"), "test.pkg"),
}
with (
app.test_request_context("/", data=data, content_type="multipart/form-data"),
patch("controllers.console.workspace.plugin.PluginService.upload_pkg", return_value={"ok": True}),
):
result = method(api, "t1")
assert result["ok"] is True
def test_upload_pkg_too_large(self, app: Flask):
api = PluginUploadFromPkgApi()
method = unwrap(api.post)
data = {
"pkg": (io.BytesIO(b"x"), "test.pkg"),
}
with (
app.test_request_context("/", data=data, content_type="multipart/form-data"),
config_overrides_context(PLUGIN_MAX_PACKAGE_SIZE=0),
patch("controllers.console.workspace.plugin.PluginService.upload_pkg") as upload_pkg_mock,
):
with pytest.raises(ValueError, match="File size exceeds the maximum allowed size") as exc_info:
method(api, "t1")
assert "File size exceeds the maximum allowed size" in str(exc_info.value)
upload_pkg_mock.assert_not_called()
class TestPluginInstallFromPkgApi:
def test_install_from_pkg(self, app: Flask):
api = PluginInstallFromPkgApi()
method = unwrap(api.post)
payload = {"plugin_unique_identifiers": ["p1"]}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.install_from_local_pkg", return_value={"ok": True}
),
):
result = method(api, ParserPluginIdentifiers.model_validate(payload), "t1")
assert result["ok"] is True
class TestPluginUninstallApi:
@pytest.mark.parametrize("preserve_credentials", [False, True])
def test_uninstall(self, app: Flask, preserve_credentials: bool):
api = PluginUninstallApi()
method = unwrap(api.post)
payload = {
"plugin_installation_id": "x",
"preserve_credentials": preserve_credentials,
}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginService.uninstall", return_value=True) as uninstall_mock,
):
result = method(api, ParserUninstall.model_validate(payload), "t1")
assert result["success"] is True
uninstall_mock.assert_called_once_with(
"t1",
"x",
preserve_credentials=preserve_credentials,
)
class TestPluginChangePermissionApi:
def test_change_permission_forbidden(self, app: Flask):
api = PluginChangePermissionApi()
method = unwrap(api.post)
user = _account(TenantAccountRole.NORMAL)
payload = {
"install_permission": TenantPluginInstallPermission.EVERYONE,
"debug_permission": TenantPluginDebugPermission.EVERYONE,
}
with (
app.test_request_context("/", json=payload),
):
with pytest.raises(Forbidden):
method(api, ParserPermissionChange(), "t1", user)
def test_change_permission_success(self, app: Flask):
api = PluginChangePermissionApi()
method = unwrap(api.post)
user = _account()
payload = {
"install_permission": TenantPluginInstallPermission.EVERYONE,
"debug_permission": TenantPluginDebugPermission.EVERYONE,
}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginPermissionService.change_permission", return_value=True),
):
result = method(api, ParserPermissionChange(), "t1", user)
assert result["success"] is True
class TestPluginFetchPermissionApi:
def test_fetch_permission_default(self, app: Flask):
api = PluginFetchPermissionApi()
method = unwrap(api.get)
with (
app.test_request_context("/"),
patch("controllers.console.workspace.plugin.PluginPermissionService.get_permission", return_value=None),
):
result = method(api, "t1")
assert result["install_permission"] == TenantPluginInstallPermission.ADMINS
assert result["debug_permission"] == TenantPluginDebugPermission.EVERYONE
class TestPluginReadmeApi:
def test_fetch_readme(self, app: Flask):
api = PluginReadmeApi()
method = unwrap(api.get)
with (
app.test_request_context("/?plugin_unique_identifier=p"),
patch("controllers.console.workspace.plugin.PluginService.fetch_plugin_readme", return_value="readme"),
):
result = method(api, ParserReadme.model_validate({"plugin_unique_identifier": "p"}), "t1")
assert result["readme"] == "readme"
class TestPluginListInstallationsFromIdsApi:
def test_success(self, app: Flask, user):
api = PluginListInstallationsFromIdsApi()
method = unwrap(api.post)
payload = {"plugin_ids": ["langgenius/demo_plugin"]}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.list_installations_from_ids",
return_value=[_plugin_installation()],
),
):
result = method(api, ParserLatest.model_validate(payload), "t1")
assert result == {"plugins": [_expected_plugin_installation_dump()]}
def test_daemon_error(self, app: Flask):
api = PluginListInstallationsFromIdsApi()
method = unwrap(api.post)
payload = {"plugin_ids": ["p1"]}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.list_installations_from_ids",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserLatest.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginInstalledIdsApi:
def test_success(self, app: Flask):
api = PluginInstalledIdsApi()
method = unwrap(api.get)
with (
app.test_request_context("/?category=tool"),
patch(
"controllers.console.workspace.plugin.PluginService.list_installed_plugin_ids",
return_value=["langgenius/openai", "langgenius/anthropic"],
) as list_installed_plugin_ids,
):
result = method(api, PluginInstalledIdsQuery.model_validate({"category": "tool"}), "t1")
assert result == {"plugin_ids": ["langgenius/openai", "langgenius/anthropic"]}
list_installed_plugin_ids.assert_called_once_with("t1", PluginCategory.Tool)
def test_daemon_error(self, app: Flask):
api = PluginInstalledIdsApi()
method = unwrap(api.get)
with (
app.test_request_context("/?category=tool"),
patch(
"controllers.console.workspace.plugin.PluginService.list_installed_plugin_ids",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(
lambda: method(api, PluginInstalledIdsQuery.model_validate({"category": "tool"}), "t1")
)
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginUploadFromGithubApi:
def test_success(self, app: Flask, user):
api = PluginUploadFromGithubApi()
method = unwrap(api.post)
payload = {"repo": "r", "version": "v", "package": "p"}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upload_pkg_from_github", return_value={"ok": True}
),
):
result = method(api, ParserGithubUpload.model_validate(payload), "t1")
assert result["ok"] is True
def test_daemon_error(self, app: Flask):
api = PluginUploadFromGithubApi()
method = unwrap(api.post)
payload = {"repo": "r", "version": "v", "package": "p"}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upload_pkg_from_github",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserGithubUpload.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
def test_download_error_reports_status(self, app: Flask):
api = PluginUploadFromGithubApi()
method = unwrap(api.post)
payload = {"repo": "r", "version": "v", "package": "p"}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upload_pkg_from_github",
side_effect=PluginDaemonClientSideError("Failed to download file: HTTP 403"),
),
):
result = raised_error(lambda: method(api, ParserGithubUpload.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "Failed to download file: HTTP 403"}, 400)
class TestPluginUploadFromBundleApi:
def test_success(self, app: Flask):
api = PluginUploadFromBundleApi()
method = unwrap(api.post)
file = FileStorage(
stream=io.BytesIO(b"x"),
filename="test.bundle",
content_type="application/octet-stream",
)
with (
app.test_request_context(
"/",
data={"bundle": file},
content_type="multipart/form-data",
),
patch("controllers.console.workspace.plugin.PluginService.upload_bundle", return_value={"ok": True}),
):
result = method(api, "t1")
assert result["ok"] is True
def test_too_large(self, app: Flask):
api = PluginUploadFromBundleApi()
method = unwrap(api.post)
file = FileStorage(
stream=io.BytesIO(b"x"),
filename="test.bundle",
content_type="application/octet-stream",
)
with (
app.test_request_context(
"/",
data={"bundle": file},
content_type="multipart/form-data",
),
config_overrides_context(PLUGIN_MAX_BUNDLE_SIZE=0),
patch("controllers.console.workspace.plugin.PluginService.upload_bundle") as upload_bundle_mock,
):
with pytest.raises(ValueError, match="File size exceeds the maximum allowed size") as exc_info:
method(api, "t1")
assert "File size exceeds the maximum allowed size" in str(exc_info.value)
upload_bundle_mock.assert_not_called()
class TestPluginInstallFromGithubApi:
def test_success(self, app: Flask):
api = PluginInstallFromGithubApi()
method = unwrap(api.post)
payload = {
"plugin_unique_identifier": "p",
"repo": "r",
"version": "v",
"package": "pkg",
}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginService.install_from_github", return_value={"ok": True}),
):
result = method(api, ParserGithubInstall.model_validate(payload), "t1")
assert result["ok"] is True
def test_daemon_error(self, app: Flask):
api = PluginInstallFromGithubApi()
method = unwrap(api.post)
payload = {
"plugin_unique_identifier": "p",
"repo": "r",
"version": "v",
"package": "pkg",
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.install_from_github",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserGithubInstall.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginInstallFromMarketplaceApi:
def test_success(self, app: Flask):
api = PluginInstallFromMarketplaceApi()
method = unwrap(api.post)
payload = {"plugin_unique_identifiers": ["p1"]}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.install_from_marketplace_pkg",
return_value={"ok": True},
),
):
result = method(api, ParserPluginIdentifiers.model_validate(payload), "t1")
assert result["ok"] is True
def test_daemon_error(self, app: Flask):
api = PluginInstallFromMarketplaceApi()
method = unwrap(api.post)
payload = {"plugin_unique_identifiers": ["p1"]}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.install_from_marketplace_pkg",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserPluginIdentifiers.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginFetchMarketplacePkgApi:
def test_success(self, app: Flask):
api = PluginFetchMarketplacePkgApi()
method = unwrap(api.get)
with (
app.test_request_context("/?plugin_unique_identifier=p"),
patch(
"controllers.console.workspace.plugin.PluginService.fetch_marketplace_pkg",
return_value=_plugin_declaration(),
),
):
result = method(api, ParserPluginIdentifierQuery.model_validate({"plugin_unique_identifier": "p"}), "t1")
assert result == {"manifest": _expected_plugin_declaration_dump()}
def test_daemon_error(self, app: Flask):
api = PluginFetchMarketplacePkgApi()
method = unwrap(api.get)
with (
app.test_request_context("/?plugin_unique_identifier=p"),
patch(
"controllers.console.workspace.plugin.PluginService.fetch_marketplace_pkg",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(
lambda: method(api, ParserPluginIdentifierQuery.model_validate({"plugin_unique_identifier": "p"}), "t1")
)
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginFetchManifestApi:
def test_success(self, app: Flask):
api = PluginFetchManifestApi()
method = unwrap(api.get)
manifest = _plugin_declaration()
with (
app.test_request_context("/?plugin_unique_identifier=p"),
patch("controllers.console.workspace.plugin.PluginService.fetch_plugin_manifest", return_value=manifest),
):
result = method(api, ParserPluginIdentifierQuery.model_validate({"plugin_unique_identifier": "p"}), "t1")
assert result == {"manifest": _expected_plugin_declaration_dump()}
def test_daemon_error(self, app: Flask):
api = PluginFetchManifestApi()
method = unwrap(api.get)
with (
app.test_request_context("/?plugin_unique_identifier=p"),
patch(
"controllers.console.workspace.plugin.PluginService.fetch_plugin_manifest",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(
lambda: method(api, ParserPluginIdentifierQuery.model_validate({"plugin_unique_identifier": "p"}), "t1")
)
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginFetchInstallTasksApi:
def test_success(self, app: Flask):
api = PluginFetchInstallTasksApi()
method = unwrap(api.get)
with (
app.test_request_context("/?page=1&page_size=10"),
patch(
"controllers.console.workspace.plugin.PluginService.fetch_install_tasks",
return_value=[_plugin_task()],
),
):
result = method(api, ParserTasks(), "t1")
assert result == {"tasks": [_expected_plugin_task_dump()]}
def test_daemon_error(self, app: Flask):
api = PluginFetchInstallTasksApi()
method = unwrap(api.get)
with (
app.test_request_context("/?page=1&page_size=10"),
patch(
"controllers.console.workspace.plugin.PluginService.fetch_install_tasks",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserTasks(), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginFetchInstallTaskApi:
def test_success(self, app: Flask):
api = PluginFetchInstallTaskApi()
method = unwrap(api.get)
with (
app.test_request_context("/"),
patch("controllers.console.workspace.plugin.PluginService.fetch_install_task", return_value=_plugin_task()),
):
result = method(api, "t1", "x")
assert result == {"task": _expected_plugin_task_dump()}
def test_daemon_error(self, app: Flask):
api = PluginFetchInstallTaskApi()
method = unwrap(api.get)
with (
app.test_request_context("/"),
patch(
"controllers.console.workspace.plugin.PluginService.fetch_install_task",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, "t1", "t"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginDeleteInstallTaskApi:
def test_success(self, app: Flask):
api = PluginDeleteInstallTaskApi()
method = unwrap(api.post)
with (
app.test_request_context("/"),
patch("controllers.console.workspace.plugin.PluginService.delete_install_task", return_value=True),
):
result = method(api, "t1", "x")
assert result["success"] is True
def test_daemon_error(self, app: Flask):
api = PluginDeleteInstallTaskApi()
method = unwrap(api.post)
with (
app.test_request_context("/"),
patch(
"controllers.console.workspace.plugin.PluginService.delete_install_task",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, "t1", "t"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginDeleteAllInstallTaskItemsApi:
def test_success(self, app: Flask):
api = PluginDeleteAllInstallTaskItemsApi()
method = unwrap(api.post)
with (
app.test_request_context("/"),
patch(
"controllers.console.workspace.plugin.PluginService.delete_all_install_task_items", return_value=True
),
):
result = method(api, "t1")
assert result["success"] is True
def test_daemon_error(self, app: Flask):
api = PluginDeleteAllInstallTaskItemsApi()
method = unwrap(api.post)
with (
app.test_request_context("/"),
patch(
"controllers.console.workspace.plugin.PluginService.delete_all_install_task_items",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginDeleteInstallTaskItemApi:
def test_success(self, app: Flask):
api = PluginDeleteInstallTaskItemApi()
method = unwrap(api.post)
with (
app.test_request_context("/"),
patch("controllers.console.workspace.plugin.PluginService.delete_install_task_item", return_value=True),
):
result = method(api, "t1", "task1", "item1")
assert result["success"] is True
def test_daemon_error(self, app: Flask):
api = PluginDeleteInstallTaskItemApi()
method = unwrap(api.post)
with (
app.test_request_context("/"),
patch(
"controllers.console.workspace.plugin.PluginService.delete_install_task_item",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, "t1", "task1", "item1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginUpgradeFromMarketplaceApi:
def test_success(self, app: Flask, user):
api = PluginUpgradeFromMarketplaceApi()
method = unwrap(api.post)
payload = {
"original_plugin_unique_identifier": "p1",
"new_plugin_unique_identifier": "p2",
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upgrade_plugin_with_marketplace",
return_value={"ok": True},
),
):
result = method(api, ParserMarketplaceUpgrade.model_validate(payload), "t1")
assert result["ok"] is True
def test_daemon_error(self, app: Flask):
api = PluginUpgradeFromMarketplaceApi()
method = unwrap(api.post)
payload = {
"original_plugin_unique_identifier": "p1",
"new_plugin_unique_identifier": "p2",
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upgrade_plugin_with_marketplace",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserMarketplaceUpgrade.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginUpgradeFromGithubApi:
def test_success(self, app: Flask):
api = PluginUpgradeFromGithubApi()
method = unwrap(api.post)
payload = {
"original_plugin_unique_identifier": "p1",
"new_plugin_unique_identifier": "p2",
"repo": "r",
"version": "v",
"package": "pkg",
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upgrade_plugin_with_github",
return_value={"ok": True},
),
):
result = method(api, ParserGithubUpgrade.model_validate(payload), "t1")
assert result["ok"] is True
def test_daemon_error(self, app: Flask):
api = PluginUpgradeFromGithubApi()
method = unwrap(api.post)
payload = {
"original_plugin_unique_identifier": "p1",
"new_plugin_unique_identifier": "p2",
"repo": "r",
"version": "v",
"package": "pkg",
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginService.upgrade_plugin_with_github",
side_effect=PluginDaemonClientSideError("error"),
),
):
result = raised_error(lambda: method(api, ParserGithubUpgrade.model_validate(payload), "t1"))
assert result == ({"code": "plugin_error", "message": "error"}, 400)
class TestPluginChangeAutoUpgradeApi:
def test_success(self, app: Flask):
api = PluginChangeAutoUpgradeApi()
method = unwrap(api.post)
user = _account()
payload = {
"category": TenantPluginAutoUpgradeCategory.TOOL.value,
"auto_upgrade": {
"strategy_setting": TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
"upgrade_time_of_day": 0,
"upgrade_mode": TenantPluginAutoUpgradeMode.EXCLUDE,
"exclude_plugins": [],
"include_plugins": [],
},
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginAutoUpgradeService.change_strategy", return_value=True
) as change,
):
result = method(api, ParserAutoUpgradeChange.model_validate(payload), "t1", user)
assert result["success"] is True
change.assert_called_once()
def test_success_with_model_category_auto_upgrade(self, app: Flask):
api = PluginChangeAutoUpgradeApi()
method = unwrap(api.post)
user = _account()
payload = {
"category": TenantPluginAutoUpgradeCategory.MODEL.value,
"auto_upgrade": {
"strategy_setting": TenantPluginAutoUpgradeStrategySetting.LATEST,
"upgrade_time_of_day": 3600,
"upgrade_mode": TenantPluginAutoUpgradeMode.ALL,
"exclude_plugins": [],
"include_plugins": [],
},
}
with (
app.test_request_context("/", json=payload),
patch(
"controllers.console.workspace.plugin.PluginAutoUpgradeService.change_strategy", return_value=True
) as change,
):
result = method(api, ParserAutoUpgradeChange.model_validate(payload), "t1", user)
assert result["success"] is True
change.assert_called_once()
assert change.call_args.kwargs["category"] == TenantPluginAutoUpgradeCategory.MODEL
def test_auto_upgrade_fail(self, app: Flask):
api = PluginChangeAutoUpgradeApi()
method = unwrap(api.post)
user = _account()
payload = {
"category": TenantPluginAutoUpgradeCategory.TOOL.value,
"auto_upgrade": {
"strategy_setting": TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
"upgrade_time_of_day": 0,
"upgrade_mode": TenantPluginAutoUpgradeMode.EXCLUDE,
"exclude_plugins": [],
"include_plugins": [],
},
}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginAutoUpgradeService.change_strategy", return_value=False),
):
result = method(api, ParserAutoUpgradeChange.model_validate(payload), "t1", user)
assert result["success"] is False
class TestPluginFetchAutoUpgradeApi:
def test_success(self, app: Flask):
api = PluginFetchAutoUpgradeApi()
method = unwrap(api.get)
auto_upgrade = TenantPluginAutoUpgradeStrategy(
tenant_id="t1",
category=TenantPluginAutoUpgradeCategory.TOOL,
strategy_setting=TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
upgrade_time_of_day=1,
upgrade_mode=TenantPluginAutoUpgradeMode.EXCLUDE,
exclude_plugins=[],
include_plugins=[],
)
with (
app.test_request_context(f"/?category={TenantPluginAutoUpgradeCategory.TOOL.value}"),
patch(
"controllers.console.workspace.plugin.PluginAutoUpgradeService.get_strategy",
return_value=auto_upgrade,
),
):
result = method(
api,
ParserAutoUpgradeFetch.model_validate({"category": TenantPluginAutoUpgradeCategory.TOOL.value}),
"t1",
)
assert result["category"] == TenantPluginAutoUpgradeCategory.TOOL
assert result["auto_upgrade"]["upgrade_time_of_day"] == 1
def test_returns_disabled_settings_when_strategy_is_missing(self, app: Flask):
api = PluginFetchAutoUpgradeApi()
method = unwrap(api.get)
with (
app.test_request_context(f"/?category={TenantPluginAutoUpgradeCategory.MODEL.value}"),
patch(
"controllers.console.workspace.plugin.PluginAutoUpgradeService.get_strategy",
return_value=None,
),
patch(
"controllers.console.workspace.plugin.PluginAutoUpgradeService.default_upgrade_time_of_day",
return_value=78300,
),
):
result = method(
api,
ParserAutoUpgradeFetch.model_validate({"category": TenantPluginAutoUpgradeCategory.MODEL.value}),
"t1",
)
assert result == {
"category": TenantPluginAutoUpgradeCategory.MODEL,
"auto_upgrade": {
"strategy_setting": TenantPluginAutoUpgradeStrategySetting.DISABLED,
"upgrade_time_of_day": 78300,
"upgrade_mode": TenantPluginAutoUpgradeMode.EXCLUDE,
"exclude_plugins": [],
"include_plugins": [],
},
}
class TestPluginAutoUpgradeExcludePluginApi:
def test_success(self, app: Flask):
api = PluginAutoUpgradeExcludePluginApi()
method = unwrap(api.post)
payload = {"plugin_id": "p", "category": TenantPluginAutoUpgradeCategory.TOOL.value}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginAutoUpgradeService.exclude_plugin", return_value=True),
):
result = method(api, ParserExcludePlugin.model_validate(payload), "t1")
assert result["success"] is True
def test_fail(self, app: Flask):
api = PluginAutoUpgradeExcludePluginApi()
method = unwrap(api.post)
payload = {"plugin_id": "p", "category": TenantPluginAutoUpgradeCategory.TOOL.value}
with (
app.test_request_context("/", json=payload),
patch("controllers.console.workspace.plugin.PluginAutoUpgradeService.exclude_plugin", return_value=False),
):
result = method(api, ParserExcludePlugin.model_validate(payload), "t1")
assert result["success"] is False