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
from __future__ import annotations
import io
from collections.abc import Callable
from dataclasses import dataclass, field
from inspect import signature
from inspect import unwrap as inspect_unwrap
from typing import cast
from unittest.mock import PropertyMock, patch
import pytest
from flask import Flask, Response
from sqlalchemy.orm import Session
from controllers.console import console_ns
from controllers.console.workspace.skills import (
WorkspaceAgentSkillBindingsApi,
WorkspaceSkillApi,
WorkspaceSkillAssistMessageApi,
WorkspaceSkillDuplicateApi,
WorkspaceSkillExportApi,
WorkspaceSkillFileContentApi,
WorkspaceSkillFilePreviewApi,
WorkspaceSkillFilesApi,
WorkspaceSkillFilesCheckApi,
WorkspaceSkillFileUploadApi,
WorkspaceSkillImportApi,
WorkspaceSkillPublishApi,
WorkspaceSkillReferencesApi,
WorkspaceSkillRestoreApi,
WorkspaceSkillsApi,
WorkspaceSkillTagsApi,
WorkspaceSkillVersionApi,
WorkspaceSkillVersionsApi,
)
from controllers.inner_api.plugin.skills import PublishedSkillPullApi
from machinery.context import RequestContext
from services.skill_management_service import (
DraftSkillArchive,
PublishedSkillArchive,
SkillAssistAttachmentPayload,
SkillDraftFileCheckPayload,
SkillDraftFileOperationPayload,
SkillDraftTreePayload,
SkillFileContent,
SkillImportPayload,
SkillManagementService,
SkillManagementServiceError,
SkillMetadataPayload,
SkillPublishPayload,
SkillRestorePayload,
SkillVersionUpdatePayload,
)
from tests.helpers.unit.controllers.error_body import raised_error
@dataclass(frozen=True)
class RecordedCall:
args: tuple[object, ...]
kwargs: dict[str, object]
@dataclass
class CallRecorder:
result: object = None
error: Exception | None = None
calls: list[RecordedCall] = field(default_factory=list)
def __call__(self, *args: object, **kwargs: object) -> object:
self.calls.append(RecordedCall(args=args, kwargs=kwargs))
if self.error is not None:
raise self.error
return self.result
def _recording_service(
method_name: str,
*,
result: object = None,
error: Exception | None = None,
) -> tuple[SkillManagementService, CallRecorder]:
service = SkillManagementService(session=Session())
recorder = CallRecorder(result=result, error=error)
setattr(service, method_name, recorder)
return service, recorder
def unwrap[ReturnT](func: Callable[..., object]) -> Callable[..., ReturnT]:
"""Call the raw handler before session injection and response serialization."""
unwrapped = cast(Callable[..., ReturnT], inspect_unwrap(func))
parameters = list(signature(unwrapped).parameters.values())
if len(parameters) > 1 and parameters[1].name == "session":
def invoke(*args: object, **kwargs: object) -> ReturnT:
with Session() as session:
return unwrapped(args[0], session, *args[1:], **kwargs)
return invoke
return unwrapped
@pytest.fixture
def app() -> Flask:
flask_app = Flask("test_workspace_skills")
flask_app.config["TESTING"] = True
return flask_app
@pytest.fixture
def request_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id=None,
account_id="user-1",
active_workspace_id="tenant-1",
)
def _skill_detail() -> dict[str, object]:
return {
"id": "skill-1",
"name": "finance-sop",
"display_name": "Finance SOP",
"icon": "📄",
"description": "",
"tags": [],
"name_manually_edited": False,
"visibility": "workspace",
"latest_published_version_id": None,
"reference_count": 0,
"created_by": "user-1",
"created_by_name": "Test User",
"updated_by": "user-1",
"updated_by_name": "Test User",
"created_at": 1,
"updated_at": 1,
"files": [
{
"id": "file-1",
"path": "SKILL.md",
"kind": "file",
"storage": "text",
"mime_type": "text/markdown",
"content": "---\nname: finance-sop\n---\n# Body",
"tool_file_id": None,
"size": 32,
"hash": "hash",
}
],
}
def test_create_skill_validates_payload_and_returns_detail(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillsApi()
method = unwrap(api.post)
service, create_skill = _recording_service("create_skill", result=_skill_detail())
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = method(api, request_context)
assert status == 201
assert payload["id"] == "skill-1"
assert payload["files"][0]["path"] == "SKILL.md"
assert len(create_skill.calls) == 1
assert create_skill.calls[0].kwargs["tenant_id"] == "tenant-1"
assert create_skill.calls[0].kwargs["user_id"] == "user-1"
@pytest.mark.parametrize("side_effect", [ValueError("bad payload"), SkillManagementServiceError("skill_error", "bad")])
def test_create_skill_maps_validation_and_service_errors(
app: Flask,
request_context: RequestContext,
side_effect: Exception,
) -> None:
api = WorkspaceSkillsApi()
method = unwrap(api.post)
service, _ = _recording_service("create_skill", error=side_effect)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"name": "finance-sop"}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context))
assert status == 400
assert payload["code"] in {"invalid_request", "skill_error"}
def test_create_skill_rejects_extra_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillsApi()
method = unwrap(api.post)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"unknown": "field"}),
):
payload, status = raised_error(lambda: method(api, request_context))
assert status == 400
assert payload["code"] == "invalid_request"
def test_list_skills_uses_default_pagination_when_query_omits_page_and_limit(
app: Flask, request_context: RequestContext
) -> None:
api = WorkspaceSkillsApi()
method = unwrap(api.get)
service, list_skills = _recording_service("list_skills")
list_response: dict[str, object] = {
"data": [],
"has_more": False,
"limit": 20,
"page": 1,
"total": 0,
}
list_skills.result = list_response
with (
app.test_request_context("/?keyword=finance&tag=ops&tag=", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context)
assert payload == {
"data": [],
"has_more": False,
"limit": 20,
"page": 1,
"total": 0,
}
assert list_skills.calls == [
RecordedCall(
args=(),
kwargs={"tenant_id": "tenant-1", "keyword": "finance", "page": 1, "limit": 20, "tags": ["ops"]},
)
]
def test_list_skills_passes_explicit_pagination(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillsApi()
method = unwrap(api.get)
service, list_skills = _recording_service("list_skills")
list_response: dict[str, object] = {"data": [], "has_more": False, "limit": 10, "page": 2, "total": 0}
list_skills.result = list_response
with (
app.test_request_context("/?limit=10&page=2", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context)
assert payload["limit"] == 10
assert payload["page"] == 2
assert list_skills.calls == [
RecordedCall(
args=(),
kwargs={"tenant_id": "tenant-1", "keyword": None, "page": 2, "limit": 10, "tags": []},
)
]
def test_upload_skill_file_returns_tool_file_metadata(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFileUploadApi()
method = unwrap(api.post)
service, upload_file = _recording_service(
"upload_file",
result={
"id": "tool-file-1",
"name": "policy.md",
"mime_type": "text/markdown",
"size": 12,
"hash": "hash",
},
)
with (
app.test_request_context(
"/",
method="POST",
data={"file": (io.BytesIO(b"Policy text."), "policy.md")},
content_type="multipart/form-data",
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = method(api, request_context)
assert status == 201
assert payload["id"] == "tool-file-1"
assert upload_file.calls == [
RecordedCall(
args=(),
kwargs={
"tenant_id": "tenant-1",
"user_id": "user-1",
"filename": "policy.md",
"content": b"Policy text.",
"mime_type": "text/markdown",
},
)
]
def test_upload_skill_file_requires_file(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFileUploadApi()
method = unwrap(api.post)
with app.test_request_context("/", method="POST", data={}, content_type="multipart/form-data"):
payload, status = raised_error(lambda: method(api, request_context))
assert status == 400
assert payload == {"code": "no_file_uploaded", "message": "no file uploaded"}
def test_upload_skill_file_requires_filename(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFileUploadApi()
method = unwrap(api.post)
with app.test_request_context(
"/",
method="POST",
data={"file": (io.BytesIO(b"payload"), "")},
content_type="multipart/form-data",
):
payload, status = raised_error(lambda: method(api, request_context))
assert status == 400
assert payload == {"code": "filename_missing", "message": "filename is required"}
def test_import_skill_uploads_zip(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillImportApi()
method = unwrap(api.post)
service, import_skill = _recording_service("import_skill", result=_skill_detail())
with (
app.test_request_context(
"/",
method="POST",
data={"file": (io.BytesIO(b"zip-bytes"), "skill.zip")},
content_type="multipart/form-data",
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = method(api, request_context)
assert status == 201
assert payload["id"] == "skill-1"
call = import_skill.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["user_id"] == "user-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillImportPayload)
assert service_payload.content == b"zip-bytes"
assert service_payload.filename == "skill.zip"
def test_import_skill_requires_file(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillImportApi()
method = unwrap(api.post)
with app.test_request_context("/", method="POST", data={}, content_type="multipart/form-data"):
payload, status = raised_error(lambda: method(api, request_context))
assert status == 400
assert payload == {"code": "invalid_request", "message": "file is required"}
def test_import_skill_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillImportApi()
method = unwrap(api.post)
service, _ = _recording_service(
"import_skill", error=SkillManagementServiceError("invalid_skill_archive", "invalid archive")
)
with (
app.test_request_context(
"/",
method="POST",
data={"file": (io.BytesIO(b"bad"), "skill.zip")},
content_type="multipart/form-data",
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context))
assert status == 400
assert payload == {"code": "invalid_skill_archive", "message": "invalid archive"}
def test_get_skill_detail_returns_files(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillApi()
method = unwrap(api.get)
service, get_skill = _recording_service("get_skill", result=_skill_detail())
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["id"] == "skill-1"
assert payload["files"][0]["path"] == "SKILL.md"
assert get_skill.calls == [RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1"})]
def test_get_skill_detail_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillApi()
method = unwrap(api.get)
service, _ = _recording_service(
"get_skill", error=SkillManagementServiceError("skill_not_found", "skill not found", status_code=404)
)
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 404
assert payload == {"code": "skill_not_found", "message": "skill not found"}
def test_update_skill_metadata_validates_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillApi()
method = unwrap(api.patch)
service, update_metadata = _recording_service(
"update_metadata", result={key: value for key, value in _skill_detail().items() if key != "files"}
)
with (
app.test_request_context("/", method="PATCH"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={"display_name": "Finance SOP", "icon": "📘", "tags": ["finance"]},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["display_name"] == "Finance SOP"
call = update_metadata.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["user_id"] == "user-1"
assert call["skill_id"] == "skill-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillMetadataPayload)
assert service_payload.tags == ["finance"]
@pytest.mark.parametrize(
"side_effect",
[ValueError("bad metadata"), SkillManagementServiceError("skill_conflict", "conflict", status_code=409)],
)
def test_update_skill_metadata_maps_service_errors(
app: Flask,
request_context: RequestContext,
side_effect: Exception,
) -> None:
api = WorkspaceSkillApi()
method = unwrap(api.patch)
service, _ = _recording_service("update_metadata", error=side_effect)
with (
app.test_request_context("/", method="PATCH"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"display_name": "Finance"}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status in {400, 409}
assert payload["code"] in {"invalid_request", "skill_conflict"}
def test_delete_skill_passes_confirmation_name(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillApi()
method = unwrap(api.delete)
service, delete_skill = _recording_service("delete_skill", result={"id": "skill-1", "deleted": True})
with (
app.test_request_context("/", method="DELETE"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={"confirmation_name": "finance-sop"},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload == {"id": "skill-1", "deleted": True}
assert delete_skill.calls == [
RecordedCall(
args=(),
kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1", "confirmation_name": "finance-sop"},
)
]
def test_delete_skill_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillApi()
method = unwrap(api.delete)
service, _ = _recording_service(
"delete_skill",
error=SkillManagementServiceError(
"skill_referenced",
"skill is referenced",
status_code=409,
),
)
with (
app.test_request_context("/", method="DELETE"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 409
assert payload == {"code": "skill_referenced", "message": "skill is referenced"}
def test_duplicate_skill_returns_new_detail(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillDuplicateApi()
method = unwrap(api.post)
service, duplicate_skill = _recording_service("duplicate_skill", result=_skill_detail())
with (
app.test_request_context("/", method="POST"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = method(api, request_context, "skill-1")
assert status == 201
assert payload["id"] == "skill-1"
assert duplicate_skill.calls == [
RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "user_id": "user-1", "skill_id": "skill-1"})
]
def test_duplicate_skill_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillDuplicateApi()
method = unwrap(api.post)
service, _ = _recording_service(
"duplicate_skill",
error=SkillManagementServiceError(
"skill_not_found",
"skill not found",
status_code=404,
),
)
with (
app.test_request_context("/", method="POST"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 404
assert payload == {"code": "skill_not_found", "message": "skill not found"}
def test_export_skill_returns_archive_response(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillExportApi()
method = unwrap(api.get)
service, export_draft_archive = _recording_service(
"export_draft_archive",
result=DraftSkillArchive(
payload=b"zip-bytes",
mime_type="application/zip",
filename="finance-sop.zip",
),
)
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
response = method(api, request_context, "skill-1")
assert response.status_code == 200
assert response.mimetype == "application/zip"
assert response.headers["Content-Disposition"].startswith("attachment;")
response.direct_passthrough = False
assert response.get_data() == b"zip-bytes"
assert export_draft_archive.calls == [
RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1"})
]
def test_export_skill_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillExportApi()
method = unwrap(api.get)
service, _ = _recording_service(
"export_draft_archive",
error=SkillManagementServiceError(
"skill_not_found",
"skill not found",
status_code=404,
),
)
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 404
assert payload == {"code": "skill_not_found", "message": "skill not found"}
def test_inner_api_pulls_published_skill_archive(app: Flask) -> None:
api = PublishedSkillPullApi()
method = unwrap(PublishedSkillPullApi.get)
service, pull_published_archive = _recording_service(
"pull_published_archive",
result=PublishedSkillArchive(
payload=b"zip-bytes",
mime_type="application/zip",
filename="finance-sop.zip",
),
)
with (
app.test_request_context("/?tenant_id=tenant-1", method="GET"),
patch("controllers.inner_api.plugin.skills.SkillManagementService", return_value=service),
):
response = method(api, "skill-1")
assert response.status_code == 200
assert response.mimetype == "application/zip"
response.direct_passthrough = False
assert response.get_data() == b"zip-bytes"
assert pull_published_archive.calls == [
RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1"})
]
def test_inner_api_pull_maps_missing_tenant_to_invalid_request(app: Flask) -> None:
api = PublishedSkillPullApi()
method = unwrap(PublishedSkillPullApi.get)
with app.test_request_context("/", method="GET"):
payload, status = method(api, "skill-1")
assert status == 400
assert payload["code"] == "invalid_request"
def test_get_agent_skill_bindings_returns_card_data(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceAgentSkillBindingsApi()
method = unwrap(api.get)
service, list_agent_bindings = _recording_service(
"list_agent_bindings",
result={
"agent_id": "agent-1",
"skill_ids": ["skill-1"],
"data": [
{
"id": "skill-1",
"priority": 0,
"name": "finance-sop",
"display_name": "Finance SOP",
"icon": "📄",
"description": "Handle finance.",
"tags": ["Finance"],
"status": "published",
"file_count": 2,
"latest_published_version_id": "version-1",
"latest_published_at": 123,
"updated_at": 124,
}
],
},
)
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "agent-1")
assert payload["skill_ids"] == ["skill-1"]
assert payload["data"][0]["display_name"] == "Finance SOP"
assert payload["data"][0]["file_count"] == 2
assert list_agent_bindings.calls == [RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "agent_id": "agent-1"})]
def test_patch_skill_file_operation_validates_payload_and_returns_detail(
app: Flask, request_context: RequestContext
) -> None:
api = WorkspaceSkillFilesApi()
method = unwrap(api.patch)
service, apply_draft_file_operation = _recording_service("apply_draft_file_operation", result=_skill_detail())
request_payload = {
"operation": "upsert_text",
"path": "references/policy.md",
"content": "Policy",
}
with (
app.test_request_context("/", method="PATCH"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=request_payload),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["id"] == "skill-1"
assert len(apply_draft_file_operation.calls) == 1
call = apply_draft_file_operation.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["user_id"] == "user-1"
assert call["skill_id"] == "skill-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillDraftFileOperationPayload)
assert service_payload.operation == "upsert_text"
def test_patch_skill_file_operation_returns_error_details(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFilesApi()
method = unwrap(api.patch)
service, _ = _recording_service(
"apply_draft_file_operation",
error=SkillManagementServiceError(
"missing_skill_name",
"SKILL.md frontmatter name is required",
details={"path": "SKILL.md", "field": "name", "line": 2},
),
)
with (
app.test_request_context("/", method="PATCH"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={"operation": "delete", "path": "SKILL.md"},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload == {
"code": "missing_skill_name",
"message": "SKILL.md frontmatter name is required",
"details": {"path": "SKILL.md", "field": "name", "line": 2},
}
def test_check_skill_files_validates_payload_and_returns_results(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFilesCheckApi()
method = unwrap(api.post)
service, check_draft_files = _recording_service(
"check_draft_files",
result={
"data": {
"policy.md": {
"path": "references/policy.md",
"filename": "policy.md",
"extension": ".md",
"mime_type": "text/markdown",
"size": 12,
"errors": list[dict[str, str]](),
}
},
},
)
with (
app.test_request_context("/", method="POST"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={"files": [{"filename": "policy.md", "path": "references/policy.md", "size": 12}]},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["data"]["policy.md"]["path"] == "references/policy.md"
assert payload["data"]["policy.md"]["errors"] == []
assert len(check_draft_files.calls) == 1
call = check_draft_files.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["skill_id"] == "skill-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillDraftFileCheckPayload)
assert service_payload.files[0].filename == "policy.md"
def test_replace_skill_draft_tree_validates_payload_and_returns_detail(
app: Flask, request_context: RequestContext
) -> None:
api = WorkspaceSkillFilesApi()
method = unwrap(api.put)
service, replace_draft_tree = _recording_service("replace_draft_tree", result=_skill_detail())
with (
app.test_request_context("/", method="PUT"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={"files": [{"path": "SKILL.md", "content": "# Body"}]},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["id"] == "skill-1"
call = replace_draft_tree.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["user_id"] == "user-1"
assert call["skill_id"] == "skill-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillDraftTreePayload)
assert service_payload.files[0].path == "SKILL.md"
def test_preview_skill_file_validates_query(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFilePreviewApi()
method = unwrap(api.get)
service, preview_file = _recording_service(
"preview_file",
result={
"path": "SKILL.md",
"mime_type": "text/markdown",
"content": "# Body",
"size": 6,
"hash": "hash",
},
)
with (
app.test_request_context("/?path=SKILL.md&version_id=version-1", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["content"] == "# Body"
assert preview_file.calls == [
RecordedCall(
args=(),
kwargs={
"tenant_id": "tenant-1",
"skill_id": "skill-1",
"path": "SKILL.md",
"version_id": "version-1",
},
)
]
def test_pull_skill_file_content_returns_download(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFileContentApi()
method = unwrap(api.get)
service, pull_file = _recording_service(
"pull_file",
result=SkillFileContent(
filename="SKILL.md",
path="SKILL.md",
mime_type="text/markdown",
payload=b"# Body",
content="# Body",
size=6,
hash="hash",
),
)
with (
app.test_request_context("/?path=SKILL.md&download=1", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
response = method(api, request_context, "skill-1")
assert response.status_code == 200
assert response.mimetype == "text/markdown"
assert response.headers["Content-Disposition"].startswith("attachment;")
response.direct_passthrough = False
assert response.get_data() == b"# Body"
assert pull_file.calls == [
RecordedCall(
args=(),
kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1", "path": "SKILL.md", "version_id": None},
)
]
def test_list_skill_tags_returns_filter_options(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillTagsApi()
method = unwrap(api.get)
service, list_tags = _recording_service("list_tags", result={"data": [{"tag": "finance", "count": 2}]})
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context)
assert payload == {"data": [{"tag": "finance", "count": 2}]}
assert list_tags.calls == [RecordedCall(args=(), kwargs={"tenant_id": "tenant-1"})]
def test_publish_skill_validates_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillPublishApi()
method = unwrap(api.post)
service, publish_skill = _recording_service(
"publish_skill",
result={
"id": "version-1",
"skill_id": "skill-1",
"version_number": 1,
"version_name": "Initial",
"publish_note": "Initial",
"hash_code": "hash-code",
"archive_size": 123,
"published_by": "user-1",
"published_by_name": "Li Wei",
"is_latest": True,
"created_at": 1,
},
)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"publish_note": "Initial"}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["id"] == "version-1"
call = publish_skill.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["user_id"] == "user-1"
assert call["skill_id"] == "skill-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillPublishPayload)
assert service_payload.publish_note == "Initial"
def test_restore_skill_version_validates_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillRestoreApi()
method = unwrap(api.post)
service, restore_version = _recording_service("restore_version")
empty_tags: list[object] = []
empty_files: list[object] = []
restored_skill: dict[str, object] = {
"id": "skill-1",
"name": "finance-sop",
"display_name": "Finance SOP",
"icon": "📄",
"description": "Finance procedures",
"tags": empty_tags,
"name_manually_edited": False,
"visibility": "workspace",
"latest_published_version_id": "version-1",
"latest_published_version_number": 1,
"latest_published_at": 1,
"reference_count": 0,
"created_by": "user-1",
"created_by_name": "Li Wei",
"updated_by": "user-1",
"updated_by_name": "Li Wei",
"created_at": 1,
"updated_at": 2,
"files": empty_files,
}
restore_version.result = restored_skill
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"version_id": "version-1"}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["latest_published_version_id"] == "version-1"
call = restore_version.calls[0].kwargs
assert call["tenant_id"] == "tenant-1"
assert call["user_id"] == "user-1"
assert call["skill_id"] == "skill-1"
service_payload = call["payload"]
assert isinstance(service_payload, SkillRestorePayload)
assert service_payload.version_id == "version-1"
def test_list_skill_references_returns_reference_data(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillReferencesApi()
method = unwrap(api.get)
service, list_skill_references = _recording_service(
"list_skill_references",
result={
"data": [
{
"type": "agent",
"agent_id": "agent-1",
"name": "Agent",
"display_name": "Agent",
}
],
},
)
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["data"][0]["agent_id"] == "agent-1"
assert list_skill_references.calls == [
RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1"})
]
def test_list_skill_versions_returns_version_page(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillVersionsApi()
method = unwrap(api.get)
service, list_versions = _recording_service(
"list_versions",
result={
"data": [
{
"id": "version-1",
"skill_id": "skill-1",
"version_number": 1,
"version_name": "Initial",
"publish_note": "Initial",
"hash_code": "hash-code",
"archive_size": 123,
"published_by": "user-1",
"published_by_name": "Li Wei",
"is_latest": True,
"created_at": 1,
}
],
},
)
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1")
assert payload["data"][0]["id"] == "version-1"
assert list_versions.calls == [RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1"})]
def test_get_skill_version_returns_version_detail(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillVersionApi()
method = unwrap(api.get)
service, get_version = _recording_service("get_version")
version_response: dict[str, object] = {
"id": "version-1",
"skill_id": "skill-1",
"version_number": 1,
"version_name": "Initial finance policy",
"publish_note": "Initial finance policy",
"hash_code": "hash-code",
"archive_size": 123,
"published_by": "user-1",
"published_by_name": "Li Wei",
"is_latest": True,
"created_at": 1,
"files": [
{
"id": None,
"path": "SKILL.md",
"kind": "file",
"storage": "text",
"mime_type": "text/markdown",
"content": "# Version",
"tool_file_id": None,
"size": 9,
"hash": "file-hash",
}
],
}
get_version.result = version_response
with (
app.test_request_context("/", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1", "version-1")
assert payload["files"][0]["content"] == "# Version"
assert get_version.calls == [
RecordedCall(args=(), kwargs={"tenant_id": "tenant-1", "skill_id": "skill-1", "version_id": "version-1"})
]
def test_patch_skill_version_renames_version(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillVersionApi()
method = unwrap(api.patch)
service, update_version = _recording_service(
"update_version",
result={
"id": "version-1",
"skill_id": "skill-1",
"version_number": 1,
"version_name": "Approval threshold",
"publish_note": "",
"hash_code": "hash-code",
"archive_size": 123,
"published_by": "user-1",
"published_by_name": "Li Wei",
"is_latest": True,
"created_at": 1,
},
)
with (
app.test_request_context("/", method="PATCH"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={"version_name": "Approval threshold"},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1", "version-1")
assert payload["version_name"] == "Approval threshold"
assert len(update_version.calls) == 1
service_payload = update_version.calls[0].kwargs["payload"]
assert isinstance(service_payload, SkillVersionUpdatePayload)
assert service_payload.version_name == "Approval threshold"
def test_delete_skill_version_returns_new_latest(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillVersionApi()
method = unwrap(api.delete)
service, delete_version = _recording_service(
"delete_version",
result={
"id": "version-2",
"deleted": True,
"latest_published_version_id": "version-1",
},
)
with (
app.test_request_context("/", method="DELETE"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "skill-1", "version-2")
assert payload == {"id": "version-2", "deleted": True, "latest_published_version_id": "version-1"}
assert delete_version.calls == [
RecordedCall(
args=(),
kwargs={
"tenant_id": "tenant-1",
"user_id": "user-1",
"skill_id": "skill-1",
"version_id": "version-2",
},
)
]
def test_skill_assistant_runs_agent_app_stream(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillAssistMessageApi()
method = unwrap(api.post)
action_stream = iter([{"event": "done"}])
service, create_assistant_action_stream = _recording_service("create_assistant_action_stream", result=action_stream)
compact_response = Response("compact")
compact_generate_response = CallRecorder(result=compact_response)
with (
app.test_request_context("/", method="POST"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value={
"attachments": [
{
"tool_file_id": "tool-file-1",
"name": "requirements.md",
"mime_type": "text/markdown",
"size": 128,
}
],
"message": "Create an approval checklist.",
},
),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
patch("controllers.console.workspace.skills.helper.compact_generate_response", new=compact_generate_response),
):
response = method(api, request_context, "skill-1")
assert response is compact_response
assert create_assistant_action_stream.calls == [
RecordedCall(
args=(),
kwargs={
"tenant_id": "tenant-1",
"skill_id": "skill-1",
"user_id": "user-1",
"message": "Create an approval checklist.",
"attachments": [
SkillAssistAttachmentPayload(
tool_file_id="tool-file-1",
name="requirements.md",
mime_type="text/markdown",
size=128,
)
],
"history": [],
"model_payload": None,
"target_path": None,
},
)
]
assert compact_generate_response.calls == [RecordedCall(args=(action_stream,), kwargs={})]
@pytest.mark.parametrize("payload", [{}, {"message": "x", "unknown": True}])
def test_skill_assistant_rejects_invalid_payload(
app: Flask,
request_context: RequestContext,
payload: dict[str, object],
) -> None:
api = WorkspaceSkillAssistMessageApi()
method = unwrap(api.post)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload),
):
response_body, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert response_body["code"] == "invalid_request"
def test_skill_assistant_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillAssistMessageApi()
method = unwrap(api.post)
service, _ = _recording_service(
"create_assistant_action_stream",
error=SkillManagementServiceError(
"model_provider_not_configured",
"model provider not configured",
),
)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"message": "help"}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload == {"code": "model_provider_not_configured", "message": "model provider not configured"}
@pytest.mark.parametrize(
("method_name", "payload"),
[
("patch", {"operation": "upsert_text", "path": "SKILL.md", "content": "x"}),
("put", {"files": [{"path": "SKILL.md", "content": "# Body"}]}),
],
)
def test_skill_file_write_methods_map_conflicts(
app: Flask,
request_context: RequestContext,
method_name: str,
payload: dict[str, object],
) -> None:
api = WorkspaceSkillFilesApi()
conflict = SkillManagementServiceError(
"skill_conflict",
"skill has been modified by another user",
status_code=409,
)
if method_name == "patch":
method = unwrap(api.patch)
service, _ = _recording_service("apply_draft_file_operation", error=conflict)
else:
method = unwrap(api.put)
service, _ = _recording_service("replace_draft_tree", error=conflict)
with (
app.test_request_context("/", method=method_name.upper()),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
response_body, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 409
assert response_body["code"] == "skill_conflict"
def test_replace_skill_draft_tree_maps_value_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFilesApi()
method = unwrap(api.put)
service, _ = _recording_service("replace_draft_tree", error=ValueError("bad path"))
with (
app.test_request_context("/", method="PUT"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"files": []}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload == {"code": "invalid_request", "message": "bad path"}
@pytest.mark.parametrize("query_string", ["", "?path=../secret.md"])
def test_preview_skill_file_rejects_invalid_query(
app: Flask, request_context: RequestContext, query_string: str
) -> None:
api = WorkspaceSkillFilePreviewApi()
method = unwrap(api.get)
with app.test_request_context(f"/{query_string}", method="GET"):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload["code"] == "invalid_request"
def test_preview_skill_file_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFilePreviewApi()
method = unwrap(api.get)
service, _ = _recording_service(
"preview_file", error=SkillManagementServiceError("file_not_found", "file not found", status_code=404)
)
with (
app.test_request_context("/?path=SKILL.md", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 404
assert payload == {"code": "file_not_found", "message": "file not found"}
@pytest.mark.parametrize("query_string", ["", "?path=../secret.md"])
def test_pull_skill_file_content_rejects_invalid_query(
app: Flask, request_context: RequestContext, query_string: str
) -> None:
api = WorkspaceSkillFileContentApi()
method = unwrap(api.get)
with app.test_request_context(f"/{query_string}", method="GET"):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload["code"] == "invalid_request"
def test_pull_skill_file_content_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillFileContentApi()
method = unwrap(api.get)
service, _ = _recording_service(
"pull_file", error=SkillManagementServiceError("file_not_found", "file not found", status_code=404)
)
with (
app.test_request_context("/?path=SKILL.md", method="GET"),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 404
assert payload == {"code": "file_not_found", "message": "file not found"}
def test_publish_skill_rejects_invalid_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillPublishApi()
method = unwrap(api.post)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"publish_note": "x" * 1025}),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload["code"] == "invalid_request"
def test_publish_skill_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillPublishApi()
method = unwrap(api.post)
service, _ = _recording_service(
"publish_skill", error=SkillManagementServiceError("missing_skill_name", "name required")
)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload == {"code": "missing_skill_name", "message": "name required"}
def test_restore_skill_version_rejects_invalid_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillRestoreApi()
method = unwrap(api.post)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={}),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 400
assert payload["code"] == "invalid_request"
def test_restore_skill_version_maps_service_error(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceSkillRestoreApi()
method = unwrap(api.post)
service, _ = _recording_service(
"restore_version",
error=SkillManagementServiceError(
"version_not_found",
"version not found",
status_code=404,
),
)
with (
app.test_request_context("/", method="POST"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"version_id": "version-1"}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload, status = raised_error(lambda: method(api, request_context, "skill-1"))
assert status == 404
assert payload == {"code": "version_not_found", "message": "version not found"}
def test_agent_skill_bindings_replaces_bound_skills(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceAgentSkillBindingsApi()
method = unwrap(api.put)
service, replace_agent_bindings = _recording_service("replace_agent_bindings")
bindings_response: dict[str, object] = {"agent_id": "agent-1", "skill_ids": ["skill-1"], "data": []}
replace_agent_bindings.result = bindings_response
with (
app.test_request_context("/", method="PUT"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"skill_ids": ["skill-1"]}),
patch("controllers.console.workspace.skills.SkillManagementService", return_value=service),
):
payload = method(api, request_context, "agent-1")
assert payload["skill_ids"] == ["skill-1"]
assert replace_agent_bindings.calls == [
RecordedCall(
args=(),
kwargs={
"tenant_id": "tenant-1",
"user_id": "user-1",
"agent_id": "agent-1",
"skill_ids": ["skill-1"],
},
)
]
def test_agent_skill_bindings_rejects_invalid_payload(app: Flask, request_context: RequestContext) -> None:
api = WorkspaceAgentSkillBindingsApi()
method = unwrap(api.put)
with (
app.test_request_context("/", method="PUT"),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value={"skill_ids": "skill-1"}),
):
payload, status = raised_error(lambda: method(api, request_context, "agent-1"))
assert status == 400
assert payload["code"] == "invalid_request"
def test_skill_import_documents_required_multipart_file() -> None:
from flask_restx.swagger import Swagger
from controllers.console import api
resource = Swagger(api).serialize_resource(console_ns, WorkspaceSkillImportApi, "/workspaces/current/skills/import")
assert resource is not None
operation = resource["post"]
body = operation["requestBody"]
assert body["required"] is True
schema = body["content"]["multipart/form-data"]["schema"]
assert schema["required"] == ["file"]
assert schema["properties"]["file"]["type"] == "string"
assert schema["properties"]["file"]["format"] == "binary"