ic-mops 1.12.0 → 2.0.0

package/dist/commands/test/test.js

@@ -1,31 +1,31 @@
-import process from 'node:process';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-import { PassThrough } from 'node:stream';
-import chalk from 'chalk';
-import { globSync } from 'glob';
-import chokidar from 'chokidar';
-import debounce from 'debounce';
-import { SemVer } from 'semver';
-import { sources } from '../sources.js';
-import { getRootDir, readConfig } from '../../mops.js';
-import { parallel } from '../../parallel.js';
-import { MMF1 } from './mmf1.js';
-import { absToRel, pipeMMF, pipeStderrToMMF, pipeStdoutToMMF } from './utils.js';
-import { VerboseReporter } from './reporters/verbose-reporter.js';
-import { FilesReporter } from './reporters/files-reporter.js';
-import { CompactReporter } from './reporters/compact-reporter.js';
-import { SilentReporter } from './reporters/silent-reporter.js';
-import { toolchain } from '../toolchain/index.js';
-import { Replica } from '../replica.js';
-import { getDfxVersion } from '../../helpers/get-dfx-version.js';
+import process from "node:process";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { PassThrough } from "node:stream";
+import chalk from "chalk";
+import { globSync } from "glob";
+import chokidar from "chokidar";
+import debounce from "debounce";
+import { SemVer } from "semver";
+import { sources } from "../sources.js";
+import { getRootDir, readConfig } from "../../mops.js";
+import { parallel } from "../../parallel.js";
+import { MMF1 } from "./mmf1.js";
+import { absToRel, pipeMMF, pipeStderrToMMF, pipeStdoutToMMF, } from "./utils.js";
+import { VerboseReporter } from "./reporters/verbose-reporter.js";
+import { FilesReporter } from "./reporters/files-reporter.js";
+import { CompactReporter } from "./reporters/compact-reporter.js";
+import { SilentReporter } from "./reporters/silent-reporter.js";
+import { toolchain } from "../toolchain/index.js";
+import { Replica } from "../replica.js";
+import { getDfxVersion } from "../../helpers/get-dfx-version.js";
 let ignore = [
-    '**/node_modules/**',
-    '**/.mops/**',
-    '**/.vessel/**',
-    '**/.git/**',
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
 ];
 let globConfig = {
     nocase: true,
@@ -41,18 +41,19 @@ async function startReplicaOnce(replica, type) {
     }
     return replicaStartPromise;
 }
-export async function test(filter = '', options = {}) {
+export async function test(filter = "", options = {}) {
     let config = readConfig();
     let rootDir = getRootDir();
-    let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
-    if (replicaType === 'pocket-ic' && !config.toolchain?.['pocket-ic']) {
+    let replicaType = options.replica ??
+        (config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx");
+    if (replicaType === "pocket-ic" && !config.toolchain?.["pocket-ic"]) {
         let dfxVersion = getDfxVersion();
-        if (!dfxVersion || new SemVer(dfxVersion).compare('0.24.1') < 0) {
-            console.log(chalk.red('Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml'));
+        if (!dfxVersion || new SemVer(dfxVersion).compare("0.24.1") < 0) {
+            console.log(chalk.red("Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml"));
             process.exit(1);
         }
         else {
-            replicaType = 'dfx-pocket-ic';
+            replicaType = "dfx-pocket-ic";
         }
     }
     replica.type = replicaType;
@@ -60,14 +61,14 @@ export async function test(filter = '', options = {}) {
     if (options.watch) {
         replica.ttl = 60 * 15; // 15 minutes
         let sigint = false;
-        process.on('SIGINT', () => {
+        process.on("SIGINT", () => {
             if (sigint) {
-                console.log('Force exit');
+                console.log("Force exit");
                 process.exit(0);
             }
             sigint = true;
             if (replicaStartPromise) {
-                console.log('Stopping replica...');
+                console.log("Stopping replica...");
                 replica.stop(true).then(() => {
                     process.exit(0);
                 });
@@ -84,22 +85,19 @@ export async function test(filter = '', options = {}) {
             controller.abort();
             await curRun;
             console.clear();
-            process.stdout.write('\x1Bc');
+            process.stdout.write("\x1Bc");
             controller = new AbortController();
             curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal);
             await curRun;
-            console.log('-'.repeat(50));
-            console.log('Waiting for file changes...');
-            console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
+            console.log("-".repeat(50));
+            console.log("Waiting for file changes...");
+            console.log(chalk.gray(`Press ${chalk.gray("Ctrl+C")} to exit.`));
         }, 200);
-        let watcher = chokidar.watch([
-            path.join(rootDir, '**/*.mo'),
-            path.join(rootDir, 'mops.toml'),
-        ], {
+        let watcher = chokidar.watch([path.join(rootDir, "**/*.mo"), path.join(rootDir, "mops.toml")], {
             ignored: ignore,
             ignoreInitial: true,
         });
-        watcher.on('all', () => {
+        watcher.on("all", () => {
             run();
         });
         run();
@@ -111,21 +109,21 @@ export async function test(filter = '', options = {}) {
         }
     }
 }
-let mocPath = '';
-let wasmtimePath = '';
-async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false, signal) {
+let mocPath = "";
+let wasmtimePath = "";
+async function runAll(reporterName, filter = "", mode = "interpreter", replicaType, watch = false, signal) {
     let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal);
     return done;
 }
-export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false, signal) {
+export async function testWithReporter(reporterName, filter = "", defaultMode = "interpreter", replicaType, watch = false, signal) {
     let rootDir = getRootDir();
     let files = [];
-    let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
+    let libFiles = globSync("**/test?(s)/lib.mo", globConfig);
     if (libFiles[0]) {
         files = [libFiles[0]];
     }
     else {
-        let globStr = '**/test?(s)/**/*.test.mo';
+        let globStr = "**/test?(s)/**/*.test.mo";
         if (filter) {
             globStr = `**/test?(s)/**/*${filter}*.mo`;
         }
@@ -136,26 +134,26 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
             console.log(`No test files found for filter '${filter}'`);
             return false;
         }
-        console.log('No test files found');
-        console.log('Put your tests in \'test\' directory in *.test.mo files');
+        console.log("No test files found");
+        console.log("Put your tests in 'test' directory in *.test.mo files");
         return false;
     }
     let reporter;
-    if (!reporterName || typeof reporterName === 'string') {
+    if (!reporterName || typeof reporterName === "string") {
         if (!reporterName) {
-            reporterName = files.length > 1 ? 'files' : 'verbose';
+            reporterName = files.length > 1 ? "files" : "verbose";
         }
-        if (reporterName == 'compact') {
-            reporter = new CompactReporter;
+        if (reporterName == "compact") {
+            reporter = new CompactReporter();
         }
-        else if (reporterName == 'files') {
-            reporter = new FilesReporter;
+        else if (reporterName == "files") {
+            reporter = new FilesReporter();
         }
-        else if (reporterName == 'silent') {
-            reporter = new SilentReporter;
+        else if (reporterName == "silent") {
+            reporter = new SilentReporter();
         }
         else {
-            reporter = new VerboseReporter;
+            reporter = new VerboseReporter();
         }
     }
     else {
@@ -165,51 +163,59 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
     let config = readConfig();
     let sourcesArr = await sources();
     if (!mocPath) {
-        mocPath = await toolchain.bin('moc', { fallback: true });
+        mocPath = await toolchain.bin("moc", { fallback: true });
     }
-    let testTempDir = path.join(getRootDir(), '.mops/.test/');
+    let testTempDir = path.join(getRootDir(), ".mops/.test/");
     replica.dir = testTempDir;
     fs.rmSync(testTempDir, { recursive: true, force: true });
     fs.mkdirSync(testTempDir, { recursive: true });
     let filesWithMode = files.map((file) => {
-        let lines = fs.readFileSync(file, 'utf8').split('\n');
+        let lines = fs.readFileSync(file, "utf8").split("\n");
         let mode = defaultMode;
-        if (lines.includes('// @testmode wasi')) {
-            mode = 'wasi';
+        if (lines.includes("// @testmode wasi")) {
+            mode = "wasi";
         }
-        else if (lines.includes('// @testmode replica') || lines.find(line => line.match(/^(persistent )?actor( class)?/))) {
-            mode = 'replica';
+        else if (lines.includes("// @testmode replica") ||
+            lines.find((line) => line.match(/^(persistent )?actor( class)?/))) {
+            mode = "replica";
         }
         return { file, mode };
     });
-    let hasWasiTests = filesWithMode.some(({ mode }) => mode === 'wasi');
-    let hasReplicaTests = filesWithMode.some(({ mode }) => mode === 'replica');
+    let hasWasiTests = filesWithMode.some(({ mode }) => mode === "wasi");
+    let hasReplicaTests = filesWithMode.some(({ mode }) => mode === "replica");
     // prepare wasmtime path
     if (hasWasiTests && !wasmtimePath) {
         // ensure wasmtime is installed or specified in config
         if (config.toolchain?.wasmtime) {
-            wasmtimePath = await toolchain.bin('wasmtime');
+            wasmtimePath = await toolchain.bin("wasmtime");
         }
         // fallback wasmtime to global binary if not specified in config (legacy)
         else {
-            wasmtimePath = 'wasmtime';
-            console.log(chalk.yellow('Warning:'), 'Wasmtime is not specified in config. Using global binary "wasmtime". This will be removed in the future.');
-            console.log(`Run ${chalk.green('mops toolchain use wasmtime')} or add ${chalk.green('wasmtime = "<version>"')} in mops.toml to avoid breaking changes with future versions of mops.`);
+            wasmtimePath = "wasmtime";
+            console.log(chalk.yellow("Warning:"), 'Wasmtime is not specified in config. Using global binary "wasmtime". This will be removed in the future.');
+            console.log(`Run ${chalk.green("mops toolchain use wasmtime")} or add ${chalk.green('wasmtime = "<version>"')} in mops.toml to avoid breaking changes with future versions of mops.`);
         }
     }
-    let runTestFile = async ({ file, mode }) => {
+    let runTestFile = async ({ file, mode, }) => {
         if (signal?.aborted) {
             return;
         }
         // print logs immediately for replica tests because we run them one-by-one
-        let mmf = new MMF1(mode === 'replica' ? 'print' : 'store', absToRel(file));
+        let mmf = new MMF1(mode === "replica" ? "print" : "store", absToRel(file));
         let promise = new Promise((resolve) => {
-            let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
+            let mocArgs = [
+                "--hide-warnings",
+                "--error-detail=2",
+                ...sourcesArr.join(" ").split(" "),
+                file,
+            ].filter((x) => x);
             // interpret
-            if (mode === 'interpreter') {
-                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs], { signal });
-                proc.addListener('error', (error) => {
-                    if (error?.code === 'ABORT_ERR') {
+            if (mode === "interpreter") {
+                let proc = spawn(mocPath, ["-r", "-ref-system-api", ...mocArgs], {
+                    signal,
+                });
+                proc.addListener("error", (error) => {
+                    if (error?.code === "ABORT_ERR") {
                         return;
                     }
                     throw error;
@@ -217,62 +223,76 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                 pipeMMF(proc, mmf).then(resolve);
             }
             // build and run wasm
-            else if (mode === 'wasi') {
+            else if (mode === "wasi") {
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs], { signal });
-                buildProc.addListener('error', (error) => {
-                    if (error?.code === 'ABORT_ERR') {
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, "-wasi-system-api", ...mocArgs], { signal });
+                buildProc.addListener("error", (error) => {
+                    if (error?.code === "ABORT_ERR") {
                         return;
                     }
                     throw error;
                 });
-                pipeMMF(buildProc, mmf).then(async () => {
+                pipeMMF(buildProc, mmf)
+                    .then(async () => {
                     if (mmf.failed > 0) {
                         return;
                     }
                     // run
                     let wasmtimeArgs = [];
-                    if (config.toolchain?.wasmtime && config.toolchain?.wasmtime >= '14.0.0') {
+                    if (config.toolchain?.wasmtime &&
+                        config.toolchain?.wasmtime >= "14.0.0") {
                         wasmtimeArgs = [
-                            '-S', 'preview2=n',
-                            '-C', 'cache=n',
-                            '-W', 'bulk-memory',
-                            '-W', 'multi-memory',
-                            '-W', 'memory64',
-                            '-W', 'max-wasm-stack=4000000',
-                            '-W', 'nan-canonicalization=y',
+                            "-S",
+                            "preview2=n",
+                            "-C",
+                            "cache=n",
+                            "-W",
+                            "bulk-memory",
+                            "-W",
+                            "multi-memory",
+                            "-W",
+                            "memory64",
+                            "-W",
+                            "max-wasm-stack=4000000",
+                            "-W",
+                            "nan-canonicalization=y",
                             wasmFile,
                         ];
                     }
                     else {
-                        console.error(chalk.red('Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version'));
+                        console.error(chalk.red("Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version"));
                         process.exit(1);
                     }
                     let proc = spawn(wasmtimePath, wasmtimeArgs, { signal });
-                    proc.addListener('error', (error) => {
-                        if (error?.code === 'ABORT_ERR') {
+                    proc.addListener("error", (error) => {
+                        if (error?.code === "ABORT_ERR") {
                             return;
                         }
                         throw error;
                     });
                     await pipeMMF(proc, mmf);
-                }).finally(() => {
+                })
+                    .finally(() => {
                     fs.rmSync(wasmFile, { force: true });
-                }).then(resolve);
+                })
+                    .then(resolve);
             }
             // build and execute in replica
-            else if (mode === 'replica') {
+            else if (mode === "replica") {
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], { signal });
-                buildProc.addListener('error', (error) => {
-                    if (error?.code === 'ABORT_ERR') {
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], {
+                    signal,
+                });
+                buildProc.addListener("error", (error) => {
+                    if (error?.code === "ABORT_ERR") {
                         return;
                     }
                     throw error;
                 });
-                pipeMMF(buildProc, mmf).then(async () => {
+                pipeMMF(buildProc, mmf)
+                    .then(async () => {
                     if (mmf.failed > 0) {
                         return;
                     }
@@ -282,14 +302,14 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                     }
                     let canisterName = path.parse(file).name;
                     let idlFactory = ({ IDL }) => {
-                        return IDL.Service({ 'runTests': IDL.Func([], [], []) });
+                        return IDL.Service({ runTests: IDL.Func([], [], []) });
                     };
                     let canister = await replica.deploy(canisterName, wasmFile, idlFactory, undefined, signal);
                     if (signal?.aborted || !canister) {
                         return;
                     }
                     pipeStdoutToMMF(canister.stream, mmf);
-                    let actor = await replica.getActor(canisterName);
+                    let actor = (await replica.getActor(canisterName));
                     try {
                         if (globalThis.mopsReplicaTestRunning) {
                             await new Promise((resolve) => {
@@ -298,7 +318,7 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                                         resolve();
                                         clearInterval(timerId);
                                     }
-                                }, Math.random() * 1000 | 0);
+                                }, (Math.random() * 1000) | 0);
                             });
                         }
                         if (signal?.aborted) {
@@ -314,10 +334,12 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                         pipeStderrToMMF(stderrStream, mmf, path.dirname(file));
                         stderrStream.write(e.message);
                     }
-                }).finally(async () => {
+                })
+                    .finally(async () => {
                     globalThis.mopsReplicaTestRunning = false;
                     fs.rmSync(wasmFile, { force: true });
-                }).then(resolve);
+                })
+                    .then(resolve);
             }
         });
         if (signal?.aborted) {
@@ -326,8 +348,8 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
         reporter.addRun(file, mmf, promise, mode);
         await promise;
     };
-    await parallel(os.cpus().length, filesWithMode.filter(({ mode }) => mode !== 'replica'), runTestFile);
-    await parallel(1, filesWithMode.filter(({ mode }) => mode === 'replica'), runTestFile);
+    await parallel(os.cpus().length, filesWithMode.filter(({ mode }) => mode !== "replica"), runTestFile);
+    await parallel(1, filesWithMode.filter(({ mode }) => mode === "replica"), runTestFile);
     if (hasReplicaTests && !watch) {
         await replica.stop();
         fs.rmSync(testTempDir, { recursive: true, force: true });

package/dist/commands/test/utils.d.ts

@@ -1,6 +1,6 @@
-import { ChildProcessWithoutNullStreams } from 'node:child_process';
-import { Readable } from 'node:stream';
-import { MMF1 } from './mmf1.js';
+import { ChildProcessWithoutNullStreams } from "node:child_process";
+import { Readable } from "node:stream";
+import { MMF1 } from "./mmf1.js";
 export declare function absToRel(p: string): string;
 export declare function pipeStdoutToMMF(stdout: Readable, mmf: MMF1): void;
 export declare function pipeStderrToMMF(stderr: Readable, mmf: MMF1, dir?: string): void;

package/dist/commands/test/utils.js

@@ -1,14 +1,14 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import chalk from 'chalk';
-import { getRootDir } from '../../mops.js';
+import path from "node:path";
+import fs from "node:fs";
+import chalk from "chalk";
+import { getRootDir } from "../../mops.js";
 export function absToRel(p) {
     let rootDir = getRootDir();
     return path.relative(rootDir, path.resolve(p));
 }
 export function pipeStdoutToMMF(stdout, mmf) {
-    stdout.on('data', (data) => {
-        for (let line of data.toString().split('\n')) {
+    stdout.on("data", (data) => {
+        for (let line of data.toString().split("\n")) {
             line = line.trim();
             if (line) {
                 mmf.parseLine(line);
@@ -16,10 +16,10 @@ export function pipeStdoutToMMF(stdout, mmf) {
         }
     });
 }
-export function pipeStderrToMMF(stderr, mmf, dir = '') {
-    stderr.on('data', (data) => {
+export function pipeStderrToMMF(stderr, mmf, dir = "") {
+    stderr.on("data", (data) => {
         let text = data.toString().trim();
-        let failedLine = '';
+        let failedLine = "";
         text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
             // change absolute file path to relative
             // change :line:col-line:col to :line:col to work in vscode
@@ -30,17 +30,17 @@ export function pipeStderrToMMF(stderr, mmf, dir = '') {
             }
             // show failed line
             let content = fs.readFileSync(file);
-            let lines = content.toString().split('\n') || [];
-            failedLine += chalk.dim('\n   ...');
+            let lines = content.toString().split("\n") || [];
+            failedLine += chalk.dim("\n   ...");
             let lineBefore = lines[+m2 - 2];
             if (lineBefore) {
-                failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`);
+                failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll("\t", "  ")}`);
             }
-            failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
+            failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll("\t", "  ")}`;
             if (lines.length > +m2) {
-                failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`);
+                failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll("\t", "  ")}`);
             }
-            failedLine += chalk.dim('\n   ...');
+            failedLine += chalk.dim("\n   ...");
             return res;
         });
         if (failedLine) {
@@ -54,9 +54,9 @@ export function pipeMMF(proc, mmf) {
         pipeStdoutToMMF(proc.stdout, mmf);
         pipeStderrToMMF(proc.stderr, mmf);
         // exit
-        proc.on('close', (code) => {
+        proc.on("close", (code) => {
             if (code === 0) {
-                mmf.strategy !== 'print' && mmf.pass();
+                mmf.strategy !== "print" && mmf.pass();
             }
             else if (code !== 1) {
                 mmf.fail(`unknown exit code: ${code}`);

package/dist/commands/toolchain/index.d.ts

@@ -1,4 +1,4 @@
-import { Tool } from '../../types.js';
+import { Tool } from "../../types.js";
 declare function ensureToolchainInited({ strict }?: {
     strict?: boolean | undefined;
 }): Promise<boolean>;