@canonical/pragma-cli 0.18.0

package/src/testing/integration/parity.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Layer 3: CLI/MCP parity tests.
+ *
+ * Each test calls the same query through both the operation layer
+ * (what CLI uses) and the MCP tool (what agents use), then asserts
+ * data equality.
+ */
+
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { listFormatters as blockListFmt } from "../../domains/block/formatters/index.js";
+import {
+  listBlocks,
+  lookupBlock,
+} from "../../domains/block/operations/index.js";
+import {
+  listModifiers,
+  lookupModifier,
+} from "../../domains/modifier/operations/index.js";
+import { listOntologies } from "../../domains/ontology/operations/index.js";
+import type { PragmaRuntime } from "../../domains/shared/runtime.js";
+import { listStandards } from "../../domains/standard/operations/index.js";
+import { listTiers } from "../../domains/tier/operations/index.js";
+import {
+  listTokens,
+  lookupToken,
+} from "../../domains/token/operations/index.js";
+import assertParity from "../helpers/assertParity.js";
+import createTestMcpClient from "../helpers/createTestMcpClient.js";
+import createTestRuntime from "../helpers/createTestRuntime.js";
+
+let rt: PragmaRuntime;
+let client: Client;
+let cleanup: () => Promise<void>;
+
+beforeAll(async () => {
+  rt = await createTestRuntime();
+  const mcp = await createTestMcpClient(rt);
+  client = mcp.client;
+  cleanup = mcp.cleanup;
+});
+
+afterAll(async () => {
+  await cleanup();
+  rt.dispose();
+});
+
+// ---------------------------------------------------------------------------
+// Block parity
+// ---------------------------------------------------------------------------
+
+describe("block parity", () => {
+  it("block_list: operation matches MCP data", async () => {
+    const opResult = await listBlocks(rt.store, rt.config);
+    const mcpRes = await client.callTool({
+      name: "block_list",
+      arguments: {},
+    });
+    assertParity(opResult, mcpRes);
+  });
+
+  it("block_list condensed: matches llm formatter", async () => {
+    const opResult = await listBlocks(rt.store, rt.config);
+    const expectedText = blockListFmt.llm(opResult);
+
+    const mcpRes = await client.callTool({
+      name: "block_list",
+      arguments: { condensed: true },
+    });
+    const content = mcpRes.content as unknown[];
+    const first = content[0] as { text: string };
+    const body = JSON.parse(first.text) as { text: string };
+    expect(body.text).toBe(expectedText);
+  });
+
+  it("block_lookup: detailed fields match", async () => {
+    const opResult = await lookupBlock(rt.store, "Button", rt.config);
+    const mcpRes = await client.callTool({
+      name: "block_lookup",
+      arguments: { names: ["Button"] },
+    });
+    const content = mcpRes.content as unknown[];
+    const first = content[0] as { text: string };
+    const body = JSON.parse(first.text) as {
+      data: { results: unknown[] };
+    };
+    expect(body.data.results[0]).toEqual(opResult);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Standard parity
+// ---------------------------------------------------------------------------
+
+describe("standard parity", () => {
+  it("standard_list: count and names match", async () => {
+    const opResult = await listStandards(rt.store);
+    const mcpRes = await client.callTool({
+      name: "standard_list",
+      arguments: {},
+    });
+    assertParity(opResult, mcpRes);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tier parity
+// ---------------------------------------------------------------------------
+
+describe("tier parity", () => {
+  it("tier_list: paths and depths match", async () => {
+    const opResult = await listTiers(rt.store);
+    const mcpRes = await client.callTool({
+      name: "tier_list",
+      arguments: {},
+    });
+    assertParity(opResult, mcpRes);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Modifier parity
+// ---------------------------------------------------------------------------
+
+describe("modifier parity", () => {
+  it("modifier_list: families match", async () => {
+    const opResult = await listModifiers(rt.store);
+    const mcpRes = await client.callTool({
+      name: "modifier_list",
+      arguments: {},
+    });
+    assertParity(opResult, mcpRes);
+  });
+
+  it("modifier_lookup: values match", async () => {
+    const opResult = await lookupModifier(rt.store, "importance");
+    const mcpRes = await client.callTool({
+      name: "modifier_lookup",
+      arguments: { names: ["importance"] },
+    });
+    const content = mcpRes.content as unknown[];
+    const first = content[0] as { text: string };
+    const body = JSON.parse(first.text) as {
+      data: { results: unknown[] };
+    };
+    expect(body.data.results[0]).toEqual(opResult);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Token parity
+// ---------------------------------------------------------------------------
+
+describe("token parity", () => {
+  it("token_list: count matches", async () => {
+    const opResult = await listTokens(rt.store);
+    const mcpRes = await client.callTool({
+      name: "token_list",
+      arguments: {},
+    });
+    assertParity(opResult, mcpRes);
+  });
+
+  it("token_lookup: values match", async () => {
+    const opResult = await lookupToken(rt.store, "color.primary");
+    const mcpRes = await client.callTool({
+      name: "token_lookup",
+      arguments: { names: ["color.primary"] },
+    });
+    const content = mcpRes.content as unknown[];
+    const first = content[0] as { text: string };
+    const body = JSON.parse(first.text) as {
+      data: { results: unknown[] };
+    };
+    expect(body.data.results[0]).toEqual(opResult);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Ontology parity
+// ---------------------------------------------------------------------------
+
+describe("ontology parity", () => {
+  it("ontology_list: count matches", async () => {
+    const opResult = await listOntologies(rt.store);
+    const mcpRes = await client.callTool({
+      name: "ontology_list",
+      arguments: {},
+    });
+    assertParity(opResult, mcpRes);
+  });
+});

package/src/testing/store.ts

@@ -0,0 +1,39 @@
+/**
+ * Test store bridge — createTestStore, PragmaTestStoreOptions.
+ *
+ * Wraps `@canonical/ke/testing` with pragma's default prefix map
+ * pre-configured so test authors do not need to repeat PREFIX_MAP.
+ */
+
+import type { TestStoreOptions, TestStoreResult } from "@canonical/ke/testing";
+import { createTestStore as keCreateTestStore } from "@canonical/ke/testing";
+import { PREFIX_MAP } from "../domains/shared/prefixes.js";
+
+/** Options for creating a test store, with pragma prefixes pre-applied. */
+interface PragmaTestStoreOptions extends Omit<TestStoreOptions, "prefixes"> {
+  prefixes?: TestStoreOptions["prefixes"];
+}
+
+/**
+ * Create a test ke store with pragma's default prefix map.
+ *
+ * @param options - Optional overrides; additional prefixes are merged
+ *   on top of the default PREFIX_MAP.
+ * @returns The test store result from ke/testing.
+ *
+ * @note Impure
+ */
+async function createTestStore(
+  options: PragmaTestStoreOptions = {},
+): Promise<TestStoreResult> {
+  return keCreateTestStore({
+    ...options,
+    prefixes: {
+      ...PREFIX_MAP,
+      ...options.prefixes,
+    },
+  });
+}
+
+export { createTestStore };
+export type { PragmaTestStoreOptions };

package/src/testing/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Testing type definitions.
+ *
+ * Shared types for the MCP test client and other test infrastructure.
+ */
+
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+/**
+ * Return value from {@link createTestMcpClient}.
+ *
+ * The caller must invoke `cleanup` when done to close
+ * both the client and server transports.
+ */
+export interface TestMcpClientResult {
+  /** The connected MCP client instance. */
+  client: Client;
+  /** Closes the client and server transports. */
+  cleanup: () => Promise<void>;
+}