ic-mops 0.45.3 → 1.0.0-pre.0

package/dist/commands/replica.js

@@ -0,0 +1,193 @@
+import process from 'node:process';
+import { execSync, spawn } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { PassThrough } from 'node:stream';
+import { Actor, HttpAgent } from '@dfinity/agent';
+import { PocketIc, PocketIcServer } from 'pic-ic';
+import { readConfig } from '../mops.js';
+import { toolchain } from './toolchain/index.js';
+export class Replica {
+    constructor() {
+        this.type = 'dfx';
+        this.verbose = false;
+        this.canisters = {};
+        this.dir = ''; // absolute path (/.../.mops/.test/)
+        this.ttl = 60;
+    }
+    async start({ type, dir, verbose, silent } = {}) {
+        this.type = type ?? this.type;
+        this.verbose = verbose ?? this.verbose;
+        this.dir = dir ?? this.dir;
+        silent || console.log(`Starting ${this.type} replica...`);
+        if (this.type == 'dfx') {
+            fs.mkdirSync(this.dir, { recursive: true });
+            fs.writeFileSync(path.join(this.dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
+            fs.writeFileSync(path.join(this.dir, 'canister.did'), 'service : { runTests: () -> (); }');
+            await this.stop();
+            this.dfxProcess = spawn('dfx', ['start', '--clean', '--artificial-delay', '0', (this.verbose ? '' : '-qqqq')].filter(x => x), { cwd: this.dir });
+            // process canister logs
+            this._attachCanisterLogHandler(this.dfxProcess);
+            this.dfxProcess.stdout.on('data', (data) => {
+                console.log('DFX:', data.toString());
+            });
+            // await for dfx to start
+            let ok = false;
+            while (!ok) {
+                await fetch('http://127.0.0.1:4945/api/v2/status')
+                    .then(res => {
+                    if (res.status === 200) {
+                        ok = true;
+                    }
+                })
+                    .catch(() => { })
+                    .finally(() => {
+                    return new Promise(resolve => setTimeout(resolve, 1000));
+                });
+            }
+        }
+        else {
+            let pocketIcBin = await toolchain.bin('pocket-ic');
+            // eslint-disable-next-line
+            let config = readConfig();
+            if (config.toolchain?.['pocket-ic'] !== '4.0.0') {
+                console.error('Current Mops CLI only supports pocket-ic 4.0.0');
+                process.exit(1);
+            }
+            this.pocketIcServer = await PocketIcServer.start({
+                showRuntimeLogs: false,
+                showCanisterLogs: false,
+                binPath: pocketIcBin,
+                ttl: this.ttl,
+            });
+            this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
+            // process canister logs
+            this._attachCanisterLogHandler(this.pocketIcServer.serverProcess);
+        }
+    }
+    _attachCanisterLogHandler(proc) {
+        let curData = '';
+        proc.stderr.on('data', (data) => {
+            curData = curData + data.toString();
+            if (curData.includes('\n')) {
+                let m = curData.match(/\[Canister ([a-z0-9-]+)\] (.*)/);
+                if (!m) {
+                    return;
+                }
+                let [, canisterId, msg] = m;
+                let stream = this.getCanisterStream(canisterId || '');
+                if (stream) {
+                    stream.write(msg);
+                }
+                curData = '';
+            }
+        });
+    }
+    async stop(sigint = false) {
+        if (this.type == 'dfx') {
+            this.dfxProcess?.kill();
+            // execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: this.dir, timeout: 10_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+        }
+        else if (this.pocketIc && this.pocketIcServer) {
+            if (!sigint) {
+                await this.pocketIc.tearDown(); // error 'fetch failed' if run on SIGINT
+            }
+            await this.pocketIcServer.stop();
+        }
+    }
+    async deploy(name, wasm, idlFactory, cwd = process.cwd()) {
+        if (this.type === 'dfx') {
+            // prepare dfx.json for current canister
+            let dfxJson = path.join(this.dir, 'dfx.json');
+            let oldDfxJsonData;
+            if (fs.existsSync(dfxJson)) {
+                oldDfxJsonData = JSON.parse(fs.readFileSync(dfxJson).toString());
+            }
+            let newDfxJsonData = this.dfxJson(name, name + '.wasm');
+            if (oldDfxJsonData.canisters) {
+                newDfxJsonData.canisters = Object.assign(oldDfxJsonData.canisters, newDfxJsonData.canisters);
+            }
+            fs.mkdirSync(this.dir, { recursive: true });
+            fs.writeFileSync(dfxJson, JSON.stringify(newDfxJsonData, null, 2));
+            execSync(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd: this.dir, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+            execSync(`dfx ledger fabricate-cycles --canister ${name} --t 100`, { cwd: this.dir, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+            let canisterId = execSync(`dfx canister id ${name}`, { cwd: this.dir }).toString().trim();
+            let actor = Actor.createActor(idlFactory, {
+                agent: await HttpAgent.create({
+                    host: 'http://127.0.0.1:4945',
+                    shouldFetchRootKey: true,
+                }),
+                canisterId,
+            });
+            this.canisters[name] = {
+                cwd,
+                canisterId,
+                actor,
+                stream: new PassThrough(),
+            };
+        }
+        else if (this.pocketIc) {
+            // let {canisterId, actor} = await this.pocketIc.setupCanister(idlFactory, wasm);
+            let { canisterId, actor } = await this.pocketIc.setupCanister({
+                idlFactory,
+                wasm,
+            });
+            await this.pocketIc.addCycles(canisterId, 1_000_000_000_000);
+            this.canisters[name] = {
+                cwd,
+                canisterId: canisterId.toText(),
+                actor,
+                stream: new PassThrough(),
+            };
+        }
+        if (!this.canisters[name]) {
+            throw new Error(`Canister ${name} not found`);
+        }
+        return this.canisters[name];
+    }
+    getActor(name) {
+        if (!this.canisters[name]) {
+            throw new Error(`Canister ${name} not found`);
+        }
+        return this.canisters[name]?.actor;
+    }
+    getCanister(name) {
+        return this.canisters[name];
+    }
+    getCanisterId(name) {
+        return this.canisters[name]?.canisterId || '';
+    }
+    getCanisterStream(canisterId) {
+        for (let canister of Object.values(this.canisters)) {
+            if (canister.canisterId === canisterId) {
+                return canister.stream;
+            }
+        }
+        return null;
+    }
+    dfxJson(canisterName, wasmPath = 'canister.wasm', didPath = 'canister.did') {
+        let canisters = {};
+        if (canisterName) {
+            canisters[canisterName] = {
+                type: 'custom',
+                wasm: wasmPath,
+                candid: didPath,
+            };
+        }
+        return {
+            version: 1,
+            canisters,
+            defaults: {
+                build: {
+                    packtool: 'mops sources',
+                },
+            },
+            networks: {
+                local: {
+                    type: 'ephemeral',
+                    bind: '127.0.0.1:4945',
+                },
+            },
+        };
+    }
+}

package/dist/commands/sources.d.ts

@@ -1,4 +1,4 @@
-export declare function sources({ verbose, cwd }?: {
-    verbose?: boolean | undefined;
+export declare function sources({ conflicts, cwd }?: {
+    conflicts?: "ignore" | "error" | "warning" | undefined;
     cwd?: string | undefined;
 }): Promise<(string | undefined)[]>;

package/dist/commands/sources.js

@@ -3,12 +3,11 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';
 import { resolvePackages } from '../resolve-packages.js';
-// TODO: resolve conflicts
-export async function sources({ verbose = false, cwd = process.cwd() } = {}) {
+export async function sources({ conflicts = 'ignore', cwd = process.cwd() } = {}) {
     if (!checkConfigFile()) {
         return [];
     }
-    let resolvedPackages = await resolvePackages({ verbose });
+    let resolvedPackages = await resolvePackages({ conflicts });
     // sources
     return Object.entries(resolvedPackages).map(([name, version]) => {
         let depType = getDependencyType(version);

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

@@ -8,14 +8,14 @@ export declare class MMF1 {
     failed: number;
     passed: number;
     skipped: number;
-    srategy: Strategy;
+    strategy: Strategy;
     output: {
         type: MessageType;
         message: string;
     }[];
     nestingSymbol: string;
     passedNamesFlat: string[];
-    constructor(srategy: Strategy, file: string);
+    constructor(strategy: Strategy, file: string);
     _log(type: MessageType, ...args: string[]): void;
     flush(messageType?: MessageType): void;
     parseLine(line: string): void;

package/dist/commands/test/mmf1.js

@@ -4,7 +4,7 @@
 // mops:1:skip
 import chalk from 'chalk';
 export class MMF1 {
-    constructor(srategy, file) {
+    constructor(strategy, file) {
         this.stack = [];
         this.currSuite = '';
         this.failed = 0;
@@ -17,17 +17,17 @@ export class MMF1 {
         // or <file> › <suite> › <test>
         // or <file> › <suite> › <test> › <nested-test>...
         this.passedNamesFlat = [];
-        this.srategy = srategy;
+        this.strategy = strategy;
         this.file = file;
     }
     _log(type, ...args) {
-        if (this.srategy === 'store') {
+        if (this.strategy === 'store') {
             this.output.push({
                 type,
                 message: args.join(' '),
             });
         }
-        else if (this.srategy === 'print') {
+        else if (this.strategy === 'print') {
             console.log(...args);
         }
     }

package/dist/commands/test/reporters/compact-reporter.d.ts

@@ -1,5 +1,6 @@
 import { MMF1 } from '../mmf1.js';
 import { Reporter } from './reporter.js';
+import { TestMode } from '../../../types.js';
 export declare class CompactReporter implements Reporter {
     #private;
     passed: number;
@@ -8,6 +9,6 @@ export declare class CompactReporter implements Reporter {
     passedFiles: number;
     failedFiles: number;
     addFiles(files: string[]): void;
-    addRun(file: string, mmf: MMF1, state: Promise<void>, _wasiMode: boolean): void;
+    addRun(file: string, mmf: MMF1, state: Promise<void>, _mode: TestMode): void;
     done(): boolean;
 }

package/dist/commands/test/reporters/compact-reporter.js

@@ -33,7 +33,7 @@ export class CompactReporter {
         __classPrivateFieldGet(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this);
         __classPrivateFieldGet(this, _CompactReporter_instances, "m", _CompactReporter_startTimer).call(this);
     }
-    addRun(file, mmf, state, _wasiMode) {
+    addRun(file, mmf, state, _mode) {
         __classPrivateFieldGet(this, _CompactReporter_runningFiles, "f").add(file);
         __classPrivateFieldGet(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this);
         state.then(() => {

package/dist/commands/test/reporters/files-reporter.d.ts

@@ -1,11 +1,12 @@
 import { MMF1 } from '../mmf1.js';
 import { Reporter } from './reporter.js';
+import { TestMode } from '../../../types.js';
 export declare class FilesReporter implements Reporter {
     #private;
     passed: number;
     failed: number;
     skipped: number;
     addFiles(files: string[]): void;
-    addRun(file: string, mmf: MMF1, state: Promise<void>, wasiMode: boolean): void;
+    addRun(file: string, mmf: MMF1, state: Promise<void>, mode: TestMode): void;
     done(): boolean;
 }

package/dist/commands/test/reporters/files-reporter.js

@@ -17,7 +17,7 @@ export class FilesReporter {
         console.log(`Test files: ${files.length}`);
         console.log('='.repeat(50));
     }
-    addRun(file, mmf, state, wasiMode) {
+    addRun(file, mmf, state, mode) {
         state.then(() => {
             this.passed += Number(mmf.failed === 0);
             this.failed += Number(mmf.failed !== 0);
@@ -28,7 +28,7 @@ export class FilesReporter {
                 console.log('-'.repeat(50));
             }
             else {
-                console.log(`${chalk.green('✓')} ${absToRel(file)} ${wasiMode ? chalk.gray('(wasi)') : ''}`);
+                console.log(`${chalk.green('✓')} ${absToRel(file)} ${mode === 'interpreter' ? '' : chalk.gray(`(${mode})`)}`);
             }
         });
     }

package/dist/commands/test/reporters/reporter.d.ts

@@ -1,6 +1,7 @@
+import { TestMode } from '../../../types.js';
 import { MMF1 } from '../mmf1.js';
 export interface Reporter {
     addFiles(files: string[]): void;
-    addRun(file: string, mmf: MMF1, state: Promise<void>, wasiMode: boolean): void;
+    addRun(file: string, mmf: MMF1, state: Promise<void>, mode: TestMode, progressive?: boolean): void;
     done(): boolean;
 }

package/dist/commands/test/reporters/silent-reporter.d.ts

@@ -1,5 +1,6 @@
 import { MMF1 } from '../mmf1.js';
 import { Reporter } from './reporter.js';
+import { TestMode } from '../../../types.js';
 export declare class SilentReporter implements Reporter {
     passed: number;
     failed: number;
@@ -8,6 +9,6 @@ export declare class SilentReporter implements Reporter {
     failedFiles: number;
     passedNamesFlat: string[];
     addFiles(_files: string[]): void;
-    addRun(file: string, mmf: MMF1, state: Promise<void>, _wasiMode: boolean): void;
+    addRun(file: string, mmf: MMF1, state: Promise<void>, _mode: TestMode): void;
     done(): boolean;
 }

package/dist/commands/test/reporters/silent-reporter.js

@@ -10,7 +10,7 @@ export class SilentReporter {
         this.passedNamesFlat = [];
     }
     addFiles(_files) { }
-    addRun(file, mmf, state, _wasiMode) {
+    addRun(file, mmf, state, _mode) {
         state.then(() => {
             this.passed += mmf.passed;
             this.failed += mmf.failed;

package/dist/commands/test/reporters/verbose-reporter.d.ts

@@ -1,11 +1,13 @@
 import { MMF1 } from '../mmf1.js';
 import { Reporter } from './reporter.js';
+import { TestMode } from '../../../types.js';
 export declare class VerboseReporter implements Reporter {
     #private;
     passed: number;
     failed: number;
     skipped: number;
     addFiles(files: string[]): void;
-    addRun(file: string, mmf: MMF1, state: Promise<void>, wasiMode: boolean): void;
+    addRun(file: string, mmf: MMF1, state: Promise<void>, mode: TestMode, progressive?: boolean): void;
     done(): boolean;
+    _printStart(file: string, mode: TestMode): void;
 }

package/dist/commands/test/reporters/verbose-reporter.js

@@ -27,17 +27,20 @@ export class VerboseReporter {
         }
         console.log('='.repeat(50));
     }
-    addRun(file, mmf, state, wasiMode) {
+    addRun(file, mmf, state, mode, progressive = false) {
+        if (progressive) {
+            this._printStart(file, mode);
+        }
         state.then(() => {
-            var _a, _b;
             this.passed += mmf.passed;
             this.failed += mmf.failed;
             this.skipped += mmf.skipped;
             if (mmf.passed === 0 && mmf.failed === 0) {
                 this.passed++;
             }
-            (__classPrivateFieldSet(this, _VerboseReporter_curFileIndex, (_b = __classPrivateFieldGet(this, _VerboseReporter_curFileIndex, "f"), _a = _b++, _b), "f"), _a) && console.log('-'.repeat(50));
-            console.log(`Running ${chalk.gray(absToRel(file))} ${wasiMode ? chalk.gray('(wasi)') : ''}`);
+            if (!progressive) {
+                this._printStart(file, mode);
+            }
             mmf.flush();
         });
     }
@@ -55,5 +58,10 @@ export class VerboseReporter {
             + (this.failed ? `, failed ${chalk[this.failed ? 'redBright' : 'gray'](this.failed)}` : ''));
         return this.failed === 0;
     }
+    _printStart(file, mode) {
+        var _a, _b;
+        (__classPrivateFieldSet(this, _VerboseReporter_curFileIndex, (_b = __classPrivateFieldGet(this, _VerboseReporter_curFileIndex, "f"), _a = _b++, _b), "f"), _a) && console.log('-'.repeat(50));
+        console.log(`Running ${chalk.gray(absToRel(file))} ${mode === 'interpreter' ? '' : chalk.gray(`(${mode})`)}`);
+    }
 }
 _VerboseReporter_startTime = new WeakMap(), _VerboseReporter_curFileIndex = new WeakMap();

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

@@ -1,11 +1,13 @@
 import { Reporter } from './reporters/reporter.js';
+import { TestMode } from '../../types.js';
 type ReporterName = 'verbose' | 'files' | 'compact' | 'silent';
-type TestMode = 'interpreter' | 'wasi';
-export declare function test(filter?: string, { watch, reporter, mode }?: {
-    watch?: boolean | undefined;
-    reporter?: ReporterName | undefined;
-    mode?: TestMode | undefined;
-}): Promise<void>;
-export declare function runAll(reporterName?: ReporterName, filter?: string, mode?: TestMode): Promise<boolean>;
-export declare function testWithReporter(reporter: Reporter, filter?: string, mode?: TestMode): Promise<boolean>;
+type ReplicaName = 'dfx' | 'pocket-ic';
+type TestOptions = {
+    watch: boolean;
+    reporter: ReporterName;
+    mode: TestMode;
+    replica: ReplicaName;
+};
+export declare function test(filter?: string, options?: Partial<TestOptions>): Promise<void>;
+export declare function testWithReporter(reporterName: ReporterName | Reporter | undefined, filter: string | undefined, defaultMode: TestMode | undefined, replicaType: ReplicaName, watch?: boolean): Promise<boolean>;
 export {};