Merge pull request #294 from YousefED/engine-tests

Setup and add first engine tests

Author: niklaskors

package.json

@@ -13,7 +13,7 @@
     "install-lerna": "npm install --no-package-lock",
     "bootstrap": "lerna bootstrap --hoist --ci && patch-package",
     "install-new-packages": "lerna bootstrap --hoist && patch-package",
-    "test": "lerna run test-no-watch",
+    "test": "jest --coverage=true --config=jest.config.js && lerna run test-no-watch",
     "build": "lerna run build --concurrency 1",
     "build-react": "lerna run build-react --concurrency 1 --stream",
     "lint": "lerna run lint --concurrency 1",

packages/engine/jest.config.js

@@ -15,5 +15,5 @@ module.exports = {
     "^y-protocols/([a-zA-Z-]*)$":
       "<rootDir>/../../node_modules/y-protocols/dist/$1.cjs",
   },
-  setupFiles: ["<rootDir>/src/setupTests.ts"],
+  setupFiles: ["<rootDir>/src/tests/setupTests.ts"],
 };

packages/engine/package.json

@@ -10,6 +10,7 @@
     "vscode-lib": "^0.1.0"
   },
   "devDependencies": {
+    "jest": "26.6.0",
     "rimraf": "^3.0.2",
     "typescript": "4.3.2"
   },
@@ -19,7 +20,8 @@
   "scripts": {
     "clean": "rimraf dist && rimraf types",
     "build": "npm run clean && tsc -p tsconfig.json",
-    "watch": "tsc --watch"
+    "watch": "tsc --watch",
+    "test": "jest --coverage=true --config=jest.config.js"
   },
   "jest": {
     "transformIgnorePatterns": [

packages/engine/src/Engine.test.ts

@@ -0,0 +1,98 @@
+import { CodeModel } from "./CodeModel";
+import { Engine } from "./Engine";
+import { event } from "vscode-lib";
+import {
+  buildMockedModel,
+  importResolver,
+  toAMDFormat,
+  waitTillEvent,
+} from "./tests/util/helpers";
+
+const getModel1 = () =>
+  buildMockedModel(
+    "model1",
+    `let x = 4; 
+let y = 6; 
+let sum = x + y;
+exports.sum = sum;
+exports.default = sum;`
+  );
+
+const getModel2 = () =>
+  buildMockedModel("model2", `exports.default = $.sum - 5;`);
+
+describe("engine class", () => {
+  it("should execute a single model", async () => {
+    const engine = new Engine<CodeModel>(importResolver);
+    engine.registerModel(getModel1());
+
+    const { model, output } = await event.Event.toPromise(engine.onOutput);
+
+    expect(model.path).toBe("model1");
+    expect(output.sum).toBe(10);
+    expect(output.default).toBe(10);
+  });
+
+  it("should read exported variables from other models", async () => {
+    const engine = new Engine<CodeModel>(importResolver);
+    engine.registerModel(getModel1());
+    await event.Event.toPromise(engine.onOutput);
+
+    engine.registerModel(getModel2());
+    const { model, output } = await event.Event.toPromise(engine.onOutput);
+
+    expect(model.path).toBe("model2");
+    expect(output.default).toBe(5);
+  });
+
+  it("should re-evaluate code after change", async () => {
+    const engine = new Engine<CodeModel>(importResolver);
+    const model1 = getModel1();
+
+    engine.registerModel(model1);
+    await event.Event.toPromise(engine.onOutput);
+
+    model1.updateCode(
+      toAMDFormat(`let x = 0;
+    let y = 6;
+    let sum = x + y;
+    exports.sum = sum;
+    exports.default = sum;`)
+    );
+
+    const { output } = await event.Event.toPromise(engine.onOutput);
+
+    expect(output.sum).toBe(6);
+    expect(output.default).toBe(6);
+  });
+
+  it("should re-evaluate other models when global variable changes", async () => {
+    const engine = new Engine<CodeModel>(importResolver);
+    // TODO: Expected 4 events. Figure out why model 2 re-evaluates.
+    const eventsPromise = waitTillEvent(engine.onOutput, 5);
+    const model1 = getModel1();
+    const model2 = getModel2();
+
+    engine.registerModel(model1);
+    engine.registerModel(model2);
+
+    model1.updateCode(
+      toAMDFormat(`let x = 0;
+    let y = 6;
+    let sum = x + y;
+    exports.sum = sum;
+    exports.default = sum;`)
+    );
+
+    const events = await eventsPromise;
+    const eventsSnapshot = events.map((event) => ({
+      path: event.model.path,
+      output: event.output,
+    }));
+    const finalEvent = eventsSnapshot[eventsSnapshot.length - 1];
+
+    expect(finalEvent.path).toBe("model2");
+    expect(finalEvent.output.default).toBe(1);
+    expect(eventsSnapshot).toMatchSnapshot();
+  });
+});

packages/engine/src/__snapshots__/Engine.test.ts.snap

@@ -0,0 +1,36 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`engine class should re-evaluate other models when global variable changes 1`] = `
+Array [
+  Object {
+    "output": Object {
+      "default": 10,
+    },
+    "path": "model1",
+  },
+  Object {
+    "output": Object {
+      "default": 5,
+    },
+    "path": "model2",
+  },
+  Object {
+    "output": Object {
+      "default": 5,
+    },
+    "path": "model2",
+  },
+  Object {
+    "output": Object {
+      "default": 6,
+    },
+    "path": "model1",
+  },
+  Object {
+    "output": Object {
+      "default": 1,
+    },
+    "path": "model2",
+  },
+]
+`;

packages/engine/src/modules.ts

@@ -87,12 +87,10 @@ export function createExecutionScope(context: TypeCellContext<any>) {
 }
 
 export function getModulesFromTypeCellCode(compiledCode: string, scope: any) {
-  if (!compiledCode.match(/^(define\((".*", )?\[.*\], )function/gm)) {
+  // Checks if define([], function) like code is already present
+  if (!compiledCode.match(/(define\((".*", )?\[.*\], )function/gm)) {
     // file is not a module (no exports). Create module-like code manually
-    compiledCode = `define([], function() {
-  ${compiledCode};
-            });   
-  `;
+    compiledCode = `define([], function() { ${compiledCode}; });`;
   }
 
   if (Object.keys(scope).find((key) => !/^[a-zA-Z0-9_$]+$/.test(key))) {

packages/engine/src/setupTests.ts

@@ -0,0 +1,7 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+// import "@testing-library/jest-dom";
+// https://github.com/developit/microbundle/issues/708, otherwise vscode-lib fails
+import "regenerator-runtime/runtime.js";

packages/engine/src/tests/setupTests.ts

@@ -0,0 +1,28 @@
+import { CodeModel } from "../../CodeModel";
+import { event } from "vscode-lib";
+
+export class CodeModelMock implements CodeModel {
+  public contentChangeEmitter = new event.Emitter<void>();
+
+  public onWillDispose() {
+    return {
+      dispose: () => {},
+    };
+  }
+  public onDidChangeContent = this.contentChangeEmitter.event;
+
+  constructor(
+    public readonly language: string,
+    public readonly path: string,
+    public code: string
+  ) {}
+
+  public getValue(): string {
+    return this.code;
+  }
+
+  public updateCode(code: string) {
+    this.code = code;
+    this.contentChangeEmitter.fire();
+  }
+}

packages/engine/src/tests/util/CodeModelMock.ts

@@ -0,0 +1,49 @@
+import { CodeModel } from "../../CodeModel";
+import { ResolvedImport } from "../../Engine";
+import { CodeModelMock } from "./CodeModelMock";
+
+export function waitTillEvent<T>(
+  e: (listener: (arg0: T) => void) => void,
+  expected: number
+): Promise<T[]> {
+  const captured: T[] = [];
+  return new Promise((resolve) => {
+    e(({ ...args }) => {
+      if (captured.length < expected) {
+        captured.push(args);
+      }
+      if (captured.length === expected) {
+        return resolve(captured);
+      }
+    });
+  });
+}
+
+export async function importResolver(
+  _module: string,
+  _forModel: CodeModel
+): Promise<ResolvedImport> {
+  const res = async () => {
+    return {
+      module: {
+        default: {},
+      },
+      dispose: () => {},
+    };
+  };
+
+  return res();
+}
+
+export function toAMDFormat(code: string) {
+  return `define(["require", "exports"], function(require, exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      ${code}
+      });
+      `;
+}
+
+export function buildMockedModel(name: string, code: string) {
+  return new CodeModelMock("javascript", name, toAMDFormat(code));
+}