feat: make __helpers available in all before hooks (#505)

Author: ojeytonwilliams

packages/dom-evaluator/src/dom-test-evaluator.ts

@@ -31,12 +31,14 @@ const READY_MESSAGE: ReadyEvent["data"] = { type: "ready" };
 declare global {
   var __FakeTimers: typeof FakeTimers;
   var assert: typeof chaiAssert;
+  var __helpers: typeof helpers;
 }
 
 // @ts-expect-error jQuery cannot be declared.
 globalThis.$ = jQuery;
 globalThis.__FakeTimers = FakeTimers;
 globalThis.assert = chaiAssert;
+globalThis.__helpers = helpers;
 
 // Local storage is not accessible in a sandboxed iframe, so we need to mock it
 Object.defineProperty(globalThis, "localStorage", {
@@ -116,8 +118,6 @@ export class DOMTestEvaluator implements TestEvaluator {
       return o;
     };
 
-    const __helpers = helpers;
-
     let Enzyme;
     if (opts.loadEnzyme) {
       let Adapter16;
@@ -135,10 +135,11 @@ export class DOMTestEvaluator implements TestEvaluator {
     this.#runTest = async function (rawTest: string): Promise<Fail | Pass> {
       this.#proxyConsole.on();
       try {
-        const test = createAsyncIife(rawTest);
+        const testWithBefore = `${opts.hooks?.beforeEach ?? ""};
+${rawTest}`;
+        const test = createAsyncIife(testWithBefore);
 
-        await eval(`${opts.hooks?.beforeEach ?? ""}
-${test}`);
+        await eval(test);
 
         return { pass: true, ...this.#proxyConsole.flush() };
       } catch (err) {

packages/javascript-evaluator/src/javascript-test-evaluator.ts

@@ -69,7 +69,7 @@ export class JavascriptTestEvaluator implements TestEvaluator {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const editableContents = opts.code?.editableContents ?? "";
         try {
-          await eval(`${opts.hooks?.beforeEach ?? ""}
+          await eval(`${opts.hooks?.beforeEach ?? ""};
 ${opts.source};
 __userCodeWasExecuted = true;
 ${test};`);

packages/python-evaluator/src/python-test-evaluator.ts

@@ -22,6 +22,12 @@ import { format } from "../../shared/src/format";
 import { ProxyConsole } from "../../shared/src/proxy-console";
 import { createAsyncIife } from "../../shared/src/async-iife";
 
+declare global {
+  var __helpers: typeof helpers;
+}
+
+globalThis.__helpers = helpers;
+
 type EvaluatedTeststring = {
   test: () => Promise<unknown>;
 };
@@ -65,14 +71,13 @@ class PythonTestEvaluator implements TestEvaluator {
     const pyodide = await this.#setupPyodide();
     eval(opts.hooks?.beforeAll ?? "");
 
-    this.#runTest = async (testString): Promise<Pass | Fail> => {
+    this.#runTest = async (rawTestString): Promise<Pass | Fail> => {
       this.#proxyConsole.on();
       const code = (opts.code?.contents ?? "").slice();
       /* eslint-disable @typescript-eslint/no-unused-vars */
       const editableContents = (opts.code?.editableContents ?? "").slice();
 
       const { assert } = chai;
-      const __helpers = helpers;
 
       // Create fresh globals for each test
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -111,7 +116,8 @@ input = __fake_input
 `);
 
       try {
-        eval(opts.hooks?.beforeEach ?? "");
+        const testString = `${opts.hooks?.beforeEach ?? ""};
+${rawTestString}`;
         // Eval test string to get the test property
 
         let evaluatedTestString;

packages/tests/integration-tests/index.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import "vitest-environment-puppeteer";
 import { compileForTests } from "../../shared/tooling/webpack-compile";
 import type { FCCTestRunner } from "../../main/src/index";
@@ -312,6 +313,21 @@ for(let i = 0; i < 3; i++) {
       });
     });
 
+    it("should handle beforeEach expressions without trailing semicolons", async () => {
+      const result = await page.evaluate(async (type) => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type,
+          hooks: {
+            beforeEach: "let x = 1;Array()",
+          },
+        });
+        const one = await runner.runTest("(assert.equal(x, 1))");
+        return one;
+      }, type);
+
+      expect(result).toEqual({ pass: true });
+    });
+
     it("should evaluate the beforeEach hook before each test", async () => {
       const result = await page.evaluate(async (type) => {
         const runner = await window.FCCTestRunner.createTestRunner({
@@ -1146,6 +1162,27 @@ checkBtn.click();
 
       expect(result).toEqual({ pass: true });
     });
+
+    it("should make __helpers available in before hooks", async () => {
+      const result = await page.evaluate(async () => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type: "dom",
+          hooks: {
+            beforeEach:
+              "const before = __helpers.removeJSComments('before // this')",
+            beforeAll:
+              "const beforeall = __helpers.removeJSComments('before all // this')",
+          },
+        });
+
+        return runner.runAllTests([
+          "assert.equal(before, 'before ')",
+          "assert.equal(beforeall, 'before all ')",
+        ]);
+      });
+
+      expect(result).toEqual([{ pass: true }, { pass: true }]);
+    });
   });
 
   describe("Javascript evaluator", () => {
@@ -1221,6 +1258,49 @@ checkBtn.click();
         },
       });
     });
+
+    it("should make __helpers available in before hooks", async () => {
+      const result = await page.evaluate(async () => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type: "javascript",
+          hooks: {
+            beforeEach:
+              "const before = __helpers.removeJSComments('before // this')",
+            beforeAll:
+              "globalThis.beforeall = __helpers.removeJSComments('before all // this')",
+          },
+        });
+
+        return runner.runAllTests([
+          "assert.equal(before, 'before ')",
+          "assert.equal(globalThis.beforeall, 'before all ')",
+        ]);
+      });
+
+      expect(result).toEqual([{ pass: true }, { pass: true }]);
+    });
+
+    // Weird edge case, but if the user code starts with an opening bracket and
+    // the beforeEach hook does not end with a semicolon, the combination of the
+    // two could be interpreted as a function call. In this case
+    // Array()( { key: 'value' }) )
+    // and that's a TypeError.
+    it("should handle user code with leading brackets", async () => {
+      const source = `({ key: 'value' })`;
+      const result = await page.evaluate(async (source) => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          source,
+          code: { contents: source },
+          type: "javascript",
+          hooks: {
+            beforeEach: "Array()",
+          },
+        });
+        return runner.runTest("(assert.equal(code, '({ key: \\'value\\' })'))");
+      }, source);
+
+      expect(result).toEqual({ pass: true });
+    });
   });
 
   describe("Python evaluator", () => {
@@ -1530,5 +1610,27 @@ pattern = re.compile('l+')`;
 
       expect(result).toEqual({ pass: true });
     });
+
+    it("should make __helpers available in before hooks", async () => {
+      const result = await page.evaluate(async () => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type: "python",
+          hooks: {
+            beforeEach:
+              "const before = __helpers.removeJSComments('before // this'); await ''",
+            beforeAll:
+              "globalThis.beforeall = __helpers.removeJSComments('before all // this')",
+          },
+        });
+
+        return runner.runAllTests([
+          "assert.equal(before, 'before ')",
+          "({test: () => { assert.equal(before, 'before ')}})",
+          "assert.equal(globalThis.beforeall, 'before all ')",
+        ]);
+      });
+
+      expect(result).toEqual([{ pass: true }, { pass: true }, { pass: true }]);
+    });
   });
 });