ic-mops 2.14.1 → 2.15.0

package/tests/deployed.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from "@jest/globals";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cli, normalizePaths, useTempFixtures } from "./helpers";
+
+describe("deployed", () => {
+  const makeTempFixture = useTempFixtures(
+    path.join(import.meta.dirname, "deployed"),
+  );
+
+  describe("init", () => {
+    test("creates baseline .most and sets [check-stable].path", async () => {
+      const cwd = await makeTempFixture("basic");
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const baseline = path.join(cwd, "deployed", "backend.most");
+      expect(existsSync(baseline)).toBe(true);
+      expect(readFileSync(baseline, "utf-8")).toBe(
+        "// Version: 1.0.0\nactor { };\n",
+      );
+
+      const toml = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+      expect(toml).toMatch(/\[canisters\.backend\.check-stable\]/);
+      expect(toml).toMatch(/path\s*=\s*"deployed\/backend\.most"/);
+
+      expect({
+        exitCode: result.exitCode,
+        stdout: normalizePaths(result.stdout),
+        stderr: normalizePaths(result.stderr),
+      }).toMatchSnapshot();
+    });
+
+    test("idempotent — second run is a no-op", async () => {
+      const cwd = await makeTempFixture("basic");
+      await cli(["deployed", "init"], { cwd });
+      const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const tomlAfter = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+      expect(tomlAfter).toBe(tomlBefore);
+    });
+
+    test("warns when [check-stable].path is set elsewhere", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(
+        tomlPath,
+        toml +
+          '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n',
+      );
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toMatch(
+        /check-stable\]\.path = "elsewhere\/backend\.most"/,
+      );
+      expect(result.stderr).toMatch(/does not match where `mops deployed`/);
+      expect(existsSync(path.join(cwd, "deployed", "backend.most"))).toBe(true);
+
+      // mops.toml should not have been rewritten
+      expect(readFileSync(tomlPath, "utf-8")).toBe(
+        toml +
+          '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n',
+      );
+    });
+
+    test("respects [deployed].dir", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(tomlPath, `${toml}\n[deployed]\ndir = "snapshots"\n`);
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "snapshots", "backend.most"))).toBe(
+        true,
+      );
+      expect(readFileSync(tomlPath, "utf-8")).toMatch(
+        /path\s*=\s*"snapshots\/backend\.most"/,
+      );
+    });
+
+    test("init for shorthand canister entry promotes it to a table", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      await writeFile(
+        tomlPath,
+        '[toolchain]\nmoc = "1.5.0"\n\n[canisters]\nbackend = "main.mo"\n',
+      );
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const after = readFileSync(tomlPath, "utf-8");
+      expect(after).toMatch(/\[canisters\.backend\]/);
+      expect(after).toMatch(/main\s*=\s*"main\.mo"/);
+      expect(after).toMatch(/\[canisters\.backend\.check-stable\]/);
+      expect(after).toMatch(/path\s*=\s*"deployed\/backend\.most"/);
+    });
+
+    test("errors on unknown canister name", async () => {
+      const cwd = await makeTempFixture("basic");
+      const result = await cli(["deployed", "init", "ghost"], { cwd });
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toMatch(/not found in mops\.toml/);
+    });
+
+    test("preserves an existing baseline file when wiring [check-stable].path", async () => {
+      const cwd = await makeTempFixture("basic");
+      const baseline = path.join(cwd, "deployed", "backend.most");
+      const customMost =
+        "// Version: 1.0.0\nactor {\n  stable var x : Nat\n};\n";
+      // pre-create the baseline (e.g. real prod snapshot copied in by the user)
+      await mkdir(path.join(cwd, "deployed"), { recursive: true });
+      await writeFile(baseline, customMost);
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(readFileSync(baseline, "utf-8")).toBe(customMost);
+      expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toMatch(
+        /\[canisters\.backend\.check-stable\][\s\S]*path\s*=\s*"deployed\/backend\.most"/,
+      );
+    });
+  });
+
+  describe("post-deploy hook", () => {
+    test("copies built .most into deployed/", async () => {
+      const cwd = await makeTempFixture("basic");
+      const buildResult = await cli(["build"], { cwd });
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const built = path.join(cwd, ".mops", ".build", "backend.most");
+      const promoted = path.join(cwd, "deployed", "backend.most");
+      expect(existsSync(promoted)).toBe(true);
+      expect(readFileSync(promoted, "utf-8")).toBe(
+        readFileSync(built, "utf-8"),
+      );
+    });
+
+    test("errors when source .most is missing", async () => {
+      const cwd = await makeTempFixture("basic");
+      const result = await cli(["deployed", "backend"], { cwd });
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toMatch(/No built \.most/);
+      expect(result.stderr).toMatch(/Run `mops build backend` first/);
+    });
+
+    test("warns when [check-stable].path differs from <dir>/<name>.most", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(
+        tomlPath,
+        toml +
+          '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n',
+      );
+
+      const buildResult = await cli(["build"], { cwd });
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toMatch(
+        /check-stable\]\.path = "elsewhere\/backend\.most"/,
+      );
+      expect(result.stderr).toMatch(/won't see updates from `mops deployed`/);
+    });
+
+    test("respects [deployed].dir from config", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(tomlPath, `${toml}\n[deployed]\ndir = "snapshots"\n`);
+
+      await cli(["build"], { cwd });
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "snapshots", "backend.most"))).toBe(
+        true,
+      );
+      expect(existsSync(path.join(cwd, "deployed", "backend.most"))).toBe(
+        false,
+      );
+    });
+
+    test("--build-dir and --dir overrides", async () => {
+      const cwd = await makeTempFixture("basic");
+      const customOut = "custom-build";
+      const customDir = "snapshots";
+
+      const buildResult = await cli(
+        ["build", "backend", "--output", customOut],
+        { cwd },
+      );
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(
+        ["deployed", "--build-dir", customOut, "--dir", customDir],
+        { cwd },
+      );
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, customDir, "backend.most"))).toBe(true);
+    });
+
+    test("with no canister names promotes all canisters", async () => {
+      const cwd = await makeTempFixture("multi");
+      const buildResult = await cli(["build"], { cwd });
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "deployed", "foo.most"))).toBe(true);
+      expect(existsSync(path.join(cwd, "deployed", "bar.most"))).toBe(true);
+    });
+
+    test("named canister filters to that canister only", async () => {
+      const cwd = await makeTempFixture("multi");
+      await cli(["build"], { cwd });
+
+      const result = await cli(["deployed", "foo"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "deployed", "foo.most"))).toBe(true);
+      expect(existsSync(path.join(cwd, "deployed", "bar.most"))).toBe(false);
+    });
+  });
+
+  describe("end-to-end with check-stable", () => {
+    test("init + build + deployed wires the check-stable baseline", async () => {
+      const cwd = await makeTempFixture("basic");
+
+      await cli(["deployed", "init"], { cwd });
+      await cli(["build"], { cwd });
+      const promoteResult = await cli(["deployed"], { cwd });
+      expect(promoteResult.exitCode).toBe(0);
+
+      const checkResult = await cli(["check-stable"], { cwd });
+      expect(checkResult.exitCode).toBe(0);
+      expect(checkResult.stdout).toMatch(/Stable compatibility check passed/);
+    });
+  });
+});

package/tests/generate/basic/candid/bar.did

@@ -0,0 +1,4 @@
+// Hand-curated; will be overwritten by `mops generate candid bar`.
+service : {
+  greet: (text) -> (text);
+}

package/tests/generate/basic/mops.toml

@@ -0,0 +1,12 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.foo]
+main = "src/Foo.mo"
+
+[canisters.bar]
+main = "src/Bar.mo"
+candid = "candid/bar.did"

package/tests/generate/basic/src/Bar.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func greet(name : Text) : async Text {
+    "Hello, " # name;
+  };
+};

package/tests/generate/basic/src/Foo.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func call() : async Text {
+    "Foo";
+  };
+};

package/tests/generate/error/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.broken]
+main = "src/Broken.mo"

package/tests/generate/error/src/Broken.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func call() : async NotAType {
+    42;
+  };
+};

package/tests/generate.test.ts

@@ -0,0 +1,140 @@
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { existsSync, readFileSync } from "node:fs";
+import { cp, rm } from "node:fs/promises";
+import path from "path";
+import { cli, cliSnapshot } from "./helpers";
+
+const fixturesDir = path.join(import.meta.dirname, "generate");
+
+describe("generate candid", () => {
+  jest.setTimeout(120_000);
+
+  const tempDirs: string[] = [];
+
+  async function makeTempFixture(fixture: string): Promise<string> {
+    const src = path.join(fixturesDir, fixture);
+    const dest = path.join(fixturesDir, `_tmp_${fixture}_${Date.now()}`);
+    await cp(src, dest, { recursive: true });
+    tempDirs.push(dest);
+    return dest;
+  }
+
+  afterEach(async () => {
+    for (const dir of tempDirs) {
+      await rm(dir, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  test("default path: writes <main-dir>/<name>.did and sets [canisters.<name>].candid", async () => {
+    const cwd = await makeTempFixture("basic");
+    const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+    expect(tomlBefore).not.toMatch(/"src\/foo\.did"/);
+
+    await cliSnapshot(["generate", "candid", "foo"], { cwd }, 0);
+
+    const did = readFileSync(path.join(cwd, "src/foo.did"), "utf-8");
+    expect(did).toMatchSnapshot("src/foo.did");
+
+    const tomlAfter = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+    expect(tomlAfter).toMatch(/candid\s*=\s*"src\/foo\.did"/);
+  });
+
+  test("configured path: overwrites in place and does not touch mops.toml", async () => {
+    const cwd = await makeTempFixture("basic");
+    const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+    const didBefore = readFileSync(path.join(cwd, "candid/bar.did"), "utf-8");
+    expect(didBefore).toMatch(/Hand-curated/);
+
+    await cliSnapshot(["generate", "candid", "bar"], { cwd }, 0);
+
+    const didAfter = readFileSync(path.join(cwd, "candid/bar.did"), "utf-8");
+    expect(didAfter).not.toMatch(/Hand-curated/);
+    expect(didAfter).toMatch(/greet/);
+    expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toBe(tomlBefore);
+  });
+
+  test("no canister names: processes all canisters", async () => {
+    const cwd = await makeTempFixture("basic");
+    await cliSnapshot(["generate", "candid"], { cwd }, 0);
+
+    expect(existsSync(path.join(cwd, "src/foo.did"))).toBe(true);
+    const barDid = readFileSync(path.join(cwd, "candid/bar.did"), "utf-8");
+    expect(barDid).toMatch(/greet/);
+    expect(barDid).not.toMatch(/Hand-curated/);
+  });
+
+  test("--output writes to the given path and does not touch mops.toml", async () => {
+    const cwd = await makeTempFixture("basic");
+    const outPath = path.join(cwd, "out/custom.did");
+    const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+
+    const result = await cli(["generate", "candid", "foo", "-o", outPath], {
+      cwd,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(existsSync(outPath)).toBe(true);
+    expect(readFileSync(outPath, "utf-8")).toMatch(/call/);
+    expect(existsSync(path.join(cwd, "src/foo.did"))).toBe(false);
+    expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toBe(tomlBefore);
+  });
+
+  test("--output rejected with multiple canisters", async () => {
+    const cwd = await makeTempFixture("basic");
+    const result = await cli(
+      ["generate", "candid", "foo", "bar", "-o", "x.did"],
+      { cwd },
+    );
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/single canister/i);
+  });
+
+  test("unknown canister name errors", async () => {
+    const cwd = await makeTempFixture("basic");
+    const result = await cli(["generate", "candid", "nope"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/not found in mops\.toml/i);
+  });
+
+  test("moc failure: leaves destination and mops.toml untouched", async () => {
+    const cwd = await makeTempFixture("error");
+    const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+
+    const result = await cli(["generate", "candid", "broken"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/Failed to generate Candid/);
+    expect(existsSync(path.join(cwd, "src/broken.did"))).toBe(false);
+    expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toBe(tomlBefore);
+  });
+
+  test("rejects destination inside .mops/", async () => {
+    const cwd = await makeTempFixture("basic");
+    const result = await cli(
+      ["generate", "candid", "foo", "-o", ".mops/foo.did"],
+      { cwd },
+    );
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/\.mops\//);
+    expect(result.stderr).toMatch(/Refusing/i);
+  });
+
+  test("creates file when [canisters.<name>].candid points to a missing path", async () => {
+    const cwd = await makeTempFixture("basic");
+    // bar's candid path points to candid/bar.did — delete it first
+    await rm(path.join(cwd, "candid/bar.did"));
+
+    const result = await cli(["generate", "candid", "bar"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(existsSync(path.join(cwd, "candid/bar.did"))).toBe(true);
+  });
+
+  test("--output collision with another canister's candid prints a warning", async () => {
+    const cwd = await makeTempFixture("basic");
+    const result = await cli(
+      ["generate", "candid", "foo", "-o", "candid/bar.did"],
+      { cwd },
+    );
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toMatch(/collides with \[canisters\.bar\]\.candid/);
+  });
+});

package/tests/helpers.ts

@@ -1,7 +1,8 @@
-import { expect } from "@jest/globals";
+import { afterEach, expect } from "@jest/globals";
 import { execa } from "execa";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
+import { cp, rm } from "node:fs/promises";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 
 export interface CliOptions {
   cwd?: string;
@@ -69,3 +70,30 @@ export const cliSnapshot = async (
   }).toMatchSnapshot();
   return result;
 };
+
+/**
+ * Set up `afterEach` cleanup and return a `makeTempFixture(name)` function
+ * that copies a fixture subtree into a unique scratch dir under `fixturesDir`.
+ *
+ * Use in tests that mutate fixture files (toml edits, baseline file creation, etc.)
+ * so they don't pollute the source-controlled fixture.
+ */
+export function useTempFixtures(fixturesDir: string) {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    for (const dir of tempDirs) {
+      await rm(dir, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  return async (fixture: string): Promise<string> => {
+    const src = path.join(fixturesDir, fixture);
+    const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const dest = path.join(fixturesDir, `_tmp_${fixture}_${suffix}`);
+    await cp(src, dest, { recursive: true });
+    tempDirs.push(dest);
+    return dest;
+  };
+}

package/tests/migrate.test.ts

@@ -1,24 +1,16 @@
-import { describe, expect, test, afterEach } from "@jest/globals";
+import { describe, expect, test } from "@jest/globals";
 import { readdirSync, readFileSync } from "node:fs";
-import { cp, rm, writeFile } from "node:fs/promises";
-import path from "path";
-import { cli, cliSnapshot, normalizePaths } from "./helpers";
+import { rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cli, cliSnapshot, normalizePaths, useTempFixtures } from "./helpers";
 
 const normalizeTimestamp = (text: string) =>
   text.replace(/\d{8}_\d{6}/g, "<TIMESTAMP>");
 
-const fixturesDir = path.join(import.meta.dirname, "migrate");
-
 describe("migrate", () => {
-  const tempDirs: string[] = [];
-
-  async function makeTempFixture(fixture: string): Promise<string> {
-    const src = path.join(fixturesDir, fixture);
-    const dest = path.join(fixturesDir, `_tmp_${fixture}_${Date.now()}`);
-    await cp(src, dest, { recursive: true });
-    tempDirs.push(dest);
-    return dest;
-  }
+  const makeTempFixture = useTempFixtures(
+    path.join(import.meta.dirname, "migrate"),
+  );
 
   async function patchMigrations(cwd: string, extra: string): Promise<void> {
     const tomlPath = path.join(cwd, "mops.toml");
@@ -32,13 +24,6 @@ describe("migrate", () => {
     );
   }
 
-  afterEach(async () => {
-    for (const dir of tempDirs) {
-      await rm(dir, { recursive: true, force: true });
-    }
-    tempDirs.length = 0;
-  });
-
   describe("migrate new", () => {
     test("creates a migration file with timestamp and template", async () => {
       const cwd = await makeTempFixture("basic");

package/types.ts

@@ -27,6 +27,9 @@ export type Config = {
     outputDir?: string;
     args?: string[];
   };
+  deployed?: {
+    dir?: string;
+  };
   lint?: {
     args?: string[];
     rules?: string[];