⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import { describe, expect, it, vi } from "vite-plus/test";
import { registerTools } from "./register.js";
type RegisteredTool = {
name: string;
config: { inputSchema?: { parse: (args: unknown) => unknown } };
handler: (args: Record<string, unknown>) => Promise<{
content: Array<{ type: string; text: string }>;
isError?: boolean;
}>;
};
function createServerMock() {
const tools = new Map<string, RegisteredTool>();
return {
server: {
registerTool: vi.fn(
(
name: string,
config: RegisteredTool["config"],
handler: RegisteredTool["handler"],
) => {
tools.set(name, { name, config, handler });
},
),
},
tools,
};
}
describe("registerTools", () => {
it("registers the MCP tools", () => {
const { server } = createServerMock();
const client = { json: vi.fn() };
registerTools(server as never, { client: client as never });
expect(server.registerTool).toHaveBeenCalled();
expect(server.registerTool).toHaveBeenCalledWith(
"whoami",
expect.any(Object),
expect.any(Function),
);
expect(server.registerTool).toHaveBeenCalledWith(
"update_task",
expect.any(Object),
expect.any(Function),
);
});
it("uses the API-key current-user endpoint for whoami", async () => {
const { server, tools } = createServerMock();
const client = {
usingApiKey: true,
json: vi.fn().mockResolvedValue({
id: "user-1",
name: "Mohiuddin",
email: "[email protected]",
role: "user",
token: "unexpected-user-secret",
}),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("whoami")?.handler({});
expect(client.json).toHaveBeenCalledWith("/api/user/me", {
method: "GET",
});
expect(result?.isError).toBe(false);
expect(result?.content).toEqual([
{
type: "text",
text: JSON.stringify(
{
id: "user-1",
name: "Mohiuddin",
email: "[email protected]",
role: "user",
},
null,
2,
),
},
]);
});
it.each(["user", null, undefined])(
"returns only safe user fields for whoami with session authentication and role %s",
async (role) => {
const { server, tools } = createServerMock();
const client = {
usingApiKey: false,
json: vi.fn().mockResolvedValue({
user: {
id: "user-1",
name: "Mohiuddin",
email: "[email protected]",
role,
token: "unexpected-user-secret",
},
session: {
id: "session-1",
token: "live-session-secret",
expiresAt: "2026-11-08T00:00:00.000Z",
ipAddress: "192.0.2.1",
userAgent: "MCP client",
},
token: "unexpected-response-secret",
}),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("whoami")?.handler({});
expect(client.json).toHaveBeenCalledWith("/api/auth/get-session", {
method: "GET",
});
expect(result?.isError).toBe(false);
expect(result?.content).toEqual([
{
type: "text",
text: JSON.stringify(
{
id: "user-1",
name: "Mohiuddin",
email: "[email protected]",
role,
},
null,
2,
),
},
]);
},
);
it("returns null for whoami when there is no session", async () => {
const { server, tools } = createServerMock();
const client = {
usingApiKey: false,
json: vi.fn().mockResolvedValue(null),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("whoami")?.handler({});
expect(result).toEqual({
content: [{ type: "text", text: "null" }],
isError: false,
});
});
it("builds the expected query string for list_tasks", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi.fn().mockResolvedValue([{ id: "task-1" }]),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("list_tasks")?.handler({
projectId: "project 1",
status: "open",
page: 2,
relatedPage: 3,
sortOrder: "desc",
});
expect(client.json).toHaveBeenCalledWith(
"/api/task/tasks/project%201?status=open&page=2&relatedPage=3&sortOrder=desc",
{ method: "GET" },
);
expect(result).toEqual({
content: [
{
type: "text",
text: JSON.stringify([{ id: "task-1" }], null, 2),
},
],
isError: false,
});
});
it("gets one task by ticket ID with an optional workspace", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi.fn().mockResolvedValue({ id: "task-1", number: 12 }),
};
registerTools(server as never, { client: client as never });
const tool = tools.get("get_task_by_ticket_id");
expect(tool).toBeDefined();
await tool?.handler({ ticketId: "KAN-12" });
await tool?.handler({ ticketId: "KAN-12", workspaceId: "workspace 1" });
await tool?.handler({ ticketId: "KAN-12", projectId: "project 1" });
expect(client.json).toHaveBeenNthCalledWith(
1,
"/api/task/by-ticket-id/KAN-12",
{ method: "GET" },
);
expect(client.json).toHaveBeenNthCalledWith(
2,
"/api/task/by-ticket-id/KAN-12?workspaceId=workspace+1",
{ method: "GET" },
);
expect(client.json).toHaveBeenNthCalledWith(
3,
"/api/task/by-ticket-id/KAN-12?projectId=project+1",
{ method: "GET" },
);
});
it("fetches the current task and sends a full body for update_task", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi
.fn()
.mockResolvedValueOnce({
title: "Draft spec",
description: "Write docs",
status: "open",
priority: "medium",
projectId: "project-1",
position: 4,
})
.mockResolvedValueOnce({ id: "task-1", status: "done" }),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("update_task")?.handler({
taskId: "task-1",
status: "done",
});
expect(client.json).toHaveBeenNthCalledWith(1, "/api/task/task-1", {
method: "GET",
});
const putCall = client.json.mock.calls[1];
expect(putCall?.[0]).toBe("/api/task/task-1");
const putBody = JSON.parse(
String((putCall?.[1] as { body?: string })?.body ?? "{}"),
);
expect(putBody).toEqual(
expect.objectContaining({
title: "Draft spec",
description: "Write docs",
status: "done",
priority: "medium",
projectId: "project-1",
position: 4,
}),
);
expect(result?.isError).toBe(false);
});
it("fetches the current project and sends a full body for update_project", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi
.fn()
.mockResolvedValueOnce({
name: "Roadmap",
slug: "roadmap",
})
.mockResolvedValueOnce({ id: "project-1", name: "Roadmap v2" }),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("update_project")?.handler({
id: "project-1",
name: "Roadmap v2",
});
expect(client.json).toHaveBeenNthCalledWith(1, "/api/project/project-1", {
method: "GET",
});
const putCall = client.json.mock.calls[1];
expect(putCall?.[0]).toBe("/api/project/project-1");
const putBody = JSON.parse(
String((putCall?.[1] as { body?: string })?.body ?? "{}"),
);
expect(putBody).toEqual({
name: "Roadmap v2",
icon: "Layout",
slug: "roadmap",
description: "",
isPublic: false,
});
expect(result?.isError).toBe(false);
});
it("returns an MCP error result when the client request fails", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi.fn().mockRejectedValue(new Error("boom")),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("whoami")?.handler({});
expect(result).toEqual({
content: [
{
type: "text",
text: JSON.stringify({ error: "boom" }, null, 2),
},
],
isError: true,
});
});
it("validates label colors as hex values", () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn() };
registerTools(server as never, { client: client as never });
const schema = tools.get("create_label")?.config.inputSchema;
expect(schema).toBeDefined();
expect(() =>
schema?.parse({
name: "Bug",
color: "red",
workspaceId: "workspace-1",
}),
).toThrow(/hex color/i);
});
it("validates task date filters as ISO datetimes with timezone", () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn() };
registerTools(server as never, { client: client as never });
const schema = tools.get("list_tasks")?.config.inputSchema;
expect(schema).toBeDefined();
expect(() =>
schema?.parse({
projectId: "project-1",
dueBefore: "2026-04-04",
}),
).toThrow();
});
it("lists a project's custom field definitions", async () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn().mockResolvedValue([]) };
registerTools(server as never, { client: client as never });
await tools
.get("list_project_custom_fields")
?.handler({ projectId: "project 1" });
expect(client.json).toHaveBeenCalledWith(
"/api/custom-field/project/project%201",
);
});
it("reads a task's custom field values", async () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn().mockResolvedValue([]) };
registerTools(server as never, { client: client as never });
await tools
.get("get_task_custom_field_values")
?.handler({ taskId: "task 1" });
expect(client.json).toHaveBeenCalledWith("/api/custom-field/task/task%201");
});
it.each([
[["Frontend", "API"], '["Frontend","API"]'],
[5, "5"],
[true, "true"],
["2026-10-17", "2026-10-17"],
[null, ""],
])("sets custom field value %j as %j", async (value, encoded) => {
const { server, tools } = createServerMock();
const client = { json: vi.fn().mockResolvedValue({ id: "value-1" }) };
registerTools(server as never, { client: client as never });
const result = await tools
.get("set_task_custom_field_value")
?.handler({ taskId: "task-1", fieldId: "field-1", value });
expect(client.json).toHaveBeenCalledWith("/api/custom-field/value", {
method: "PUT",
body: JSON.stringify({
taskId: "task-1",
fieldId: "field-1",
value: encoded,
}),
});
expect(result?.isError).toBe(false);
});
it("rejects a custom field value that is missing or an object", async () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn() };
registerTools(server as never, { client: client as never });
const tool = tools.get("set_task_custom_field_value");
const missing = await tool?.handler({ taskId: "task-1", fieldId: "f" });
const object = await tool?.handler({
taskId: "task-1",
fieldId: "f",
value: { option: "a" },
});
expect(missing?.isError).toBe(true);
expect(object?.isError).toBe(true);
expect(client.json).not.toHaveBeenCalled();
});
it("creates a task relation with the expected body", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi.fn().mockResolvedValue({ id: "rel-1", relationType: "blocks" }),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("create_task_relation")?.handler({
sourceTaskId: "task-1",
targetTaskId: "task-2",
relationType: "blocks",
});
expect(client.json).toHaveBeenCalledWith("/api/task-relation", {
method: "POST",
body: JSON.stringify({
sourceTaskId: "task-1",
targetTaskId: "task-2",
relationType: "blocks",
}),
});
expect(result?.isError).toBe(false);
});
it("validates relationType for create_task_relation", () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn() };
registerTools(server as never, { client: client as never });
const schema = tools.get("create_task_relation")?.config.inputSchema;
expect(schema).toBeDefined();
expect(() =>
schema?.parse({
sourceTaskId: "task-1",
targetTaskId: "task-2",
relationType: "duplicate",
}),
).toThrow();
});
it("gets task relations by task id", async () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn().mockResolvedValue([]) };
registerTools(server as never, { client: client as never });
await tools.get("get_task_relations")?.handler({ taskId: "task 1" });
expect(client.json).toHaveBeenCalledWith("/api/task-relation/task%201", {
method: "GET",
});
});
it("deletes a task relation by id", async () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn().mockResolvedValue({}) };
registerTools(server as never, { client: client as never });
await tools.get("delete_task_relation")?.handler({ id: "rel-1" });
expect(client.json).toHaveBeenCalledWith("/api/task-relation/rel-1", {
method: "DELETE",
});
});
it("deletes a task-associated label without an obsolete preflight", async () => {
const { server, tools } = createServerMock();
const client = { json: vi.fn().mockResolvedValue({ id: "label-1" }) };
registerTools(server as never, { client: client as never });
const result = await tools.get("delete_label")?.handler({ id: "label-1" });
expect(client.json).toHaveBeenCalledExactlyOnceWith("/api/label/label-1", {
method: "DELETE",
signal: expect.any(AbortSignal),
});
expect(result?.isError).toBe(false);
});
it("resumes workspace label deletion until the API completes it", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi
.fn()
.mockResolvedValueOnce({
id: "label-1",
taskId: null,
pendingDeletion: true,
})
.mockResolvedValueOnce({ id: "label-1", taskId: null }),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("delete_label")?.handler({ id: "label-1" });
expect(result?.isError).toBe(false);
expect(client.json).toHaveBeenCalledTimes(2);
expect(client.json).toHaveBeenNthCalledWith(2, "/api/label/label-1", {
method: "DELETE",
signal: expect.any(AbortSignal),
});
});
it("returns saved progress when the overall deletion deadline expires", async () => {
const { server, tools } = createServerMock();
const controller = new AbortController();
const timeout = vi
.spyOn(AbortSignal, "timeout")
.mockReturnValue(controller.signal);
const progress = { id: "large", pendingDeletion: true };
const client = {
json: vi
.fn()
.mockResolvedValueOnce(progress)
.mockImplementationOnce(async () => {
controller.abort();
throw new DOMException("Timed out", "TimeoutError");
}),
};
try {
registerTools(server as never, { client: client as never });
const result = await tools.get("delete_label")?.handler({ id: "large" });
expect(timeout).toHaveBeenCalledWith(10_000);
expect(result?.isError).toBe(false);
expect(client.json).toHaveBeenCalledTimes(2);
expect(client.json).toHaveBeenLastCalledWith("/api/label/large", {
method: "DELETE",
signal: controller.signal,
});
expect(result?.content).toEqual([
expect.objectContaining({
text: expect.stringContaining('"pendingDeletion": true'),
}),
]);
} finally {
timeout.mockRestore();
}
});
it("returns resumable progress when a cascade exceeds one tool call", async () => {
const { server, tools } = createServerMock();
const client = {
json: vi.fn().mockResolvedValue({ pendingDeletion: true }),
};
registerTools(server as never, { client: client as never });
const result = await tools.get("delete_label")?.handler({ id: "large" });
expect(result?.isError).toBe(false);
expect(client.json).toHaveBeenCalledTimes(100);
expect(result?.content).toEqual([
expect.objectContaining({
text: expect.stringContaining('"pendingDeletion": true'),
}),
]);
});
});