ic-mops 2.15.1 → 2.16.0

package/tests/check-stable/check-limit-warning/migrations/20250301_000000_AddD.mo

@@ -0,0 +1,10 @@
+module {
+  public func migration(old : { a : Nat; b : Text; c : Bool }) : {
+    a : Nat;
+    b : Text;
+    c : Bool;
+    d : Int;
+  } {
+    { old with d = 0 };
+  };
+};

package/tests/check-stable/check-limit-warning/mops.toml

@@ -0,0 +1,15 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "src/main.mo"
+
+[canisters.backend.migrations]
+chain = "migrations"
+check-limit = 1
+
+[canisters.backend.check-stable]
+path = "deployed.most"

package/tests/check-stable/check-limit-warning/src/main.mo

@@ -0,0 +1,12 @@
+import Prim "mo:prim";
+
+actor {
+  let a : Nat;
+  let b : Text;
+  let c : Bool;
+  let d : Int;
+
+  public func check() : async () {
+    Prim.debugPrint(debug_show { a; b; c; d });
+  };
+};

package/tests/check-stable.test.ts

@@ -106,4 +106,28 @@ describe("check-stable", () => {
       expect(result.stdout).toMatch(/Stable compatibility check passed/);
     }
   }, 60_000);
+
+  test("fails with check-limit diagnostic when pending migrations exceed check-limit", async () => {
+    const cwd = path.join(
+      import.meta.dirname,
+      "check-stable/check-limit-warning",
+    );
+    await cliSnapshot(["check-stable"], { cwd }, 1);
+  });
+
+  test("does not warn when deployed baseline matches the chain", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/migrations-chain");
+    const result = await cli(["check-stable"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).not.toMatch(/pending migration\(s\) but check-limit/);
+  });
+
+  test("--no-check-limit suppresses pending migration warning", async () => {
+    const cwd = path.join(
+      import.meta.dirname,
+      "check-stable/check-limit-warning",
+    );
+    const result = await cli(["check-stable", "--no-check-limit"], { cwd });
+    expect(result.stderr).not.toMatch(/pending migration\(s\) but check-limit/);
+  });
 });

package/tests/check.test.ts

@@ -195,4 +195,13 @@ describe("check", () => {
     expect(result.stdout).not.toMatch(/\.migrations-/);
     expect(result.stdout).not.toMatch(/-A=M0254/);
   });
+
+  test("--no-check-limit suppresses pending migration warning in check", async () => {
+    const cwd = path.join(
+      import.meta.dirname,
+      "check-stable/check-limit-warning",
+    );
+    const result = await cli(["check", "--no-check-limit"], { cwd });
+    expect(result.stderr).not.toMatch(/pending migration\(s\) but check-limit/);
+  });
 });

package/tests/lint-extra-example-rules/lint/migration-self-contained/migration-self-contained.toml

@@ -0,0 +1,7 @@
+name = "migration-self-contained"
+description = "Migration files must not import local modules (relative paths). Got: @path"
+includes = ["migrations/*.mo"]
+query = '''
+(import (text_literal) @path @error
+  (#match? @path "^\"[^:]*\"$"))
+'''

package/tests/lint-extra-example-rules/migrations/20250101_000000_Init.mo

@@ -0,0 +1,11 @@
+import Map "mo:map/Map";
+import Backend "canister:backend";
+import Types "Types";
+import TypesDot "./Types";
+import TypesParent "../src/Types";
+
+module {
+  public func migration(_ : {}) : { count : Nat } {
+    { count = 0 };
+  };
+};

package/tests/lint-extra-example-rules/mops.toml

@@ -5,3 +5,4 @@ lintoko = "0.7.0"
 "src/Main.mo" = ["lint/no-types"]
 "src/Types.mo" = ["lint/types-only"]
 "src/Migration.mo" = ["lint/migration-only"]
+"migrations/*.mo" = ["lint/migration-self-contained"]

package/tests/lint.test.ts

@@ -83,7 +83,7 @@ describe("lint", () => {
       );
     });
 
-    test("example rules: no-types, types-only, migration-only", async () => {
+    test("example rules: no-types, types-only, migration-only, migration-self-contained", async () => {
       const cwd = path.join(import.meta.dirname, "lint-extra-example-rules");
       await cliSnapshot(["lint"], { cwd }, 1);
     });

package/tests/migrations-most.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  latestAppliedMigrationName,
+  parseMostAppliedMigrationNames,
+} from "../helpers/parse-most";
+
+describe("parseMostAppliedMigrationNames", () => {
+  test("parses Version 4.0.0 enhanced-migration chain", () => {
+    const content = `// Version: 4.0.0
+{
+  "20250101_000000_Init" : {} -> {a : Nat; b : Text};
+  "20250201_000000_AddField" : (old : {a : Nat; b : Text}) -> {a : Nat; b : Text; c : Bool};
+}
+actor  {
+  stable a : Nat;
+  stable b : Text;
+  stable c : Bool
+};
+`;
+    expect(parseMostAppliedMigrationNames(content)).toEqual([
+      "20250101_000000_Init",
+      "20250201_000000_AddField",
+    ]);
+  });
+
+  test("returns empty array for Version 1.0.0 (no EM chain)", () => {
+    expect(
+      parseMostAppliedMigrationNames("// Version: 1.0.0\nactor { };\n"),
+    ).toEqual([]);
+  });
+
+  test("returns empty array for Version 3.0.0 (legacy migration)", () => {
+    const content = `// Version: 3.0.0
+actor ({
+}, {
+  stable var field1 : Nat;
+  stable var field2 : Text
+});
+`;
+    expect(parseMostAppliedMigrationNames(content)).toEqual([]);
+  });
+
+  test("returns null when version header is missing", () => {
+    expect(parseMostAppliedMigrationNames("actor { };\n")).toBeNull();
+  });
+
+  test("returns null when Version 4.0.0 has no actor block", () => {
+    expect(
+      parseMostAppliedMigrationNames(
+        '// Version: 4.0.0\n{ "Init" : {} -> {} }',
+      ),
+    ).toBeNull();
+  });
+
+  test("latestAppliedMigrationName picks lexicographic max", () => {
+    expect(
+      latestAppliedMigrationName([
+        "20250101_000000_Init",
+        "20250301_000000_AddD",
+        "20250201_000000_AddField",
+      ]),
+    ).toBe("20250301_000000_AddD");
+  });
+});

package/tests/requirements-lintoko/mops.toml

@@ -0,0 +1,5 @@
+[dependencies]
+my-pkg = "0.1.0"
+
+[toolchain]
+lintoko = "0.7.0"

package/tests/requirements.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+import { cp, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "path";
+import { bytesToHex } from "@noble/hashes/utils";
+import { sha256 } from "@noble/hashes/sha256";
+import { cli } from "./helpers";
+
+describe("requirements", () => {
+  const fixtureDir = path.join(import.meta.dirname, "requirements-lintoko");
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = path.join(
+      import.meta.dirname,
+      `_tmp_requirements_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    );
+    await cp(fixtureDir, tempDir, { recursive: true });
+
+    const depDir = path.join(tempDir, ".mops", "my-pkg@0.1.0");
+    await mkdir(depDir, { recursive: true });
+    await writeFile(
+      path.join(depDir, "mops.toml"),
+      `[package]
+name = "my-pkg"
+version = "0.1.0"
+
+[requirements]
+lintoko = "0.10.0"
+`,
+    );
+
+    const mopsTomlDepsHash = bytesToHex(
+      sha256(JSON.stringify({ "my-pkg": "0.1.0" })),
+    );
+    await writeFile(
+      path.join(tempDir, "mops.lock"),
+      JSON.stringify({
+        version: 3,
+        mopsTomlDepsHash,
+        deps: { "my-pkg": "0.1.0" },
+        hashes: {
+          "my-pkg@0.1.0": {
+            "mops.toml":
+              "0000000000000000000000000000000000000000000000000000000000000000",
+          },
+        },
+      }),
+    );
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  test("lintoko requirement warns when installed version is too old", async () => {
+    const result = await cli(["toolchain", "use", "lintoko", "0.7.0"], {
+      cwd: tempDir,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(
+      /lintoko version does not meet the requirements of my-pkg@0\.1\.0/,
+    );
+    expect(result.stdout).toMatch(/Required: >= 0\.10\.0/);
+    expect(result.stdout).toMatch(/Installed:\s+0\.7\.0/);
+  });
+});

package/types.ts

@@ -78,6 +78,7 @@ export type Tool = "moc" | "wasmtime" | "pocket-ic" | "lintoko";
 
 export type Requirements = {
   moc?: string;
+  lintoko?: string;
 };
 
 // export type Format = {