@ricsam/isolate-test-environment 0.1.1 → 0.1.3

package/src/expect.test.ts

@@ -1,319 +0,0 @@
-import { test, describe, beforeEach, afterEach } from "node:test";
-import assert from "node:assert";
-import ivm from "isolated-vm";
-import { setupTestEnvironment, runTests } from "./index.ts";
-
-describe("expect matchers", () => {
-  let isolate: ivm.Isolate;
-  let context: ivm.Context;
-
-  beforeEach(async () => {
-    isolate = new ivm.Isolate();
-    context = await isolate.createContext();
-    await setupTestEnvironment(context);
-  });
-
-  afterEach(() => {
-    context.release();
-    isolate.dispose();
-  });
-
-  describe("toBe", () => {
-    test("passes for equal primitives", async () => {
-      context.evalSync(`
-        test("toBe test", () => {
-          expect(1).toBe(1);
-          expect("hello").toBe("hello");
-          expect(true).toBe(true);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("fails for different primitives", async () => {
-      context.evalSync(`
-        test("toBe fails", () => {
-          expect(1).toBe(2);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 0);
-      assert.strictEqual(results.failed, 1);
-      assert.ok(results.results[0].error?.includes("Expected 1 to be 2"));
-    });
-  });
-
-  describe("toEqual", () => {
-    test("passes for equal objects", async () => {
-      context.evalSync(`
-        test("toEqual objects", () => {
-          expect({ a: 1, b: 2 }).toEqual({ a: 1, b: 2 });
-          expect({ nested: { value: 42 } }).toEqual({ nested: { value: 42 } });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("passes for equal arrays", async () => {
-      context.evalSync(`
-        test("toEqual arrays", () => {
-          expect([1, 2, 3]).toEqual([1, 2, 3]);
-          expect([{ a: 1 }, { b: 2 }]).toEqual([{ a: 1 }, { b: 2 }]);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toStrictEqual", () => {
-    test("checks for strict equality", async () => {
-      context.evalSync(`
-        test("toStrictEqual", () => {
-          expect({ a: 1 }).toStrictEqual({ a: 1 });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("not modifier", () => {
-    test("not.toBe inverts the check", async () => {
-      context.evalSync(`
-        test("not.toBe", () => {
-          expect(1).not.toBe(2);
-          expect("hello").not.toBe("world");
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toBeTruthy", () => {
-    test("passes for truthy values", async () => {
-      context.evalSync(`
-        test("toBeTruthy", () => {
-          expect(1).toBeTruthy();
-          expect("hello").toBeTruthy();
-          expect([]).toBeTruthy();
-          expect({}).toBeTruthy();
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toBeFalsy", () => {
-    test("passes for falsy values", async () => {
-      context.evalSync(`
-        test("toBeFalsy", () => {
-          expect(0).toBeFalsy();
-          expect("").toBeFalsy();
-          expect(null).toBeFalsy();
-          expect(undefined).toBeFalsy();
-          expect(false).toBeFalsy();
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toBeNull", () => {
-    test("passes for null", async () => {
-      context.evalSync(`
-        test("toBeNull", () => {
-          expect(null).toBeNull();
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toBeUndefined", () => {
-    test("passes for undefined", async () => {
-      context.evalSync(`
-        test("toBeUndefined", () => {
-          expect(undefined).toBeUndefined();
-          let x;
-          expect(x).toBeUndefined();
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toBeDefined", () => {
-    test("passes for defined values", async () => {
-      context.evalSync(`
-        test("toBeDefined", () => {
-          expect(1).toBeDefined();
-          expect("").toBeDefined();
-          expect(null).toBeDefined();
-          expect(0).toBeDefined();
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toContain", () => {
-    test("passes when array contains item", async () => {
-      context.evalSync(`
-        test("toContain array", () => {
-          expect([1, 2, 3]).toContain(2);
-          expect(["a", "b", "c"]).toContain("b");
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("passes when string contains substring", async () => {
-      context.evalSync(`
-        test("toContain string", () => {
-          expect("hello world").toContain("world");
-          expect("abc").toContain("b");
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toThrow", () => {
-    test("passes when function throws", async () => {
-      context.evalSync(`
-        test("toThrow", () => {
-          expect(() => { throw new Error("boom"); }).toThrow();
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("can match error message", async () => {
-      context.evalSync(`
-        test("toThrow with message", () => {
-          expect(() => { throw new Error("something went wrong"); }).toThrow("went wrong");
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toBeInstanceOf", () => {
-    test("passes for correct instance", async () => {
-      context.evalSync(`
-        test("toBeInstanceOf", () => {
-          expect(new Error()).toBeInstanceOf(Error);
-          expect([]).toBeInstanceOf(Array);
-          expect({}).toBeInstanceOf(Object);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toHaveLength", () => {
-    test("passes for correct array length", async () => {
-      context.evalSync(`
-        test("toHaveLength array", () => {
-          expect([1, 2, 3]).toHaveLength(3);
-          expect([]).toHaveLength(0);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("passes for correct string length", async () => {
-      context.evalSync(`
-        test("toHaveLength string", () => {
-          expect("hello").toHaveLength(5);
-          expect("").toHaveLength(0);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toMatch", () => {
-    test("passes for matching regexp", async () => {
-      context.evalSync(`
-        test("toMatch regexp", () => {
-          expect("hello world").toMatch(/world/);
-          expect("abc123").toMatch(/\\d+/);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("passes for matching substring", async () => {
-      context.evalSync(`
-        test("toMatch substring", () => {
-          expect("hello world").toMatch("world");
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("toHaveProperty", () => {
-    test("passes when property exists", async () => {
-      context.evalSync(`
-        test("toHaveProperty exists", () => {
-          expect({ a: 1 }).toHaveProperty("a");
-          expect({ nested: { value: 42 } }).toHaveProperty("nested.value");
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("passes when property has expected value", async () => {
-      context.evalSync(`
-        test("toHaveProperty with value", () => {
-          expect({ a: 1 }).toHaveProperty("a", 1);
-          expect({ nested: { value: 42 } }).toHaveProperty("nested.value", 42);
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-});

package/src/hooks.test.ts

@@ -1,303 +0,0 @@
-import { test, describe, beforeEach, afterEach } from "node:test";
-import assert from "node:assert";
-import ivm from "isolated-vm";
-import { setupTestEnvironment, runTests } from "./index.ts";
-
-describe("test hooks", () => {
-  let isolate: ivm.Isolate;
-  let context: ivm.Context;
-
-  beforeEach(async () => {
-    isolate = new ivm.Isolate();
-    context = await isolate.createContext();
-    await setupTestEnvironment(context);
-  });
-
-  afterEach(() => {
-    context.release();
-    isolate.dispose();
-  });
-
-  describe("beforeEach", () => {
-    test("runs before each test", async () => {
-      context.evalSync(`
-        let counter = 0;
-
-        describe("suite", () => {
-          beforeEach(() => {
-            counter++;
-          });
-
-          test("first test", () => {
-            expect(counter).toBe(1);
-          });
-
-          test("second test", () => {
-            expect(counter).toBe(2);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 2);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("afterEach", () => {
-    test("runs after each test", async () => {
-      context.evalSync(`
-        let log = [];
-
-        describe("suite", () => {
-          afterEach(() => {
-            log.push("afterEach");
-          });
-
-          test("first test", () => {
-            log.push("test1");
-          });
-
-          test("second test", () => {
-            log.push("test2");
-            expect(log).toEqual(["test1", "afterEach", "test2"]);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 2);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("beforeAll", () => {
-    test("runs once before all tests", async () => {
-      context.evalSync(`
-        let setupCount = 0;
-
-        describe("suite", () => {
-          beforeAll(() => {
-            setupCount++;
-          });
-
-          test("first test", () => {
-            expect(setupCount).toBe(1);
-          });
-
-          test("second test", () => {
-            expect(setupCount).toBe(1);
-          });
-
-          test("third test", () => {
-            expect(setupCount).toBe(1);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 3);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("afterAll", () => {
-    test("runs once after all tests", async () => {
-      context.evalSync(`
-        let log = [];
-
-        describe("suite", () => {
-          afterAll(() => {
-            log.push("afterAll");
-          });
-
-          test("first test", () => {
-            log.push("test1");
-          });
-
-          test("second test", () => {
-            log.push("test2");
-          });
-        });
-
-        // We can check in a sibling suite that afterAll ran
-        describe("verification", () => {
-          test("afterAll was called", () => {
-            expect(log).toEqual(["test1", "test2", "afterAll"]);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 3);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("nested describe", () => {
-    test("hooks run in correct order", async () => {
-      context.evalSync(`
-        let log = [];
-
-        describe("outer", () => {
-          beforeAll(() => log.push("outer beforeAll"));
-          afterAll(() => log.push("outer afterAll"));
-          beforeEach(() => log.push("outer beforeEach"));
-          afterEach(() => log.push("outer afterEach"));
-
-          describe("inner", () => {
-            beforeAll(() => log.push("inner beforeAll"));
-            afterAll(() => log.push("inner afterAll"));
-            beforeEach(() => log.push("inner beforeEach"));
-            afterEach(() => log.push("inner afterEach"));
-
-            test("nested test", () => {
-              log.push("test");
-            });
-          });
-        });
-
-        describe("check results", () => {
-          test("hooks ran in correct order", () => {
-            expect(log).toEqual([
-              "outer beforeAll",
-              "inner beforeAll",
-              "outer beforeEach",
-              "inner beforeEach",
-              "test",
-              "inner afterEach",
-              "outer afterEach",
-              "inner afterAll",
-              "outer afterAll"
-            ]);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 2);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("test.skip", () => {
-    test("skips tests marked with skip", async () => {
-      context.evalSync(`
-        describe("suite", () => {
-          test("normal test", () => {
-            expect(true).toBe(true);
-          });
-
-          test.skip("skipped test", () => {
-            expect(true).toBe(false); // This would fail if run
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-      assert.strictEqual(results.results.filter((r: any) => r.skipped).length, 1);
-    });
-  });
-
-  describe("test.only", () => {
-    test("runs only tests marked with only", async () => {
-      context.evalSync(`
-        describe("suite", () => {
-          test("should not run", () => {
-            expect(true).toBe(false); // Would fail if run
-          });
-
-          test.only("should run", () => {
-            expect(true).toBe(true);
-          });
-
-          test("also should not run", () => {
-            expect(true).toBe(false); // Would fail if run
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-      assert.strictEqual(results.total, 1);
-    });
-  });
-
-  describe("describe.skip", () => {
-    test("skips all tests in skipped describe", async () => {
-      context.evalSync(`
-        describe.skip("skipped suite", () => {
-          test("test 1", () => {
-            expect(true).toBe(false);
-          });
-
-          test("test 2", () => {
-            expect(true).toBe(false);
-          });
-        });
-
-        describe("normal suite", () => {
-          test("normal test", () => {
-            expect(true).toBe(true);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-      assert.strictEqual(results.results.filter((r: any) => r.skipped).length, 2);
-    });
-  });
-
-  describe("async tests", () => {
-    test("supports async test functions", async () => {
-      context.evalSync(`
-        describe("async suite", () => {
-          test("async test", async () => {
-            await Promise.resolve();
-            expect(1 + 1).toBe(2);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-
-    test("supports async hooks", async () => {
-      context.evalSync(`
-        let value = 0;
-
-        describe("async hooks", () => {
-          beforeEach(async () => {
-            await Promise.resolve();
-            value = 42;
-          });
-
-          test("value is set", () => {
-            expect(value).toBe(42);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-    });
-  });
-
-  describe("it alias", () => {
-    test("it works as alias for test", async () => {
-      context.evalSync(`
-        describe("suite", () => {
-          it("uses it instead of test", () => {
-            expect(1).toBe(1);
-          });
-
-          it.skip("skipped with it", () => {
-            expect(true).toBe(false);
-          });
-        });
-      `);
-      const results = await runTests(context);
-      assert.strictEqual(results.passed, 1);
-      assert.strictEqual(results.failed, 0);
-      assert.strictEqual(results.results.filter((r: any) => r.skipped).length, 1);
-    });
-  });
-});