kunthawat
2d1be52177
Fixes: 1. media.ts: wrap placeholder generation in try-catch 2. toolbar.ts: check r.ok, display error message in popover
422 lines
13 KiB
TypeScript
422 lines
13 KiB
TypeScript
/**
|
|
* MCP menu tools — comprehensive integration tests.
|
|
*
|
|
* Covers:
|
|
* - menu_list
|
|
* - menu_get
|
|
*
|
|
* Plus regression for bug #15 (no menu mutation tools — gap).
|
|
*/
|
|
|
|
import { Role } from "@emdash-cms/auth";
|
|
import type { Kysely } from "kysely";
|
|
import { ulid } from "ulidx";
|
|
import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
|
|
|
import type { Database } from "../../../src/database/types.js";
|
|
import {
|
|
connectMcpHarness,
|
|
extractJson,
|
|
extractText,
|
|
type McpHarness,
|
|
} from "../../utils/mcp-runtime.js";
|
|
import { setupTestDatabase, teardownTestDatabase } from "../../utils/test-db.js";
|
|
|
|
const ADMIN_ID = "user_admin";
|
|
const SUBSCRIBER_ID = "user_subscriber";
|
|
|
|
async function seedMenu(
|
|
db: Kysely<Database>,
|
|
name: string,
|
|
label: string,
|
|
items: Array<{
|
|
label: string;
|
|
url?: string;
|
|
sort_order?: number;
|
|
parent_id?: string | null;
|
|
}> = [],
|
|
): Promise<string> {
|
|
const menuId = ulid();
|
|
const now = new Date().toISOString();
|
|
await db
|
|
.insertInto("_emdash_menus" as never)
|
|
.values({ id: menuId, name, label, created_at: now, updated_at: now } as never)
|
|
.execute();
|
|
|
|
for (const [i, item] of items.entries()) {
|
|
await db
|
|
.insertInto("_emdash_menu_items" as never)
|
|
.values({
|
|
id: ulid(),
|
|
menu_id: menuId,
|
|
label: item.label,
|
|
custom_url: item.url ?? null,
|
|
type: "custom",
|
|
sort_order: item.sort_order ?? i,
|
|
parent_id: item.parent_id ?? null,
|
|
created_at: now,
|
|
} as never)
|
|
.execute();
|
|
}
|
|
return menuId;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// menu_list
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("menu_list", () => {
|
|
let db: Kysely<Database>;
|
|
let harness: McpHarness;
|
|
|
|
beforeEach(async () => {
|
|
db = await setupTestDatabase();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
if (harness) await harness.cleanup();
|
|
await teardownTestDatabase(db);
|
|
});
|
|
|
|
it("returns empty list when no menus exist", async () => {
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_list",
|
|
arguments: {},
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
const data = extractJson(result);
|
|
expect(Array.isArray(data) ? data : []).toEqual([]);
|
|
});
|
|
|
|
it("lists multiple menus in alphabetical order", async () => {
|
|
await seedMenu(db, "main", "Main Menu");
|
|
await seedMenu(db, "footer", "Footer");
|
|
await seedMenu(db, "sidebar", "Sidebar");
|
|
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_list",
|
|
arguments: {},
|
|
});
|
|
const data = extractJson<Array<{ name: string; label: string }>>(result);
|
|
expect(data.map((m) => m.name)).toEqual(["footer", "main", "sidebar"]);
|
|
});
|
|
|
|
it("itemCount reflects per-menu item count (LEFT JOIN correctness)", async () => {
|
|
// handleMenuList uses a single LEFT JOIN + GROUP BY for the count.
|
|
// A regression to INNER JOIN would drop empty menus; a regression
|
|
// in the count column or join key would silently report wrong
|
|
// numbers per menu. Seed three menus with known, distinct counts.
|
|
await seedMenu(db, "empty", "Empty");
|
|
await seedMenu(db, "single", "Single", [{ label: "Home", url: "/" }]);
|
|
await seedMenu(db, "triple", "Triple", [
|
|
{ label: "Home", url: "/" },
|
|
{ label: "About", url: "/about" },
|
|
{ label: "Blog", url: "/blog" },
|
|
]);
|
|
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
const result = await harness.client.callTool({ name: "menu_list", arguments: {} });
|
|
const data = extractJson<Array<{ name: string; itemCount: number }>>(result);
|
|
|
|
const empty = data.find((m) => m.name === "empty");
|
|
const single = data.find((m) => m.name === "single");
|
|
const triple = data.find((m) => m.name === "triple");
|
|
expect(empty?.itemCount).toBe(0);
|
|
expect(single?.itemCount).toBe(1);
|
|
expect(triple?.itemCount).toBe(3);
|
|
// Empty menu must still be present — guards against an INNER JOIN
|
|
// regression where it would disappear.
|
|
expect(data.map((m) => m.name)).toContain("empty");
|
|
});
|
|
|
|
it("any logged-in user can list menus", async () => {
|
|
await seedMenu(db, "main", "Main");
|
|
harness = await connectMcpHarness({ db, userId: SUBSCRIBER_ID, userRole: Role.SUBSCRIBER });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_list",
|
|
arguments: {},
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// menu_get
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("menu_get", () => {
|
|
let db: Kysely<Database>;
|
|
let harness: McpHarness;
|
|
|
|
beforeEach(async () => {
|
|
db = await setupTestDatabase();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
if (harness) await harness.cleanup();
|
|
await teardownTestDatabase(db);
|
|
});
|
|
|
|
it("returns menu with items in sort order", async () => {
|
|
await seedMenu(db, "main", "Main", [
|
|
{ label: "Home", url: "/", sort_order: 0 },
|
|
{ label: "Blog", url: "/blog", sort_order: 1 },
|
|
{ label: "About", url: "/about", sort_order: 2 },
|
|
]);
|
|
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
const menu = extractJson<{
|
|
name: string;
|
|
items: Array<{ label: string; sort_order: number }>;
|
|
}>(result);
|
|
expect(menu.name).toBe("main");
|
|
expect(menu.items).toHaveLength(3);
|
|
expect(menu.items.map((i) => i.label)).toEqual(["Home", "Blog", "About"]);
|
|
});
|
|
|
|
it("returns NOT_FOUND error for missing menu", async () => {
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "ghost" },
|
|
});
|
|
expect(result.isError).toBe(true);
|
|
expect(extractText(result)).toMatch(/\bNOT_FOUND\b|\bnot found\b/i);
|
|
expect(extractText(result)).toContain("ghost");
|
|
});
|
|
|
|
it("empty menu returns empty items array", async () => {
|
|
await seedMenu(db, "empty", "Empty Menu", []);
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "empty" },
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
const menu = extractJson<{ items: unknown[] }>(result);
|
|
expect(menu.items).toEqual([]);
|
|
});
|
|
|
|
it("any logged-in user can get a menu", async () => {
|
|
await seedMenu(db, "main", "Main", [{ label: "Home", url: "/" }]);
|
|
harness = await connectMcpHarness({ db, userId: SUBSCRIBER_ID, userRole: Role.SUBSCRIBER });
|
|
const result = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Bug #15 / F6 / F12 — happy paths for menu mutation tools.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("menu mutations (bug #15 / F6 / F12)", () => {
|
|
let db: Kysely<Database>;
|
|
let harness: McpHarness;
|
|
|
|
beforeEach(async () => {
|
|
db = await setupTestDatabase();
|
|
harness = await connectMcpHarness({ db, userId: ADMIN_ID, userRole: Role.ADMIN });
|
|
});
|
|
|
|
afterEach(async () => {
|
|
if (harness) await harness.cleanup();
|
|
await teardownTestDatabase(db);
|
|
});
|
|
|
|
it("MCP exposes menu_create, menu_update, menu_set_items, menu_delete", async () => {
|
|
const tools = await harness.client.listTools();
|
|
const names = new Set(tools.tools.map((t) => t.name));
|
|
expect(names.has("menu_create")).toBe(true);
|
|
expect(names.has("menu_update")).toBe(true);
|
|
expect(names.has("menu_set_items")).toBe(true);
|
|
expect(names.has("menu_delete")).toBe(true);
|
|
});
|
|
|
|
it("menu_create + menu_get round-trip", async () => {
|
|
const create = await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Main Menu" },
|
|
});
|
|
expect(create.isError, extractText(create)).toBeFalsy();
|
|
|
|
const get = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
expect(get.isError, extractText(get)).toBeFalsy();
|
|
const menu = extractJson<{ name: string; label: string; items: unknown[] }>(get);
|
|
expect(menu.name).toBe("main");
|
|
expect(menu.label).toBe("Main Menu");
|
|
expect(menu.items).toEqual([]);
|
|
});
|
|
|
|
it("menu_create with a duplicate name returns CONFLICT", async () => {
|
|
await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Main" },
|
|
});
|
|
const dup = await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Other" },
|
|
});
|
|
expect(dup.isError).toBe(true);
|
|
expect(extractText(dup)).toMatch(/CONFLICT|already exists/i);
|
|
});
|
|
|
|
it("menu_update changes the label", async () => {
|
|
await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Original" },
|
|
});
|
|
const update = await harness.client.callTool({
|
|
name: "menu_update",
|
|
arguments: { name: "main", label: "Renamed" },
|
|
});
|
|
expect(update.isError, extractText(update)).toBeFalsy();
|
|
|
|
const get = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
const menu = extractJson<{ label: string }>(get);
|
|
expect(menu.label).toBe("Renamed");
|
|
});
|
|
|
|
it("menu_set_items with empty list clears all items", async () => {
|
|
await seedMenu(db, "main", "Main", [
|
|
{ label: "Home", url: "/" },
|
|
{ label: "Blog", url: "/blog" },
|
|
]);
|
|
|
|
const result = await harness.client.callTool({
|
|
name: "menu_set_items",
|
|
arguments: { name: "main", items: [] },
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
|
|
const get = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
const menu = extractJson<{ items: unknown[] }>(get);
|
|
expect(menu.items).toEqual([]);
|
|
});
|
|
|
|
it("menu_set_items supports 3-level nesting via parentIndex chain", async () => {
|
|
await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Main" },
|
|
});
|
|
|
|
const result = await harness.client.callTool({
|
|
name: "menu_set_items",
|
|
arguments: {
|
|
name: "main",
|
|
items: [
|
|
{ label: "Root", type: "custom", customUrl: "/" },
|
|
{ label: "Child", type: "custom", customUrl: "/child", parentIndex: 0 },
|
|
{ label: "Grandchild", type: "custom", customUrl: "/gc", parentIndex: 1 },
|
|
],
|
|
},
|
|
});
|
|
expect(result.isError, extractText(result)).toBeFalsy();
|
|
|
|
const get = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
const menu = extractJson<{
|
|
items: Array<{ id: string; label: string; parent_id: string | null; sort_order: number }>;
|
|
}>(get);
|
|
expect(menu.items).toHaveLength(3);
|
|
|
|
const byLabel = new Map(menu.items.map((i) => [i.label, i]));
|
|
const root = byLabel.get("Root");
|
|
const child = byLabel.get("Child");
|
|
const grand = byLabel.get("Grandchild");
|
|
expect(root?.parent_id).toBeNull();
|
|
expect(child?.parent_id).toBe(root?.id);
|
|
expect(grand?.parent_id).toBe(child?.id);
|
|
});
|
|
|
|
it("menu_set_items rejects parentIndex >= i (must be earlier)", async () => {
|
|
await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Main" },
|
|
});
|
|
const result = await harness.client.callTool({
|
|
name: "menu_set_items",
|
|
arguments: {
|
|
name: "main",
|
|
items: [
|
|
{ label: "A", type: "custom", customUrl: "/a", parentIndex: 0 }, // self-ref
|
|
],
|
|
},
|
|
});
|
|
expect(result.isError).toBe(true);
|
|
expect(extractText(result)).toMatch(/VALIDATION_ERROR|parentIndex/);
|
|
});
|
|
|
|
it("F6: menu_delete removes both menu and items (D1 cascade safe)", async () => {
|
|
await harness.client.callTool({
|
|
name: "menu_create",
|
|
arguments: { name: "main", label: "Main" },
|
|
});
|
|
await harness.client.callTool({
|
|
name: "menu_set_items",
|
|
arguments: {
|
|
name: "main",
|
|
items: [
|
|
{ label: "A", type: "custom", customUrl: "/a" },
|
|
{ label: "B", type: "custom", customUrl: "/b" },
|
|
{ label: "C", type: "custom", customUrl: "/c" },
|
|
],
|
|
},
|
|
});
|
|
|
|
// Sanity: menu_get sees 3 items.
|
|
const before = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
const menuBefore = extractJson<{
|
|
id: string;
|
|
items: unknown[];
|
|
}>(before);
|
|
expect(menuBefore.items).toHaveLength(3);
|
|
|
|
// Delete.
|
|
const del = await harness.client.callTool({
|
|
name: "menu_delete",
|
|
arguments: { name: "main" },
|
|
});
|
|
expect(del.isError, extractText(del)).toBeFalsy();
|
|
|
|
// Items table is empty for that menu_id.
|
|
const orphans = await db
|
|
.selectFrom("_emdash_menu_items" as never)
|
|
.select(["id" as never])
|
|
.where("menu_id" as never, "=", menuBefore.id as never)
|
|
.execute();
|
|
expect(orphans).toEqual([]);
|
|
|
|
// menu_get returns NOT_FOUND.
|
|
const after = await harness.client.callTool({
|
|
name: "menu_get",
|
|
arguments: { name: "main" },
|
|
});
|
|
expect(after.isError).toBe(true);
|
|
expect(extractText(after)).toMatch(/NOT_FOUND/);
|
|
});
|
|
});
|