microvium/dist/test/modules/modules.test.js

A compact, embeddable scripting engine for microcontrollers for executing small scripts written in a subset of JavaScript.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const chai_1 = require("chai");
const lib_1 = require("../../lib");
const fs_extra_1 = __importDefault(require("fs-extra"));
// TODO: These tests don't test the mutability of exported bindings
suite('modules', function () {
    test('basic-import', () => {
        let printLog = [];
        const vm = lib_1.Microvium.create();
        vm.globalThis.print = (s) => printLog.push(s);
        const aModule = {
            default: 1,
            b: 2,
            d: 3,
            f: 4
        };
        const module = vm.evaluateModule({
            sourceText: `
        import a from 'aModule';
        import { b } from 'aModule';
        import c, { d } from 'aModule';
        import * as e from 'aModule';
        import { f as g } from 'aModule';
        print(a); // 1
        print(b); // 2
        print(c); // 1
        print(3); // 3
        print(e); // { ... }
        print(g); // 4

        export const h = 5, i = 6;
        export function j() {
          print(h);
          return 7;
        }
      `,
            importDependency(specifier) {
                chai_1.assert.equal(specifier, 'aModule');
                return aModule;
            }
        });
        chai_1.assert.deepEqual(printLog, [
            1,
            2,
            1,
            3,
            { default: 1, b: 2, d: 3, f: 4 },
            4
        ]);
        printLog = [];
        chai_1.assert.equal(module.h, 5);
        chai_1.assert.equal(module.i, 6);
        chai_1.assert.equal(module.j(), 7);
        chai_1.assert.deepEqual(printLog, [5]);
    });
    test('module-source-import', () => {
        const m1 = {
            sourceText: `
        import { y } from './m2';
        print('m1 importing');
        export const x = 5;
        print(y); // print 6
      `,
            importDependency: specifier => {
                chai_1.assert.equal(specifier, './m2');
                return vm.evaluateModule(m2);
            }
        };
        const m2 = {
            sourceText: `
        import { x } from './m1'
        print('m2 importing');
        export const y = 6;
        print(x); // Should print 'undefined' if the module cache is working
      `,
            importDependency: specifier => {
                chai_1.assert.equal(specifier, './m1');
                return vm.evaluateModule(m1);
            }
        };
        let printLog = [];
        const vm = lib_1.Microvium.create();
        vm.globalThis.print = (s) => printLog.push(s);
        vm.evaluateModule(m1);
        chai_1.assert.deepEqual(printLog, [
            'm2 importing',
            undefined,
            'm1 importing',
            6
        ]);
    });
    test('shared-import', () => {
        const m1 = {
            sourceText: `
        import { x } from './m3';
        export function inc() { x++; }
        vmExport(1, inc);
      `,
            importDependency: specifier => {
                chai_1.assert.equal(specifier, './m3');
                return vm.evaluateModule(m3);
            }
        };
        const m2 = {
            sourceText: `
        import { x } from './m3';
        export function printX() { print(x); }
        vmExport(2, printX);
      `,
            importDependency: specifier => {
                chai_1.assert.equal(specifier, './m3');
                return vm.evaluateModule(m3);
            }
        };
        const m3 = {
            sourceText: `
        export let x = 1;
      `
        };
        let printLog = [];
        const vm = lib_1.Microvium.create();
        vm.globalThis.vmExport = vm.vmExport;
        vm.globalThis.print = (s) => printLog.push(s);
        const { inc } = vm.evaluateModule(m1);
        const { printX } = vm.evaluateModule(m2);
        printX(); // Prints 1
        inc();
        printX(); // Prints 2, showing that x is shared
        chai_1.assert.deepEqual(printLog, [
            1,
            2,
        ]);
    });
    test('class-import', () => {
        const m1 = {
            sourceText: `
        import { MyClass } from './m2'
        vmExport(1, () => {
          const inst = new MyClass()
          print(inst.x)
          print(inst.myMethod())
          print(inst.myMethod())
        });
      `,
            importDependency: specifier => {
                chai_1.assert.equal(specifier, './m2');
                return vm.evaluateModule(m2);
            }
        };
        const m2 = {
            sourceText: `
        export class MyClass {
          constructor() { this.x = 5 }
          myMethod() { return ++this.x }
        }
      `
        };
        let printLog = [];
        const vm = lib_1.Microvium.create();
        vm.globalThis.vmExport = vm.vmExport;
        vm.globalThis.print = (s) => printLog.push(s);
        vm.evaluateModule(m1);
        vm.resolveExport(1)();
        chai_1.assert.deepEqual(printLog, [
            5,
            6,
            7,
        ]);
    });
    test('default-fetcher', () => {
        const moduleOptions = {
            fileSystemAccess: 'subdir-only',
            basedir: 'test/modules/src',
            includes: ['**/*.mvm.js'],
            allowNodeCoreModules: true,
            coreModules: {
                'core': './a-core-module.mvm.js'
            }
        };
        let printLog = [];
        const vm = lib_1.Microvium.create();
        const importer = (0, lib_1.nodeStyleImporter)(vm, moduleOptions);
        vm.globalThis.print = (s) => printLog.push(s);
        if (fs_extra_1.default.existsSync('test/modules/output.txt'))
            fs_extra_1.default.removeSync('test/modules/output.txt');
        importer('./m1');
        chai_1.assert.deepEqual(printLog, [
            'importing m3',
            'Writing to a file',
            'importing m2',
            'importing m1',
        ]);
        const output = fs_extra_1.default.readFileSync('test/modules/output.txt', 'utf8');
        chai_1.assert.equal(output, 'This is some output');
    });
    test('import-for-side-effects', () => {
        let printLog = [];
        const vm = lib_1.Microvium.create();
        vm.globalThis.print = (s) => printLog.push(s);
        const otherModule = {
            sourceText: `
        print('Other module side effects');
      `
        };
        vm.evaluateModule({
            sourceText: `
        import 'other';
      `,
            importDependency(specifier) {
                chai_1.assert.equal(specifier, 'other');
                return vm.evaluateModule(otherModule);
            }
        });
        chai_1.assert.deepEqual(printLog, [
            'Other module side effects'
        ]);
    });
});
//# sourceMappingURL=modules.test.js.map