ic-mops 0.45.4-pre.0 → 1.0.0

package/commands/replica.ts

@@ -0,0 +1,239 @@
+import process from 'node:process';
+import {ChildProcessWithoutNullStreams, execSync, spawn} from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import {PassThrough} from 'node:stream';
+
+import {IDL} from '@dfinity/candid';
+import {Actor, HttpAgent} from '@dfinity/agent';
+import {PocketIc, PocketIcServer} from 'pic-ic';
+
+import {readConfig} from '../mops.js';
+import {toolchain} from './toolchain/index.js';
+
+type StartOptions = {
+	type ?: 'dfx' | 'pocket-ic';
+	dir ?: string;
+	verbose ?: boolean;
+	silent ?: boolean;
+};
+
+export class Replica {
+	type : 'dfx' | 'pocket-ic' = 'dfx';
+	verbose = false;
+	canisters : Record<string, {cwd : string; canisterId : string; actor : any; stream : PassThrough;}> = {};
+	pocketIcServer ?: PocketIcServer;
+	pocketIc ?: PocketIc;
+	dfxProcess ?: ChildProcessWithoutNullStreams;
+	dir : string = ''; // absolute path (/.../.mops/.test/)
+	ttl = 60;
+
+	async start({type, dir, verbose, silent} : StartOptions = {}) {
+		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 as ChildProcessWithoutNullStreams);
+		}
+	}
+
+	_attachCanisterLogHandler(proc : ChildProcessWithoutNullStreams) {
+		let curData = '';
+		proc.stderr.on('data', (data) => {
+			curData = curData + data.toString();
+
+			if (curData.includes('\n')) {
+				let chunk = curData.split('\n').slice(0, -1).join('\n');
+				let matches = [...chunk.matchAll(/\[Canister ([a-z0-9-]+)\] (.*)/g)];
+
+				for (let match of matches) {
+					let [, canisterId, msg] = match;
+					let stream = this.getCanisterStream(canisterId || '');
+					if (stream) {
+						stream.write(msg);
+					}
+				}
+
+				if (matches.length) {
+					curData = curData.split('\n').slice(-1).join('\n');
+				}
+			}
+		});
+	}
+
+	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 : string, wasm : string, idlFactory : IDL.InterfaceFactory, cwd : string = 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 : string) : unknown {
+		if (!this.canisters[name]) {
+			throw new Error(`Canister ${name} not found`);
+		}
+		return this.canisters[name]?.actor;
+	}
+
+	getCanister(name : string) {
+		return this.canisters[name];
+	}
+
+	getCanisterId(name : string) : string {
+		return this.canisters[name]?.canisterId || '';
+	}
+
+	getCanisterStream(canisterId : string) : PassThrough | null {
+		for (let canister of Object.values(this.canisters)) {
+			if (canister.canisterId === canisterId) {
+				return canister.stream;
+			}
+		}
+		return null;
+	}
+
+	dfxJson(canisterName : string, wasmPath = 'canister.wasm', didPath = 'canister.did') {
+		let canisters : Record<string, any> = {};
+		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/commands/sources.ts

@@ -4,13 +4,12 @@ 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' as 'warning' | 'error' | '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]) => {

package/commands/test/mmf1.ts

@@ -15,7 +15,7 @@ export class MMF1 {
 	failed = 0;
 	passed = 0;
 	skipped = 0;
-	srategy : Strategy;
+	strategy : Strategy;
 	output : {
 		type : MessageType;
 		message : string;
@@ -27,19 +27,19 @@ export class MMF1 {
 	// or <file> › <suite> › <test> › <nested-test>...
 	passedNamesFlat : string[] = [];
 
-	constructor(srategy : Strategy, file : string) {
-		this.srategy = srategy;
+	constructor(strategy : Strategy, file : string) {
+		this.strategy = strategy;
 		this.file = file;
 	}
 
 	_log(type : MessageType,  ...args : string[]) {
-		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);
 		}
 	}
@@ -83,7 +83,11 @@ export class MMF1 {
 	}
 
 	_testEnd(name : string) {
-		if (name !== this.stack.pop()) {
+		let last = this.stack.pop();
+		if (name !== last) {
+			console.error(`Expected test name "${last}" but got "${name}"`);
+			console.error(`Stack: ${this.stack.join(' › ')}`);
+			console.error(`File: ${this.file}`);
 			throw 'mmf1._testEnd: start and end test mismatch';
 		}
 		this._status(name, 'pass');

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

@@ -3,6 +3,7 @@ import logUpdate from 'log-update';
 import {absToRel} from '../utils.js';
 import {MMF1} from '../mmf1.js';
 import {Reporter} from './reporter.js';
+import {TestMode} from '../../../types.js';
 
 export class CompactReporter implements Reporter {
 	passed = 0;
@@ -23,7 +24,7 @@ export class CompactReporter implements Reporter {
 		this.#startTimer();
 	}
 
-	addRun(file : string, mmf : MMF1, state : Promise<void>, _wasiMode : boolean) {
+	addRun(file : string, mmf : MMF1, state : Promise<void>, _mode : TestMode) {
 		this.#runningFiles.add(file);
 		this.#log();
 

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

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import {absToRel} from '../utils.js';
 import {MMF1} from '../mmf1.js';
 import {Reporter} from './reporter.js';
+import {TestMode} from '../../../types.js';
 
 export class FilesReporter implements Reporter {
 	passed = 0;
@@ -15,7 +16,7 @@ export class FilesReporter implements Reporter {
 		console.log('='.repeat(50));
 	}
 
-	addRun(file : string, mmf : MMF1, state : Promise<void>, wasiMode : boolean) {
+	addRun(file : string, mmf : MMF1, state : Promise<void>, mode : TestMode) {
 		state.then(() => {
 			this.passed += Number(mmf.failed === 0);
 			this.failed += Number(mmf.failed !== 0);
@@ -27,7 +28,7 @@ export class FilesReporter implements Reporter {
 				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/commands/test/reporters/reporter.ts

@@ -1,7 +1,8 @@
+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/commands/test/reporters/silent-reporter.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import {absToRel} from '../utils.js';
 import {MMF1} from '../mmf1.js';
 import {Reporter} from './reporter.js';
+import {TestMode} from '../../../types.js';
 
 export class SilentReporter implements Reporter {
 	passed = 0;
@@ -13,7 +14,7 @@ export class SilentReporter implements Reporter {
 
 	addFiles(_files : string[]) {}
 
-	addRun(file : string, mmf : MMF1, state : Promise<void>, _wasiMode : boolean) {
+	addRun(file : string, mmf : MMF1, state : Promise<void>, _mode : TestMode) {
 		state.then(() => {
 			this.passed += mmf.passed;
 			this.failed += mmf.failed;

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

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import {absToRel} from '../utils.js';
 import {MMF1} from '../mmf1.js';
 import {Reporter} from './reporter.js';
+import {TestMode} from '../../../types.js';
 
 export class VerboseReporter implements Reporter {
 	passed = 0;
@@ -19,7 +20,11 @@ export class VerboseReporter implements Reporter {
 		console.log('='.repeat(50));
 	}
 
-	addRun(file : string, mmf : MMF1, state : Promise<void>, wasiMode : boolean) {
+	addRun(file : string, mmf : MMF1, state : Promise<void>, mode : TestMode, progressive = false) {
+		if (progressive) {
+			this._printStart(file, mode);
+		}
+
 		state.then(() => {
 			this.passed += mmf.passed;
 			this.failed += mmf.failed;
@@ -28,9 +33,9 @@ export class VerboseReporter implements Reporter {
 			if (mmf.passed === 0 && mmf.failed === 0) {
 				this.passed++;
 			}
-
-			this.#curFileIndex++ && console.log('-'.repeat(50));
-			console.log(`Running ${chalk.gray(absToRel(file))} ${wasiMode ? chalk.gray('(wasi)') : ''}`);
+			if (!progressive) {
+				this._printStart(file, mode);
+			}
 			mmf.flush();
 		});
 	}
@@ -52,4 +57,9 @@ export class VerboseReporter implements Reporter {
 
 		return this.failed === 0;
 	}
+
+	_printStart(file : string, mode : TestMode) {
+		this.#curFileIndex++ && console.log('-'.repeat(50));
+		console.log(`Running ${chalk.gray(absToRel(file))} ${mode === 'interpreter' ? '' : chalk.gray(`(${mode})`)}`);
+	}
 }