@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/packages/vite-plugin/tests/output-collision.test.ts

@@ -0,0 +1,329 @@
+/**
+ * Two `.did` files that name the same module collide, and whether `Ledger.did`
+ * and `ledger.did` do depends on the filesystem of the output directory: they
+ * are one file on macOS and Windows by default, and two on Linux.
+ *
+ * The comparison is tested with the answer of the filesystem injected, so that
+ * what it decides does not depend on the machine the tests run on. The probe
+ * that gives the answer is checked against what the machine does, and the
+ * plugin against the probe.
+ */
+import { spawnSync } from "node:child_process"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import {
+  foldsCase,
+  generate,
+  outputsOf,
+  resolveCliBin,
+} from "../src/generate.js"
+import {
+  createApp,
+  PING_DID,
+  removeDirectory,
+  runBuild,
+  type App,
+} from "./support.js"
+
+const apps: App[] = []
+const directories: string[] = []
+
+afterEach(() => {
+  for (const app of apps.splice(0)) app.cleanup()
+  for (const directory of directories.splice(0)) removeDirectory(directory)
+})
+
+/**
+ * An app with the stand-in CLI and three `.did` files, and what `generate`
+ * needs of it. They are in directories of their own, so that they are three
+ * files on every filesystem: it is the modules that may collide.
+ */
+function setup() {
+  const app = createApp(
+    {
+      "one/Ledger.did": "ok\n",
+      "two/ledger.did": "ok\n",
+      "three/Ledger.did": "ok\n",
+    },
+    "fake"
+  )
+  apps.push(app)
+  const at = (file: string) => path.join(app.root, file)
+  return {
+    app,
+    at,
+    request: {
+      cli: resolveCliBin(app.root),
+      root: app.root,
+      timeoutMs: 10_000,
+    },
+  }
+}
+
+describe("canisters whose modules differ only in case", () => {
+  it("collide where the output directory ignores case, and the second is refused", async () => {
+    const { app, at, request } = setup()
+
+    const { outcomes } = await generate({
+      ...request,
+      foldsCase: () => true,
+      canisters: [
+        { name: "upper", didFile: at("one/Ledger.did"), outDir: at("out") },
+        { name: "lower", didFile: at("two/ledger.did"), outDir: at("out") },
+      ],
+    })
+
+    expect(outcomes).toEqual([
+      {
+        names: ["lower"],
+        status: "failed",
+        omitted: [],
+        failure:
+          'would write out/ledger.ts, which "upper" already writes as out/Ledger.ts: the filesystem does not tell the two names apart. ' +
+          "The generator names a module after its .did file: rename one file or give one canister its own outDir",
+      },
+      expect.objectContaining({ names: ["upper"], status: "written" }),
+    ])
+    // The generator was given the first only.
+    expect(app.runs()).toEqual([
+      ["gen", at("one/Ledger.did"), "-o", at("out"), "--json"],
+    ])
+  })
+
+  it("write two modules where the output directory tells them apart", async () => {
+    const { app, at, request } = setup()
+
+    const { outcomes } = await generate({
+      ...request,
+      foldsCase: () => false,
+      canisters: [
+        { name: "upper", didFile: at("one/Ledger.did"), outDir: at("out") },
+        { name: "lower", didFile: at("two/ledger.did"), outDir: at("out") },
+      ],
+    })
+
+    expect(outcomes.map(({ names, status }) => ({ names, status }))).toEqual([
+      { names: ["upper"], status: "written" },
+      { names: ["lower"], status: "written" },
+    ])
+    expect(outcomes.map(({ module }) => module)).toEqual([
+      at("out/Ledger.ts"),
+      at("out/ledger.ts"),
+    ])
+    expect(app.runs()).toEqual([
+      [
+        "gen",
+        at("one/Ledger.did"),
+        at("two/ledger.did"),
+        "-o",
+        at("out"),
+        "--json",
+      ],
+    ])
+  })
+
+  // A filesystem that cannot be told is compared exactly: a canister is never
+  // refused on a guess.
+  it("are taken for two files when the filesystem cannot be told", async () => {
+    const { at, request } = setup()
+
+    const { outcomes } = await generate({
+      ...request,
+      foldsCase: () => undefined,
+      canisters: [
+        { name: "upper", didFile: at("one/Ledger.did"), outDir: at("out") },
+        { name: "lower", didFile: at("two/ledger.did"), outDir: at("out") },
+      ],
+    })
+
+    expect(outcomes.map(({ status }) => status)).toEqual(["written", "written"])
+  })
+
+  it("ask each output directory once, and decide each by its own answer", async () => {
+    const { at, request } = setup()
+    const asked = vi.fn((dir: string) => dir.endsWith("folded"))
+
+    const { outcomes } = await generate({
+      ...request,
+      foldsCase: asked,
+      canisters: [
+        { name: "a", didFile: at("one/Ledger.did"), outDir: at("plain") },
+        { name: "b", didFile: at("two/ledger.did"), outDir: at("plain") },
+        { name: "c", didFile: at("one/Ledger.did"), outDir: at("folded") },
+        { name: "d", didFile: at("two/ledger.did"), outDir: at("folded") },
+      ],
+    })
+
+    expect(asked.mock.calls.map(([dir]) => dir)).toEqual([
+      at("plain"),
+      at("folded"),
+    ])
+    // Told apart in `plain`, and one module in `folded`.
+    expect(
+      outcomes.map(({ names, status }) => `${names.join()} ${status}`).sort()
+    ).toEqual(["a written", "b written", "c written", "d failed"])
+  })
+
+  it("are refused as before when the name is exactly the same, whatever the filesystem says", async () => {
+    const { at, request } = setup()
+
+    const { outcomes } = await generate({
+      ...request,
+      foldsCase: () => false,
+      canisters: [
+        { name: "one", didFile: at("one/Ledger.did"), outDir: at("out") },
+        { name: "three", didFile: at("three/Ledger.did"), outDir: at("out") },
+      ],
+    })
+
+    expect(outcomes[0]).toMatchObject({
+      names: ["three"],
+      status: "failed",
+      failure: expect.stringContaining(
+        'would write out/Ledger.ts, which "one" already writes. '
+      ),
+    })
+  })
+})
+
+describe("the probe of the filesystem", () => {
+  const directory = () => {
+    const made = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), "ic-reactor-case-"))
+    )
+    directories.push(made)
+    return made
+  }
+
+  /** What the machine does: whether a name is found by another spelling of its case. */
+  const observe = (made: string) => {
+    fs.writeFileSync(path.join(made, "Probe.txt"), "")
+    return fs.existsSync(path.join(made, "pROBE.TXT"))
+  }
+
+  it("agrees with the machine for a directory that has files", () => {
+    const made = directory()
+    const expected = observe(made)
+
+    expect(foldsCase(made)).toBe(expected)
+  })
+
+  it("agrees with the machine for a directory with nothing in it, and for one not made yet", () => {
+    const made = directory()
+    const expected = observe(made)
+    const empty = path.join(made, "empty")
+    fs.mkdirSync(empty)
+
+    expect(foldsCase(empty)).toBe(expected)
+    expect(foldsCase(path.join(made, "not", "made", "yet"))).toBe(expected)
+  })
+
+  it("does not throw for a path it cannot read", () => {
+    const made = directory()
+    const file = path.join(made, "file.txt")
+    fs.writeFileSync(file, "")
+
+    expect(["boolean", "undefined"]).toContain(
+      typeof foldsCase(path.join(file, "below"))
+    )
+  })
+
+  // The plugin asks the probe, and does not decide for itself.
+  it("decides what the plugin generates", async () => {
+    const { app } = setup()
+    const expected = observe(app.root)
+    const { result, lines } = runBuild(app.root, {
+      failOnError: false,
+      canisters: {
+        upper: { didFile: "one/Ledger.did" },
+        lower: { didFile: "two/ledger.did" },
+      },
+    })
+    await result
+
+    const refused = lines.some((line) =>
+      line.includes("the filesystem does not tell the two names apart")
+    )
+    expect(refused).toBe(expected)
+  })
+})
+
+// The plugin names the files the generator writes by one rule, `outputsOf`:
+// the modules canisters would write, and the files a run puts back. It is the
+// CLI's own, and the CLI reports what it names, even for a file it fails.
+describe("the files the generator writes for a .did", () => {
+  it("are named as meant gen names them, whatever the file's name", () => {
+    const names = [
+      "api.did",
+      "api.v2.did",
+      "api.did.did",
+      ".did",
+      "..did",
+      "api.candid",
+      "api.DID",
+      "api",
+    ]
+    const app = createApp(
+      Object.fromEntries(
+        names.map((name, index) => [`in${index}/${name}`, PING_DID])
+      ),
+      "real"
+    )
+    apps.push(app)
+    const cli = resolveCliBin(app.root)
+
+    // What the CLI reports and writes for each, beside what the plugin names.
+    const runs = names.map((name, index) => {
+      const didFile = path.join(app.root, `in${index}`, name)
+      const outDir = path.join(app.root, `out${index}`)
+      const run = spawnSync(
+        process.execPath,
+        [cli, "gen", didFile, "-o", outDir, "--json"],
+        { cwd: app.root, encoding: "utf-8" }
+      )
+      const [entry] = (
+        JSON.parse(run.stdout) as {
+          entries: Array<{ status: string; module: string; envelope: string }>
+        }
+      ).entries
+      const written = fs.existsSync(outDir) ? fs.readdirSync(outDir) : []
+      return { name, didFile, outDir, entry, written: written.sort() }
+    })
+    expect(
+      runs.map(({ name, didFile, outDir }) => {
+        const { module, envelope } = outputsOf({ didFile, outDir })
+        return { name, module, envelope }
+      })
+    ).toEqual(
+      runs.map(({ name, entry }) => ({
+        name,
+        module: entry.module,
+        envelope: entry.envelope,
+      }))
+    )
+    // Written where it is named, or nothing written at all.
+    for (const { entry, written } of runs) {
+      expect(written).toEqual(
+        entry.status === "written"
+          ? [path.basename(entry.envelope), path.basename(entry.module)].sort()
+          : []
+      )
+    }
+    const named = runs.map(
+      ({ name, entry }) =>
+        `${name} ${entry.status} ${path.basename(entry.module)}`
+    )
+    expect(named).toEqual([
+      "api.did written api.ts",
+      "api.v2.did written api.v2.ts",
+      "api.did.did written api.did.ts",
+      ".did written .ts",
+      "..did written ..ts",
+      "api.candid failed api.candid.ts",
+      "api.DID failed api.DID.ts",
+      "api failed api.ts",
+    ])
+  })
+})

package/packages/vite-plugin/tests/package.test.ts

@@ -0,0 +1,62 @@
+/**
+ * What the package promises about its own shape: one exact `@meantjs/cli`
+ * that pairs with the schema runtime, and two public exports.
+ */
+import fs from "node:fs"
+import { createRequire } from "node:module"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { describe, expect, it } from "vitest"
+import { MEANT_CLI_VERSION, resolveCliBin } from "../src/generate.js"
+import * as entry from "../src/index.js"
+
+const PACKAGE = path.join(path.dirname(fileURLToPath(import.meta.url)), "..")
+const manifest = JSON.parse(
+  fs.readFileSync(path.join(PACKAGE, "package.json"), "utf-8")
+) as {
+  peerDependencies: Record<string, string>
+  devDependencies: Record<string, string>
+}
+
+describe("the @meantjs/cli pin", () => {
+  // The app installs the generator that pairs with its schema runtime, so the
+  // peer is one exact version and not a range (DECISIONS Q16).
+  it("is one exact version, as a peer and as the dev dependency the tests run", () => {
+    expect(MEANT_CLI_VERSION).toMatch(/^\d+\.\d+\.\d+(-[\w.]+)?$/)
+    expect(manifest.peerDependencies["@meantjs/cli"]).toBe(MEANT_CLI_VERSION)
+    expect(manifest.devDependencies["@meantjs/cli"]).toBe(MEANT_CLI_VERSION)
+  })
+
+  it("is the version the tests install", () => {
+    const installed = createRequire(import.meta.url).resolve(
+      "@meantjs/cli/package.json"
+    )
+    expect(JSON.parse(fs.readFileSync(installed, "utf-8")).version).toBe(
+      MEANT_CLI_VERSION
+    )
+  })
+
+  it("resolves the bin script of the CLI an app has installed", () => {
+    const bin = resolveCliBin(PACKAGE)
+
+    expect(path.isAbsolute(bin)).toBe(true)
+    expect(fs.existsSync(bin)).toBe(true)
+    expect(path.basename(bin)).toBe("cli.js")
+  })
+})
+
+describe("the public surface", () => {
+  it("has two exports: icReactor and the type IcReactorPluginOptions", () => {
+    expect(Object.keys(entry)).toEqual(["icReactor"])
+
+    const exported = fs
+      .readFileSync(path.join(PACKAGE, "src/index.ts"), "utf-8")
+      // A Windows checkout can have CRLF line endings.
+      .split(/\r?\n/)
+      .filter((line) => /^export\b/.test(line))
+    expect(exported).toEqual([
+      "export interface IcReactorPluginOptions {",
+      "export function icReactor(options: IcReactorPluginOptions = {}): Plugin {",
+    ])
+  })
+})