ic-mops 0.36.1 → 0.37.0

package/dist/commands/toolchain/moc.js

@@ -1,22 +1,32 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { globalCacheDir } from '../../mops.js';
-import { downloadGithubRelease } from './toolchain-utils.js';
+import * as toolchainUtils from './toolchain-utils.js';
 let cacheDir = path.join(globalCacheDir, 'moc');
+export let repo = 'dfinity/motoko';
+export let getLatestReleaseTag = async () => {
+    return toolchainUtils.getLatestReleaseTag(repo);
+};
+export let getReleases = async () => {
+    return toolchainUtils.getReleases(repo);
+};
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
     return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'moc'));
 };
-export let download = async (version, { silent = false } = {}) => {
+export let download = async (version, { silent = false, verbose = false } = {}) => {
     if (process.platform == 'win32') {
-        console.log('Windows is not supported. Please use WSL');
+        console.error('Windows is not supported. Please use WSL');
         process.exit(1);
     }
     if (!version) {
-        console.log('version is not defined');
+        console.error('version is not defined');
         process.exit(1);
     }
     if (isCached(version)) {
+        if (verbose) {
+            console.log(`moc ${version} is already installed`);
+        }
         return;
     }
     let url;
@@ -31,6 +41,8 @@ export let download = async (version, { silent = false } = {}) => {
         let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
         url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
     }
-    silent || console.log(`Downloading ${url}`);
-    await downloadGithubRelease(url, path.join(cacheDir, version));
+    if (verbose && !silent) {
+        console.log(`Downloading ${url}`);
+    }
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
 };

package/dist/commands/toolchain/mocv.js

@@ -228,7 +228,6 @@ let updateShellConfig = async ({ reset = false, yes = false } = {}) => {
         }
         fs.writeFileSync(configFile, data);
     }
-    ;
     console.log('Success!');
     // console.log(`Run "source ${configFile}" to apply changes`);
     console.log('Restart terminal to apply changes');

package/dist/commands/toolchain/pocket-ic.d.ts

@@ -0,0 +1,12 @@
+export declare let repo: string;
+export declare let getLatestReleaseTag: () => Promise<string>;
+export declare let getReleases: () => Promise<{
+    tag_name: string;
+    published_at: Date;
+    draft: boolean;
+}[]>;
+export declare let isCached: (version: string) => boolean;
+export declare let download: (version: string, { silent, verbose }?: {
+    silent?: boolean | undefined;
+    verbose?: boolean | undefined;
+}) => Promise<void>;

package/dist/commands/toolchain/pocket-ic.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { globalCacheDir } from '../../mops.js';
+import * as toolchainUtils from './toolchain-utils.js';
+let cacheDir = path.join(globalCacheDir, 'pocket-ic');
+export let repo = 'dfinity/pocketic';
+export let getLatestReleaseTag = async () => {
+    return '1.0.0';
+    // return toolchainUtils.getLatestReleaseTag(repo);
+};
+export let getReleases = async () => {
+    // return toolchainUtils.getReleases(repo);
+    return [
+        // {
+        // 	tag_name: '2.0.1',
+        // 	published_at: new Date('2023-11-23'),
+        // 	draft: false,
+        // },
+        // {
+        // 	tag_name: '2.0.0',
+        // 	published_at: new Date('2023-11-21'),
+        // 	draft: false,
+        // },
+        {
+            tag_name: '1.0.0',
+            published_at: new Date('2023-10-12'),
+            draft: false,
+        },
+    ];
+};
+export let isCached = (version) => {
+    let dir = path.join(cacheDir, version);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'pocket-ic'));
+};
+export let download = async (version, { silent = false, verbose = false } = {}) => {
+    if (!version) {
+        console.error('version is not defined');
+        process.exit(1);
+    }
+    if (version !== '1.0.0') {
+        console.error('Currently only pocket-ic 1.0.0 is supported');
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        if (verbose) {
+            console.log(`pocket-ic ${version} is already installed`);
+        }
+        return;
+    }
+    let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
+    let arch = 'x86_64';
+    let hashes = {
+        // '2.0.1': '69e1408347723dbaa7a6cd2faa9b65c42abbe861',
+        // '2.0.0': '29ec86dc9f9ca4691d4d4386c8b2aa41e14d9d16',
+        '1.0.0': '307d5847c1d2fe1f5e19181c7d0fcec23f4658b3',
+    };
+    let url = `https://download.dfinity.systems/ic/${hashes[version]}/openssl-static-binaries/${arch}-${platfrom}/pocket-ic.gz`;
+    if (verbose && !silent) {
+        console.log(`Downloading ${url}`);
+    }
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
+};

package/dist/commands/toolchain/toolchain-utils.d.ts

@@ -1,3 +1,3 @@
-export declare let downloadGithubRelease: (url: string, dest: string) => Promise<void>;
-export declare let getLatestReleaseTag: (repo: string) => Promise<string | undefined>;
+export declare let downloadAndExtract: (url: string, dest: string) => Promise<void>;
+export declare let getLatestReleaseTag: (repo: string) => Promise<string>;
 export declare let getReleases: (repo: string) => Promise<any>;

package/dist/commands/toolchain/toolchain-utils.js

@@ -1,4 +1,6 @@
 import path from 'node:path';
+import { unzipSync } from 'node:zlib';
+import { chmodSync } from 'node:fs';
 import fs from 'fs-extra';
 import decompress from 'decompress';
 import decompressTarxz from 'decomp-tarxz';
@@ -6,7 +8,7 @@ import { deleteSync } from 'del';
 import { Octokit } from 'octokit';
 import tar from 'tar';
 import { getRootDir } from '../../mops.js';
-export let downloadGithubRelease = async (url, dest) => {
+export let downloadAndExtract = async (url, dest) => {
     let res = await fetch(url);
     if (res.status !== 200) {
         console.error(`ERROR ${res.status} ${url}`);
@@ -20,25 +22,34 @@ export let downloadGithubRelease = async (url, dest) => {
     fs.writeFileSync(archive, buffer);
     fs.mkdirSync(dest, { recursive: true });
     if (archive.endsWith('.xz')) {
-        await decompress(archive, dest, {
-            strip: 1,
+        await decompress(archive, tmpDir, {
             plugins: [decompressTarxz()],
         }).catch(() => {
             deleteSync([tmpDir]);
         });
+        fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), dest, { recursive: true });
     }
-    else {
+    else if (archive.endsWith('tar.gz')) {
         await tar.extract({
             file: archive,
             cwd: dest,
         });
     }
+    else if (archive.endsWith('.gz')) {
+        let destFile = path.join(dest, path.parse(archive).name);
+        fs.writeFileSync(destFile, unzipSync(buffer));
+        chmodSync(destFile, 0o700);
+    }
     deleteSync([tmpDir], { force: true });
 };
 export let getLatestReleaseTag = async (repo) => {
     let releases = await getReleases(repo);
     let release = releases.find((release) => !release.prerelease && !release.draft);
-    return release?.tag_name;
+    if (!release?.tag_name) {
+        console.error(`Failed to fetch latest release tag for ${repo}`);
+        process.exit(1);
+    }
+    return release.tag_name.replace(/^v/, '');
 };
 export let getReleases = async (repo) => {
     let octokit = new Octokit;
@@ -52,5 +63,10 @@ export let getReleases = async (repo) => {
         console.log('Releases fetch error');
         process.exit(1);
     }
-    return res.data;
+    return res.data.map((release) => {
+        return {
+            ...release,
+            tag_name: release.tag_name.replace(/^v/, ''),
+        };
+    });
 };

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

@@ -1,4 +1,8 @@
+export declare let repo: string;
+export declare let getLatestReleaseTag: () => Promise<string>;
+export declare let getReleases: () => Promise<any>;
 export declare let isCached: (version: string) => boolean;
-export declare let download: (version: string, { silent }?: {
+export declare let download: (version: string, { silent, verbose }?: {
     silent?: boolean | undefined;
+    verbose?: boolean | undefined;
 }) => Promise<void>;

package/dist/commands/toolchain/wasmtime.js

@@ -1,23 +1,35 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { globalCacheDir } from '../../mops.js';
-import { downloadGithubRelease } from './toolchain-utils.js';
+import * as toolchainUtils from './toolchain-utils.js';
 let cacheDir = path.join(globalCacheDir, 'wasmtime');
+export let repo = 'bytecodealliance/wasmtime';
+export let getLatestReleaseTag = async () => {
+    return toolchainUtils.getLatestReleaseTag(repo);
+};
+export let getReleases = async () => {
+    return toolchainUtils.getReleases(repo);
+};
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
     return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'wasmtime'));
 };
-export let download = async (version, { silent = false } = {}) => {
+export let download = async (version, { silent = false, verbose = false } = {}) => {
     if (!version) {
         console.error('version is not defined');
         process.exit(1);
     }
     if (isCached(version)) {
+        if (verbose) {
+            console.log(`wasmtime ${version} is already installed`);
+        }
         return;
     }
     let platfrom = process.platform == 'darwin' ? 'macos' : 'linux';
     let arch = process.arch.startsWith('arm') ? 'aarch64' : 'x86_64';
     let url = `https://github.com/bytecodealliance/wasmtime/releases/download/v${version}/wasmtime-v${version}-${arch}-${platfrom}.tar.xz`;
-    silent || console.log(`Downloading ${url}`);
-    await downloadGithubRelease(url, path.join(cacheDir, version));
+    if (verbose && !silent) {
+        console.log(`Downloading ${url}`);
+    }
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
 };

package/dist/integrity.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
-import { getDependencyType, getRootDir } from './mops.js';
+import { getDependencyType, getRootDir, readConfig } from './mops.js';
 import { mainActor } from './api/actors.js';
 import { resolvePackages } from './resolve-packages.js';
 export async function checkIntegrity(lock) {
@@ -48,6 +48,18 @@ export function getLocalFileHash(fileId) {
 function getMopsTomlHash() {
     return bytesToHex(sha256(fs.readFileSync(getRootDir() + '/mops.toml')));
 }
+function getMopsTomlDepsHash() {
+    let config = readConfig();
+    let deps = config.dependencies || {};
+    let devDeps = config['dev-dependencies'] || {};
+    let allDeps = { ...deps, ...devDeps };
+    // sort allDeps by key
+    let sortedDeps = Object.keys(allDeps).sort().reduce((acc, key) => {
+        acc[key] = allDeps[key]?.version || allDeps[key]?.repo || allDeps[key]?.path || '';
+        return acc;
+    }, {});
+    return bytesToHex(sha256(JSON.stringify(sortedDeps)));
+}
 // compare hashes of local files with hashes from the registry
 export async function checkRemote() {
     let fileHashesFromRegistry = await getFileHashesFromRegistry();
@@ -70,15 +82,15 @@ export async function updateLockFile() {
     // if lock file exists and mops.toml hasn't changed, don't update it
     if (fs.existsSync(lockFile)) {
         let lockFileJson = JSON.parse(fs.readFileSync(lockFile).toString());
-        let mopsTomlHash = getMopsTomlHash();
-        if (mopsTomlHash === lockFileJson.mopsTomlHash) {
+        let mopsTomlDepsHash = getMopsTomlDepsHash();
+        if (mopsTomlDepsHash === lockFileJson.mopsTomlDepsHash) {
             return;
         }
     }
     let fileHashes = await getFileHashesFromRegistry();
     let lockFileJson = {
-        version: 1,
-        mopsTomlHash: getMopsTomlHash(),
+        version: 2,
+        mopsTomlDepsHash: getMopsTomlDepsHash(),
         hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
             acc[packageId] = fileHashes.reduce((acc, [fileId, hash]) => {
                 acc[fileId] = bytesToHex(new Uint8Array(hash));
@@ -101,21 +113,34 @@ export async function checkLockFile(force = false) {
         }
         return;
     }
-    let lockFileJson = JSON.parse(fs.readFileSync(lockFile).toString());
+    let lockFileJsonGeneric = JSON.parse(fs.readFileSync(lockFile).toString());
     let packageIds = await getResolvedMopsPackageIds();
     // check lock file version
-    if (lockFileJson.version !== 1) {
+    if (lockFileJsonGeneric.version !== 1 && lockFileJsonGeneric.version !== 2) {
         console.error('Integrity check failed');
-        console.error(`Invalid lock file version: ${lockFileJson.version}. Supported versions: 1`);
+        console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: 1`);
         process.exit(1);
     }
-    // check mops.toml hash
-    if (lockFileJson.mopsTomlHash !== getMopsTomlHash()) {
-        console.error('Integrity check failed');
-        console.error('Mismatched mops.toml hash');
-        console.error(`Locked hash: ${lockFileJson.mopsTomlHash}`);
-        console.error(`Actual hash: ${getMopsTomlHash()}`);
-        process.exit(1);
+    let lockFileJson = lockFileJsonGeneric;
+    // V1: check mops.toml hash
+    if (lockFileJson.version === 1) {
+        if (lockFileJson.mopsTomlHash !== getMopsTomlHash()) {
+            console.error('Integrity check failed');
+            console.error('Mismatched mops.toml hash');
+            console.error(`Locked hash: ${lockFileJson.mopsTomlHash}`);
+            console.error(`Actual hash: ${getMopsTomlHash()}`);
+            process.exit(1);
+        }
+    }
+    // V2: check mops.toml deps hash
+    if (lockFileJson.version === 2) {
+        if (lockFileJson.mopsTomlDepsHash !== getMopsTomlDepsHash()) {
+            console.error('Integrity check failed');
+            console.error('Mismatched mops.toml dependencies hash');
+            console.error(`Locked hash: ${lockFileJson.mopsTomlDepsHash}`);
+            console.error(`Actual hash: ${getMopsTomlDepsHash()}`);
+            process.exit(1);
+        }
     }
     // check number of packages
     if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {

package/dist/mops.js

@@ -93,7 +93,7 @@ export let getIdentity = async () => {
 };
 export function getClosestConfigFile(dir = process.cwd()) {
     if (!path.basename(dir)) {
-        throw '';
+        return '';
     }
     let configFile = path.join(dir, 'mops.toml');
     if (fs.existsSync(configFile)) {
@@ -182,7 +182,7 @@ export function readConfig(configFile = getClosestConfigFile()) {
     return toml;
 }
 export function writeConfig(config, configFile = getClosestConfigFile()) {
-    let resConfig = { ...config };
+    let resConfig = JSON.parse(JSON.stringify(config));
     let deps = resConfig.dependencies || {};
     Object.entries(config.dependencies || {}).forEach(([name, { repo, path, version }]) => {
         deps[name] = repo || path || version;

package/dist/package.json

@@ -1,9 +1,10 @@
 {
   "name": "ic-mops",
-  "version": "0.36.1",
+  "version": "0.37.0",
   "type": "module",
   "bin": {
-    "mops": "dist/cli.js"
+    "mops": "dist/bin/mops.js",
+    "moc-wrapper": "bin/moc-wrapper.sh"
   },
   "files": [
     "*",
@@ -37,7 +38,6 @@
     "@dfinity/identity": "^0.19.3",
     "@dfinity/identity-secp256k1": "^0.19.3",
     "@dfinity/principal": "^0.19.3",
-    "@hadronous/pic": "0.2.0",
     "@iarna/toml": "^2.2.5",
     "@noble/hashes": "1.3.2",
     "as-table": "^1.0.55",
@@ -45,13 +45,15 @@
     "camelcase": "^7.0.1",
     "chalk": "^5.3.0",
     "chokidar": "^3.5.3",
-    "commander": "^11.0.0",
+    "commander": "11.1.0",
     "debounce": "^1.2.1",
+    "decomp-tarxz": "0.1.1",
     "decompress": "^4.2.1",
     "del": "^7.0.0",
     "dhall-to-json-cli": "^1.7.6",
     "eslint": "^8.45.0",
     "execa": "7.1.1",
+    "fs-extra": "11.2.0",
     "get-folder-size": "^4.0.0",
     "glob": "^10.3.3",
     "globby": "^13.2.2",
@@ -63,7 +65,9 @@
     "minimatch": "^9.0.3",
     "ncp": "^2.0.0",
     "node-fetch": "^3.3.2",
+    "octokit": "3.1.2",
     "pem-file": "^1.0.1",
+    "pic-ic": "0.3.2",
     "prompts": "^2.4.2",
     "stream-to-promise": "^3.0.0",
     "string-width": "7.0.0",
@@ -73,6 +77,7 @@
     "@tsconfig/strictest": "^2.0.1",
     "@types/debounce": "^1.2.1",
     "@types/decompress": "^4.2.4",
+    "@types/fs-extra": "11.0.4",
     "@types/glob": "^8.1.0",
     "@types/ncp": "^2.0.5",
     "@types/node": "^20.4.4",

package/dist/pic-js/examples/clock/tests/clock/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pic-js/examples/clock/tests/clock/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idlFactory = void 0;
+var clock_did_1 = require("../../declarations/clock.did");
+Object.defineProperty(exports, "idlFactory", { enumerable: true, get: function () { return clock_did_1.idlFactory; } });

package/dist/pic-js/examples/clock/tests/jest.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'jest';
+declare const config: Config;
+export default config;

package/dist/pic-js/examples/clock/tests/jest.config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    watch: false,
+    preset: 'ts-jest/presets/js-with-ts',
+    testEnvironment: 'node',
+};
+exports.default = config;

package/dist/pic-js/examples/clock/tests/src/clock.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pic-js/examples/clock/tests/src/clock.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const principal_1 = require("@dfinity/principal");
+const pic_1 = require("@hadronous/pic");
+const clock_1 = require("../clock");
+const WASM_PATH = (0, node_path_1.resolve)(__dirname, '..', '..', '..', '..', '.dfx', 'local', 'canisters', 'clock', 'clock.wasm');
+describe('Clock', () => {
+    let actor;
+    let pic;
+    let canisterId;
+    beforeEach(async () => {
+        pic = await pic_1.PocketIc.create();
+        const fixture = await pic.setupCanister(clock_1.idlFactory, WASM_PATH);
+        actor = fixture.actor;
+        canisterId = fixture.canisterId;
+    });
+    afterEach(async () => {
+        await pic.tearDown();
+    });
+    it('should create the correct canister', async () => {
+        const canisterExists = await pic.checkCanisterExists(canisterId);
+        expect(canisterExists).toBe(true);
+    });
+    it('should not create any other canister', async () => {
+        const otherCanisterId = principal_1.Principal.fromUint8Array(new Uint8Array([0]));
+        const canisterExists = await pic.checkCanisterExists(otherCanisterId);
+        expect(canisterExists).toBe(false);
+    });
+    it('should set and get canister cycles', async () => {
+        const cycles = await pic.getCyclesBalance(canisterId);
+        const cyclesToAdd = 1000000;
+        const updatedCyclesBalance = await pic.addCycles(canisterId, cyclesToAdd);
+        const fetchUpdatedCyclesBalance = await pic.getCyclesBalance(canisterId);
+        expect(updatedCyclesBalance).toEqual(cycles + cyclesToAdd);
+        expect(fetchUpdatedCyclesBalance).toEqual(updatedCyclesBalance);
+    });
+    it.each([1, 10, 1000, 100000])('should return the correct time after %d second(s)', async (timeToAdvanceS) => {
+        await pic.resetTime();
+        await pic.tick();
+        const timeToAdvanceMs = timeToAdvanceS * 1000;
+        const initialTime = await actor.get();
+        await pic.advanceTime(timeToAdvanceMs);
+        await pic.tick();
+        const finalTime = await actor.get();
+        expect(finalTime).toEqual(initialTime + BigInt(timeToAdvanceMs));
+    });
+});

package/dist/pic-js/examples/counter/tests/counter/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pic-js/examples/counter/tests/counter/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idlFactory = void 0;
+var counter_did_1 = require("../../declarations/counter.did");
+Object.defineProperty(exports, "idlFactory", { enumerable: true, get: function () { return counter_did_1.idlFactory; } });

package/dist/pic-js/examples/counter/tests/jest.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'jest';
+declare const config: Config;
+export default config;

package/dist/pic-js/examples/counter/tests/jest.config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    watch: false,
+    preset: 'ts-jest/presets/js-with-ts',
+    testEnvironment: 'node',
+};
+exports.default = config;

package/dist/pic-js/examples/counter/tests/src/counter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pic-js/examples/counter/tests/src/counter.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const pic_1 = require("@hadronous/pic");
+const counter_1 = require("../counter");
+const WASM_PATH = (0, node_path_1.resolve)(__dirname, '..', '..', '..', '..', '.dfx', 'local', 'canisters', 'counter', 'counter.wasm');
+describe('Counter', () => {
+    let pic;
+    let actor;
+    let canisterId;
+    beforeEach(async () => {
+        pic = await pic_1.PocketIc.create();
+        const fixture = await pic.setupCanister(counter_1.idlFactory, WASM_PATH);
+        actor = fixture.actor;
+        canisterId = fixture.canisterId;
+    });
+    afterEach(async () => {
+        await pic.tearDown();
+    });
+    it('should start at 0', async () => {
+        const result = await actor.get();
+        expect(result).toEqual(0n);
+    });
+    it.each([42n, 306n, 7n])('should set the counter to %d', async (input) => {
+        await actor.set(input);
+        const result = await actor.get();
+        expect(result).toEqual(input);
+    });
+    it('should increment from 0', async () => {
+        const initialCount = await actor.get();
+        await actor.inc();
+        const countAfterFirstInc = await actor.get();
+        await actor.inc();
+        const finalCount = await actor.get();
+        expect(initialCount).toEqual(0n);
+        expect(countAfterFirstInc).toEqual(1n);
+        expect(finalCount).toEqual(2n);
+    });
+    it.each([42n, 306n, 7n])('should increment from %d', async (input) => {
+        await actor.set(input);
+        const initialCount = await actor.get();
+        await actor.inc();
+        const countAfterFirstInc = await actor.get();
+        await actor.inc();
+        const finalCount = await actor.get();
+        expect(initialCount).toEqual(input);
+        expect(countAfterFirstInc).toEqual(input + 1n);
+        expect(finalCount).toEqual(input + 2n);
+    });
+    it.each([42n, 306n, 7n])('should decrement from %d', async (input) => {
+        await actor.set(input);
+        const initialCount = await actor.get();
+        await actor.dec();
+        const countAfterFirstDec = await actor.get();
+        await actor.dec();
+        const finalCount = await actor.get();
+        expect(initialCount).toEqual(input);
+        expect(countAfterFirstDec).toEqual(input - 1n);
+        expect(finalCount).toEqual(input - 2n);
+    });
+    it('should fail to decrement from 0', async () => {
+        const initialCount = await actor.get();
+        expect(initialCount).toEqual(0n);
+        await expect(actor.dec()).rejects.toThrow('Natural subtraction underflow');
+    });
+    it('should upgrade the canister', async () => {
+        await actor.inc();
+        const preUpgradeCount = await actor.get();
+        await pic.upgradeCanister(canisterId, WASM_PATH);
+        const postUpgradeCount = await actor.get();
+        expect(preUpgradeCount).toEqual(postUpgradeCount);
+    });
+    it('should reinstall the canister', async () => {
+        await actor.inc();
+        const preReinstallCount = await actor.get();
+        await pic.reinstallCode(canisterId, WASM_PATH);
+        const postReinstallCount = await actor.get();
+        expect(postReinstallCount).not.toEqual(preReinstallCount);
+    });
+});

package/dist/pic-js/examples/todo/tests/jest.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'jest';
+declare const config: Config;
+export default config;

package/dist/pic-js/examples/todo/tests/jest.config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    watch: false,
+    preset: 'ts-jest/presets/js-with-ts',
+    testEnvironment: 'node',
+};
+exports.default = config;

package/dist/pic-js/examples/todo/tests/src/todo.spec.d.ts

@@ -0,0 +1 @@
+export {};