@scelar/nodepod 1.0.1 → 1.0.3

package/src/__tests__/process.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi } from "vitest";
+import { buildProcessEnv } from "../polyfills/process";
+
+describe("process polyfill", () => {
+  describe("basic properties", () => {
+    it('has platform "linux"', () => {
+      const proc = buildProcessEnv();
+      expect(proc.platform).toBe("linux");
+    });
+
+    it('has arch "x64"', () => {
+      const proc = buildProcessEnv();
+      expect(proc.arch).toBe("x64");
+    });
+
+    it('has version string starting with "v"', () => {
+      const proc = buildProcessEnv();
+      expect(proc.version).toMatch(/^v\d+/);
+    });
+
+    it("has pid as a number", () => {
+      const proc = buildProcessEnv();
+      expect(typeof proc.pid).toBe("number");
+    });
+
+    it("has argv as an array", () => {
+      const proc = buildProcessEnv();
+      expect(Array.isArray(proc.argv)).toBe(true);
+    });
+  });
+
+  describe("cwd / chdir", () => {
+    it("cwd() returns initial cwd", () => {
+      const proc = buildProcessEnv({ cwd: "/mydir" });
+      expect(proc.cwd()).toBe("/mydir");
+    });
+
+    it("chdir changes cwd", () => {
+      const proc = buildProcessEnv({ cwd: "/" });
+      proc.chdir("/other");
+      expect(proc.cwd()).toBe("/other");
+    });
+  });
+
+  describe("env", () => {
+    it("includes default env vars", () => {
+      const proc = buildProcessEnv();
+      expect(proc.env.PATH).toBeDefined();
+      expect(proc.env.HOME).toBeDefined();
+    });
+
+    it("includes custom env vars passed in config", () => {
+      const proc = buildProcessEnv({ env: { MY_VAR: "hello" } });
+      expect(proc.env.MY_VAR).toBe("hello");
+    });
+
+    it("includes NAPI_RS_FORCE_WASM=1", () => {
+      const proc = buildProcessEnv();
+      expect(proc.env.NAPI_RS_FORCE_WASM).toBe("1");
+    });
+
+    it("is mutable", () => {
+      const proc = buildProcessEnv();
+      proc.env.CUSTOM = "value";
+      expect(proc.env.CUSTOM).toBe("value");
+    });
+  });
+
+  describe("hrtime", () => {
+    it("returns [seconds, nanoseconds] tuple", () => {
+      const proc = buildProcessEnv();
+      const hr = proc.hrtime();
+      expect(Array.isArray(hr)).toBe(true);
+      expect(hr.length).toBe(2);
+      expect(typeof hr[0]).toBe("number");
+      expect(typeof hr[1]).toBe("number");
+    });
+
+    it("hrtime.bigint() returns bigint", () => {
+      const proc = buildProcessEnv();
+      const result = proc.hrtime.bigint();
+      expect(typeof result).toBe("bigint");
+    });
+  });
+
+  describe("nextTick", () => {
+    it("schedules callback asynchronously", async () => {
+      const proc = buildProcessEnv();
+      let called = false;
+      proc.nextTick(() => {
+        called = true;
+      });
+      expect(called).toBe(false);
+      await new Promise((r) => setTimeout(r, 10));
+      expect(called).toBe(true);
+    });
+  });
+
+  describe("memoryUsage", () => {
+    it("returns object with expected shape", () => {
+      const proc = buildProcessEnv();
+      const mem = proc.memoryUsage();
+      expect(typeof mem.rss).toBe("number");
+      expect(typeof mem.heapTotal).toBe("number");
+      expect(typeof mem.heapUsed).toBe("number");
+      expect(typeof mem.external).toBe("number");
+      expect(typeof mem.arrayBuffers).toBe("number");
+    });
+  });
+
+  describe("stdout.write", () => {
+    it("calls onStdout callback when provided", () => {
+      const output: string[] = [];
+      const proc = buildProcessEnv({ onStdout: (text) => output.push(text) });
+      proc.stdout.write("test");
+      expect(output).toContain("test");
+    });
+  });
+
+  describe("kill / signals", () => {
+    it("kill emits signal on process", () => {
+      const proc = buildProcessEnv();
+      const fn = vi.fn();
+      proc.on("SIGTERM", fn);
+      proc.kill(proc.pid, "SIGTERM");
+      expect(fn).toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/script-engine.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect } from "vitest";
+import { ScriptEngine } from "../script-engine";
+import { MemoryVolume } from "../memory-volume";
+
+function createEngine(files?: Record<string, string>) {
+  const vol = new MemoryVolume();
+  vol.mkdirSync("/project", { recursive: true });
+  if (files) {
+    for (const [path, content] of Object.entries(files)) {
+      const dir = path.substring(0, path.lastIndexOf("/")) || "/";
+      if (dir !== "/") vol.mkdirSync(dir, { recursive: true });
+      vol.writeFileSync(path, content);
+    }
+  }
+  return { vol, engine: new ScriptEngine(vol, { cwd: "/project" }) };
+}
+
+describe("ScriptEngine", () => {
+  describe("execute()", () => {
+    it("runs basic JS and returns exports", () => {
+      const { engine } = createEngine();
+      const result = engine.execute("module.exports = 42;", "/index.js");
+      expect(result.exports).toBe(42);
+    });
+
+    it("module.exports = object", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        "module.exports = { x: 1 };",
+        "/index.js",
+      );
+      expect(result.exports).toEqual({ x: 1 });
+    });
+
+    it("exports.x = value shorthand", () => {
+      const { engine } = createEngine();
+      const result = engine.execute("exports.x = 1;", "/index.js");
+      expect((result.exports as any).x).toBe(1);
+    });
+
+    it("has access to __dirname and __filename", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        "module.exports = { dir: __dirname, file: __filename };",
+        "/project/test.js",
+      );
+      expect((result.exports as any).dir).toBe("/project");
+      expect((result.exports as any).file).toBe("/project/test.js");
+    });
+
+    it("has access to process object", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        "module.exports = process.platform;",
+        "/index.js",
+      );
+      expect(result.exports).toBe("linux");
+    });
+
+    it("handles syntax errors by throwing", () => {
+      const { engine } = createEngine();
+      expect(() => engine.execute("const {", "/bad.js")).toThrow();
+    });
+  });
+
+  describe("runFile()", () => {
+    it("reads file from volume and executes", () => {
+      const { engine } = createEngine({
+        "/project/app.js": 'module.exports = "hello";',
+      });
+      const result = engine.runFile("/project/app.js");
+      expect(result.exports).toBe("hello");
+    });
+
+    it("throws for nonexistent file", () => {
+      const { engine } = createEngine();
+      expect(() => engine.runFile("/nonexistent.js")).toThrow();
+    });
+  });
+
+  describe("require()", () => {
+    it("requires a local file with relative path", () => {
+      const { engine } = createEngine({
+        "/project/lib.js": "module.exports = 10;",
+      });
+      const result = engine.execute(
+        'const lib = require("./lib"); module.exports = lib;',
+        "/project/index.js",
+      );
+      expect(result.exports).toBe(10);
+    });
+
+    it("requires chained files (A requires B requires C)", () => {
+      const { engine } = createEngine({
+        "/project/c.js": "module.exports = 3;",
+        "/project/b.js":
+          'module.exports = require("./c") * 2;',
+        "/project/a.js":
+          'module.exports = require("./b") + 1;',
+      });
+      const result = engine.runFile("/project/a.js");
+      expect(result.exports).toBe(7);
+    });
+
+    it("caches modules (same object returned on second require)", () => {
+      const { engine } = createEngine({
+        "/project/mod.js": "module.exports = { count: 0 };",
+      });
+      const result = engine.execute(
+        'const a = require("./mod"); const b = require("./mod"); a.count++; module.exports = b.count;',
+        "/project/test.js",
+      );
+      expect(result.exports).toBe(1);
+    });
+
+    it("requires built-in modules: path", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        'const p = require("path"); module.exports = p.join("/a", "b");',
+        "/index.js",
+      );
+      expect(result.exports).toBe("/a/b");
+    });
+
+    it("requires built-in modules: events", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        'const EE = require("events"); module.exports = typeof EE;',
+        "/index.js",
+      );
+      expect(result.exports).toBe("function");
+    });
+
+    it("requires JSON files", () => {
+      const { engine } = createEngine({
+        "/project/data.json": '{"key": "value"}',
+      });
+      const result = engine.execute(
+        'module.exports = require("./data.json");',
+        "/project/index.js",
+      );
+      expect(result.exports).toEqual({ key: "value" });
+    });
+
+    it("throws for missing module", () => {
+      const { engine } = createEngine();
+      expect(() =>
+        engine.execute('require("./nonexistent");', "/index.js"),
+      ).toThrow();
+    });
+  });
+
+  describe("ESM auto-conversion", () => {
+    it("auto-converts import/export to CJS when required", () => {
+      const { engine } = createEngine({
+        "/project/mod.js": "export const x = 42;",
+      });
+      const result = engine.execute(
+        'const m = require("./mod"); module.exports = m.x;',
+        "/project/index.js",
+      );
+      expect(result.exports).toBe(42);
+    });
+
+    it("handles export function containing dynamic import() without corruption", () => {
+      const { engine } = createEngine({
+        "/project/plugin.js": [
+          'import path from "path";',
+          "export function helper() { return 1; }",
+          "export function main() {",
+          "  const loader = () => import('./other.js');",
+          "  return { loader, val: path.join('a', 'b') };",
+          "}",
+        ].join("\n"),
+      });
+      const result = engine.execute(
+        'const m = require("./plugin"); module.exports = m.main().val;',
+        "/project/index.js",
+      );
+      expect(result.exports).toBe("a/b");
+    });
+  });
+
+  describe("clearCache()", () => {
+    it("clears module cache so modules are re-evaluated", () => {
+      const { engine } = createEngine({
+        "/project/counter.js":
+          "let c = 0; module.exports = { inc() { return ++c; } };",
+      });
+      engine.execute(
+        'module.exports = require("./counter").inc();',
+        "/project/a.js",
+      );
+      engine.clearCache();
+      const result = engine.execute(
+        'module.exports = require("./counter").inc();',
+        "/project/b.js",
+      );
+      // c resets to 0 after cache clear
+      expect(result.exports).toBe(1);
+    });
+  });
+
+  describe("createREPL()", () => {
+    it("evaluates expressions", () => {
+      const { engine } = createEngine();
+      const repl = engine.createREPL();
+      expect(repl.eval("1 + 1")).toBe(2);
+    });
+
+    it("evaluates variable declarations across calls", () => {
+      const { engine } = createEngine();
+      const repl = engine.createREPL();
+      repl.eval("var x = 10");
+      expect(repl.eval("x")).toBe(10);
+    });
+  });
+
+  describe("shebang handling", () => {
+    it("strips shebang line", () => {
+      const { engine } = createEngine({
+        "/project/script.js":
+          "#!/usr/bin/env node\nmodule.exports = 42;",
+      });
+      const result = engine.runFile("/project/script.js");
+      expect(result.exports).toBe(42);
+    });
+  });
+});