@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/testing/integration/edge-cases.test.ts

@@ -1,263 +0,0 @@
-/**
- * Layer 3b: Edge-case and error-path tests.
- *
- * Covers error conditions that are not exercised by the happy-path
- * parity tests or the basic MCP surface tests: unknown prefixes,
- * all-fail batches, empty result sets, and condensed-mode error
- * rendering.
- */
-
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import type { PragmaRuntime } from "../../domains/shared/runtime.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();
-});
-
-/** Parse MCP response envelope. */
-function parseEnvelope(
-  mcpResponse: Record<string, unknown>,
-): Record<string, unknown> {
-  const content = mcpResponse.content as unknown[];
-  const first = content[0] as { text: string };
-  return JSON.parse(first.text) as Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// Unknown prefix IRI resolution
-// ---------------------------------------------------------------------------
-
-describe("IRI resolution edge cases", () => {
-  it("block_lookup with unknown prefix returns error", async () => {
-    const res = await client.callTool({
-      name: "block_lookup",
-      arguments: { names: ["zz:nonexistent.block"] },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const data = body.data as { results: unknown[]; errors: unknown[] };
-    expect(data.results).toHaveLength(0);
-    expect(data.errors).toHaveLength(1);
-  });
-
-  it("standard_lookup with unknown prefix returns error", async () => {
-    const res = await client.callTool({
-      name: "standard_lookup",
-      arguments: { names: ["zz:nonexistent.standard"] },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const data = body.data as { results: unknown[]; errors: unknown[] };
-    expect(data.results).toHaveLength(0);
-    expect(data.errors).toHaveLength(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// All-fail batch lookups
-// ---------------------------------------------------------------------------
-
-describe("all-fail batch lookups", () => {
-  it("block_lookup: all names unknown → empty results, all errors", async () => {
-    const res = await client.callTool({
-      name: "block_lookup",
-      arguments: { names: ["Unknown1", "Unknown2", "Unknown3"] },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const data = body.data as {
-      results: unknown[];
-      errors: { query: string; code: string }[];
-    };
-    expect(data.results).toHaveLength(0);
-    expect(data.errors).toHaveLength(3);
-    for (const err of data.errors) {
-      expect(err.code).toBe("ENTITY_NOT_FOUND");
-    }
-  });
-
-  it("standard_lookup: all names unknown → empty results, all errors", async () => {
-    const res = await client.callTool({
-      name: "standard_lookup",
-      arguments: { names: ["no/such/standard", "also/missing"] },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const data = body.data as {
-      results: unknown[];
-      errors: { query: string }[];
-    };
-    expect(data.results).toHaveLength(0);
-    expect(data.errors).toHaveLength(2);
-  });
-
-  it("modifier_lookup: unknown family → error", async () => {
-    const res = await client.callTool({
-      name: "modifier_lookup",
-      arguments: { names: ["nonexistent_family"] },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const data = body.data as {
-      results: unknown[];
-      errors: { query: string; code: string }[];
-    };
-    expect(data.results).toHaveLength(0);
-    expect(data.errors).toHaveLength(1);
-    expect(data.errors[0]?.code).toBe("ENTITY_NOT_FOUND");
-  });
-
-  it("token_lookup: unknown token → error", async () => {
-    const res = await client.callTool({
-      name: "token_lookup",
-      arguments: { names: ["color.nonexistent"] },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const data = body.data as {
-      results: unknown[];
-      errors: { query: string; code: string }[];
-    };
-    expect(data.results).toHaveLength(0);
-    expect(data.errors).toHaveLength(1);
-    expect(data.errors[0]?.code).toBe("ENTITY_NOT_FOUND");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Empty result sets (filtered lists)
-// ---------------------------------------------------------------------------
-
-describe("empty result sets", () => {
-  it("standard_list with nonexistent category → error envelope", async () => {
-    const res = await client.callTool({
-      name: "standard_list",
-      arguments: { category: "nonexistent_category" },
-    });
-    const body = parseEnvelope(res);
-    // resolveStandardList throws when no results found
-    expect(body.ok).toBe(false);
-    const error = body.error as { code: string };
-    expect(error.code).toBeDefined();
-  });
-
-  it("token_list with nonexistent category → empty or error", async () => {
-    const res = await client.callTool({
-      name: "token_list",
-      arguments: { category: "NonexistentType" },
-    });
-    const body = parseEnvelope(res);
-    if (body.ok) {
-      const data = body.data as unknown[];
-      expect(data).toHaveLength(0);
-    } else {
-      // Token list may throw on empty results
-      const error = body.error as { code: string };
-      expect(error.code).toBeDefined();
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ontology_show with unknown prefix
-// ---------------------------------------------------------------------------
-
-describe("ontology_show edge cases", () => {
-  it("unknown prefix → error envelope", async () => {
-    const res = await client.callTool({
-      name: "ontology_show",
-      arguments: { prefix: "zzz" },
-    });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(false);
-    const error = body.error as { code: string };
-    expect(error.code).toBeDefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Condensed mode with errors
-// ---------------------------------------------------------------------------
-
-describe("condensed mode error rendering", () => {
-  it("block_lookup condensed: includes error section for unknown blocks", async () => {
-    const res = await client.callTool({
-      name: "block_lookup",
-      arguments: {
-        names: ["Button", "Nonexistent"],
-        condensed: true,
-      },
-    });
-    const body = parseEnvelope(res);
-    expect(body.condensed).toBe(true);
-    const text = body.text as string;
-    // Should contain the successful block
-    expect(text).toContain("Button");
-    // Should contain the errors section
-    expect(text).toContain("Errors");
-    expect(text).toContain("Nonexistent");
-  });
-
-  it("standard_lookup condensed: includes error section for unknown standards", async () => {
-    const res = await client.callTool({
-      name: "standard_lookup",
-      arguments: {
-        names: ["react/component/folder-structure", "no/such/standard"],
-        condensed: true,
-      },
-    });
-    const body = parseEnvelope(res);
-    expect(body.condensed).toBe(true);
-    const text = body.text as string;
-    expect(text).toContain("folder-structure");
-    expect(text).toContain("Errors");
-    expect(text).toContain("no/such/standard");
-  });
-
-  it("modifier_lookup condensed: includes error for unknown family", async () => {
-    const res = await client.callTool({
-      name: "modifier_lookup",
-      arguments: {
-        names: ["importance", "nonexistent"],
-        condensed: true,
-      },
-    });
-    const body = parseEnvelope(res);
-    expect(body.condensed).toBe(true);
-    const text = body.text as string;
-    expect(text).toContain("importance");
-    expect(text).toContain("Errors");
-    expect(text).toContain("nonexistent");
-  });
-
-  it("token_lookup condensed: includes error for unknown token", async () => {
-    const res = await client.callTool({
-      name: "token_lookup",
-      arguments: {
-        names: ["color.primary", "color.nonexistent"],
-        condensed: true,
-      },
-    });
-    const body = parseEnvelope(res);
-    expect(body.condensed).toBe(true);
-    const text = body.text as string;
-    expect(text).toContain("color.primary");
-    expect(text).toContain("Errors");
-    expect(text).toContain("color.nonexistent");
-  });
-});

package/src/testing/integration/executor-execution.test.ts

@@ -1,101 +0,0 @@
-/**
- * End-to-end characterization of the real-execution path the executor merge
- * (4a) rewired: every generator the CLI actually dispatches, and a real setup
- * task, run through the shared UI-free core ({@link runGeneratorTask}) and
- * produce their files on disk.
- *
- * The golden snapshots (executor-golden.test.ts) lock the *preview* modes
- * (dry-run/json/llm), which never execute. This locks the *real* run: the
- * merged core executes the genuine task trees — not test doubles — with the
- * correct working-directory semantics.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  rmSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { runGeneratorTask } from "@canonical/cli-core";
-import { generators as packageGenerators } from "@canonical/summon-package";
-import type { Task } from "@canonical/task";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { COMPONENT_GENERATORS } from "../../domains/create/generators.js";
-import setupMcp from "../../domains/setup/operations/setupMcp.js";
-
-interface Case {
-  readonly name: string;
-  readonly build: () => Task<unknown>;
-}
-
-const componentParams = { componentPath: "src/components/Button" };
-const packageParams = { name: "@canonical/example", type: "library" };
-
-const cases: Case[] = [
-  {
-    name: "component/react",
-    build: () => COMPONENT_GENERATORS.react.generate(componentParams),
-  },
-  {
-    name: "component/svelte",
-    build: () => COMPONENT_GENERATORS.svelte.generate(componentParams),
-  },
-  {
-    name: "component/lit",
-    build: () => COMPONENT_GENERATORS.lit.generate(componentParams),
-  },
-  {
-    name: "package/library",
-    build: () => packageGenerators.package.generate(packageParams),
-  },
-];
-
-const countFiles = (root: string): number => {
-  let total = 0;
-  for (const entry of readdirSync(root, { withFileTypes: true })) {
-    total += entry.isDirectory() ? countFiles(join(root, entry.name)) : 1;
-  }
-  return total;
-};
-
-describe("shared executor — real execution over the dispatched tasks", () => {
-  let dir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    originalCwd = process.cwd();
-    dir = mkdtempSync(join(tmpdir(), "executor-execution-"));
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  for (const testCase of cases) {
-    it(`${testCase.name} — executes for real in the target cwd`, async () => {
-      const targetDir = join(dir, "target");
-      mkdirSync(targetDir);
-
-      await runGeneratorTask(testCase.build(), { cwd: targetDir });
-
-      expect(countFiles(targetDir)).toBeGreaterThan(0);
-      expect(process.cwd()).toBe(originalCwd);
-    });
-  }
-
-  // A real setup task on the rewired production surface. setupMcp in force
-  // mode writes root-relative config (no prompts, no home-dir writes), so it
-  // is safe to execute in a sandbox.
-  it("setup/mcp (force) — writes the harness config for real", async () => {
-    const root = join(dir, "project");
-    mkdirSync(root);
-
-    await runGeneratorTask(setupMcp(root, "cursor"));
-
-    expect(existsSync(join(root, ".cursor", "mcp.json"))).toBe(true);
-  });
-});

package/src/testing/integration/executor-golden.test.ts

@@ -1,145 +0,0 @@
-/**
- * Characterization (golden) snapshots of the two current executors —
- * `executeGenerator` (cli-core, drives `pragma create`) and `runSetupTask`
- * (drives `pragma setup`) — across the real generators and setup tasks.
- *
- * These lock the *observable output* of each executor for representative,
- * fully-answered inputs in every non-interactive mode. Both executors now run
- * real execution through the shared UI-free core (`runGeneratorTask`), and the
- * merged path must keep reproducing these byte-for-byte; the execution
- * characterization test alongside asserts the real-run path. Interactive
- * behavior is characterized separately, since it runs through the injected
- * `promptHandler` seam.
- */
-
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { CommandContext, CommandResult } from "@canonical/cli-core";
-import { executeGenerator } from "@canonical/cli-core";
-import { generators as packageGenerators } from "@canonical/summon-package";
-import { describe, expect, it } from "vitest";
-import { COMPONENT_GENERATORS } from "../../domains/create/generators.js";
-import runSetupTask from "../../domains/setup/helpers/runSetupTask.js";
-import setupCompletions from "../../domains/setup/operations/setupCompletions.js";
-import setupLsp from "../../domains/setup/operations/setupLsp.js";
-
-const ROOT = "/tmp/characterization-project";
-
-const ctx = (format: "text" | "json", llm = false): CommandContext => ({
-  cwd: ROOT,
-  globalFlags: { llm, format, verbose: false },
-});
-
-/**
- * Render an executor result to the plain string a user would see, with
- * environment-specific bytes normalised so a committed baseline compares
- * equal on every machine and in CI: ANSI color codes are stripped (chalk
- * enables them under nx's FORCE_COLOR in CI but not in a plain local run),
- * then the repo checkout root (package-generator plans embed absolute
- * template source paths) and the home directory (shell-completion install
- * targets embed `$HOME`) become stable tokens. The repo root is replaced
- * first — on a dev machine it usually lives under `$HOME`.
- */
-const plain = (result: CommandResult): string => {
-  let text =
-    result.tag === "output"
-      ? result.render.plain(result.value)
-      : `[${result.tag}]`;
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: matching the ANSI escape byte is the point
-  text = text.replace(/\u001b\[[0-9;]*m/g, "");
-  const repoRoot = resolve(
-    dirname(fileURLToPath(import.meta.url)),
-    "../../../../../..",
-  );
-  text = text.split(repoRoot).join("<repo>");
-  const home = process.env.HOME ?? "";
-  return home === "" ? text : text.split(home).join("<home>");
-};
-
-// =============================================================================
-// create — executeGenerator across the real component + package generators
-// =============================================================================
-
-const componentParams = { componentPath: "src/components/Button" };
-const packageParams = { name: "@canonical/example", type: "library" };
-
-describe("golden: executeGenerator — components", () => {
-  for (const framework of ["react", "svelte", "lit"] as const) {
-    const gen = COMPONENT_GENERATORS[framework];
-
-    it(`${framework} — dry-run plan`, async () => {
-      const result = await executeGenerator(
-        gen,
-        { ...componentParams, dryRun: true },
-        ctx("text"),
-      );
-      expect(plain(result)).toMatchSnapshot();
-    });
-
-    it(`${framework} — json plan`, async () => {
-      const result = await executeGenerator(
-        gen,
-        { ...componentParams },
-        ctx("json"),
-      );
-      expect(plain(result)).toMatchSnapshot();
-    });
-
-    it(`${framework} — llm plan`, async () => {
-      const result = await executeGenerator(
-        gen,
-        { ...componentParams },
-        ctx("text", true),
-      );
-      expect(plain(result)).toMatchSnapshot();
-    });
-  }
-});
-
-describe("golden: executeGenerator — package", () => {
-  const gen = packageGenerators.package;
-
-  it("library — dry-run plan", async () => {
-    const result = await executeGenerator(
-      gen,
-      { ...packageParams, dryRun: true },
-      ctx("text"),
-    );
-    expect(plain(result)).toMatchSnapshot();
-  });
-
-  it("library — json plan", async () => {
-    const result = await executeGenerator(
-      gen,
-      { ...packageParams },
-      ctx("json"),
-    );
-    expect(plain(result)).toMatchSnapshot();
-  });
-});
-
-// =============================================================================
-// setup — runSetupTask across representative deterministic setup tasks
-// =============================================================================
-
-describe("golden: runSetupTask — setups", () => {
-  it("lsp — dry-run", async () => {
-    const result = await runSetupTask(setupLsp(ROOT), { dryRun: true });
-    expect(plain(result)).toMatchSnapshot();
-  });
-
-  it("completions (bash) — dry-run", async () => {
-    const result = await runSetupTask(setupCompletions("bash"), {
-      dryRun: true,
-    });
-    expect(plain(result)).toMatchSnapshot();
-  });
-
-  it("lsp — dry-run json", async () => {
-    const result = await runSetupTask(setupLsp(ROOT), {
-      dryRun: true,
-      format: "json",
-    });
-    expect(plain(result)).toMatchSnapshot();
-  });
-});