@gjsify/process 0.0.3 → 0.1.0

package/src/extended.spec.ts

@@ -0,0 +1,214 @@
+// Ported from refs/node-test/parallel/test-process-*.js
+// Original: MIT license, Node.js contributors
+
+import { describe, it, expect } from '@gjsify/unit';
+import process from 'node:process';
+
+export default async () => {
+
+  // ===================== Signal handling =====================
+  await describe('process signal handling', async () => {
+    await it('should support registering SIGTERM handler', async () => {
+      let handlerCalled = false;
+      const handler = () => { handlerCalled = true; };
+      process.on('SIGTERM', handler);
+      expect(process.listenerCount('SIGTERM')).toBeGreaterThan(0);
+      process.removeListener('SIGTERM', handler);
+    });
+
+    await it('should support registering SIGINT handler', async () => {
+      const handler = () => {};
+      process.on('SIGINT', handler);
+      expect(process.listenerCount('SIGINT')).toBeGreaterThan(0);
+      process.removeListener('SIGINT', handler);
+    });
+  });
+
+  // ===================== process.stdout/stderr =====================
+  await describe('process.stdout and process.stderr', async () => {
+    await it('process.stdout should exist', async () => {
+      expect(process.stdout).toBeDefined();
+    });
+
+    await it('process.stderr should exist', async () => {
+      expect(process.stderr).toBeDefined();
+    });
+
+    await it('process.stdout should have write method', async () => {
+      expect(typeof process.stdout.write).toBe('function');
+    });
+
+    await it('process.stderr should have write method', async () => {
+      expect(typeof process.stderr.write).toBe('function');
+    });
+  });
+
+  // ===================== process.stdin =====================
+  await describe('process.stdin', async () => {
+    await it('should exist', async () => {
+      expect(process.stdin).toBeDefined();
+    });
+  });
+
+  // ===================== process.nextTick ordering =====================
+  await describe('process.nextTick ordering', async () => {
+    await it('should execute callbacks in FIFO order', async () => {
+      const order: number[] = [];
+      await new Promise<void>((resolve) => {
+        process.nextTick(() => { order.push(1); });
+        process.nextTick(() => { order.push(2); });
+        process.nextTick(() => {
+          order.push(3);
+          resolve();
+        });
+      });
+      expect(order[0]).toBe(1);
+      expect(order[1]).toBe(2);
+      expect(order[2]).toBe(3);
+    });
+
+    await it('should pass arguments to callback', async () => {
+      const result = await new Promise<string>((resolve) => {
+        process.nextTick((a: string, b: string) => {
+          resolve(a + b);
+        }, 'hello', ' world');
+      });
+      expect(result).toBe('hello world');
+    });
+  });
+
+  // ===================== process.env deep =====================
+  await describe('process.env deep', async () => {
+    await it('should support setting and deleting env vars', async () => {
+      process.env.TEST_GJSIFY_VAR = 'test_value';
+      expect(process.env.TEST_GJSIFY_VAR).toBe('test_value');
+      delete process.env.TEST_GJSIFY_VAR;
+      expect(process.env.TEST_GJSIFY_VAR).toBeUndefined();
+    });
+
+    await it('should coerce non-string values to strings', async () => {
+      (process.env as any).TEST_NUM = 42;
+      expect(typeof process.env.TEST_NUM).toBe('string');
+      expect(process.env.TEST_NUM).toBe('42');
+      delete process.env.TEST_NUM;
+    });
+
+    await it('should enumerate env vars with Object.keys', async () => {
+      const keys = Object.keys(process.env);
+      expect(keys.length).toBeGreaterThan(0);
+      // PATH or HOME should be present
+      const hasCommon = keys.includes('PATH') || keys.includes('HOME') || keys.includes('USER');
+      expect(hasCommon).toBe(true);
+    });
+  });
+
+  // ===================== process.hrtime =====================
+  await describe('process.hrtime deep', async () => {
+    await it('hrtime should return [seconds, nanoseconds]', async () => {
+      const hr = process.hrtime();
+      expect(Array.isArray(hr)).toBe(true);
+      expect(hr.length).toBe(2);
+      expect(typeof hr[0]).toBe('number');
+      expect(typeof hr[1]).toBe('number');
+      expect(hr[0]).toBeGreaterThan(-1);
+      expect(hr[1]).toBeGreaterThan(-1);
+    });
+
+    await it('hrtime diff should measure elapsed time', async () => {
+      const start = process.hrtime();
+      // Small busy wait
+      let sum = 0;
+      for (let i = 0; i < 100000; i++) sum += i;
+      const diff = process.hrtime(start);
+      expect(diff[0]).toBeGreaterThan(-1);
+      // Total nanoseconds should be positive
+      const totalNs = diff[0] * 1e9 + diff[1];
+      expect(totalNs).toBeGreaterThan(0);
+    });
+
+    await it('hrtime.bigint should return bigint', async () => {
+      const t = process.hrtime.bigint();
+      expect(typeof t).toBe('bigint');
+      expect(t > 0n).toBe(true);
+    });
+
+    await it('hrtime.bigint should be monotonic', async () => {
+      const a = process.hrtime.bigint();
+      const b = process.hrtime.bigint();
+      expect(b >= a).toBe(true);
+    });
+  });
+
+  // ===================== process.memoryUsage =====================
+  await describe('process.memoryUsage deep', async () => {
+    await it('should return object with expected fields', async () => {
+      const mem = process.memoryUsage();
+      expect(typeof mem).toBe('object');
+      expect(typeof mem.rss).toBe('number');
+      expect(typeof mem.heapTotal).toBe('number');
+      expect(typeof mem.heapUsed).toBe('number');
+      expect(typeof mem.external).toBe('number');
+    });
+
+    await it('rss should be positive', async () => {
+      const mem = process.memoryUsage();
+      expect(mem.rss).toBeGreaterThan(0);
+    });
+
+    await it('heapUsed should be less than or equal to heapTotal', async () => {
+      const mem = process.memoryUsage();
+      expect(mem.heapUsed <= mem.heapTotal).toBe(true);
+    });
+  });
+
+  // ===================== process.cpuUsage =====================
+  await describe('process.cpuUsage deep', async () => {
+    await it('should return user and system times', async () => {
+      const usage = process.cpuUsage();
+      expect(typeof usage.user).toBe('number');
+      expect(typeof usage.system).toBe('number');
+    });
+
+    await it('should accept previous value for delta', async () => {
+      const prev = process.cpuUsage();
+      // Do some work
+      let sum = 0;
+      for (let i = 0; i < 100000; i++) sum += i;
+      const delta = process.cpuUsage(prev);
+      expect(typeof delta.user).toBe('number');
+      expect(typeof delta.system).toBe('number');
+      // Delta user time should be non-negative
+      expect(delta.user >= 0).toBe(true);
+    });
+  });
+
+  // ===================== process.emitWarning =====================
+  await describe('process.emitWarning', async () => {
+    await it('should be a function', async () => {
+      expect(typeof process.emitWarning).toBe('function');
+    });
+  });
+
+  // ===================== process.versions =====================
+  await describe('process.versions deep', async () => {
+    await it('should have versions object', async () => {
+      expect(typeof process.versions).toBe('object');
+      expect(process.versions !== null).toBe(true);
+    });
+
+    await it('should have v8 or gjs version', async () => {
+      // On Node.js: v8 exists. On GJS: may have gjs or modules
+      const hasEngine = process.versions.v8 !== undefined ||
+                        (process.versions as any).gjs !== undefined ||
+                        process.versions.modules !== undefined;
+      expect(hasEngine).toBe(true);
+    });
+  });
+
+  // ===================== process.config =====================
+  await describe('process.config', async () => {
+    await it('should be an object', async () => {
+      expect(typeof process.config).toBe('object');
+    });
+  });
+};

package/src/index.spec.ts

@@ -1,28 +1,438 @@
+// Ported from refs/node-test/parallel/ and refs/node/test/parallel/test-process-*.js
+// Original: MIT license, Node.js contributors
+// Additional tests inspired by refs/bun/test/js/node/ and refs/deno/ext/node/polyfills/
+
 import { describe, it, expect } from '@gjsify/unit'
 
-import process from 'process';
+import process from 'node:process';
+import * as os from 'node:os';
 
-// process.on('exit', code => console.log('bye bye: ' + code));
+export default async () => {
+  await describe("process: properties", async () => {
+    await it("process.arch should be a string", async () => {
+      expect(typeof process.arch).toBe("string");
+    });
 
-// Object.keys(process).forEach(key => {
-//   switch (key) {
-//     case 'abort':
-//     case 'env':
-//     case 'exit':
-//     case 'nextTick':
-//       return;
-//   }
-//   console.log(key, typeof process[key] === 'function' ? process[key]() : process[key]);
-// });
+    await it("process.platform should be a string", async () => {
+      expect(typeof process.platform).toBe("string");
+    });
 
-// process.nextTick(process.exit, 0);
+    await it("process.pid should be a number", async () => {
+      expect(typeof process.pid).toBe("number");
+    });
 
-// assert.deepEqual(process.argv.splice(2),  ["--foo", "bar"]);
+    await it("process.pid should be a positive integer", async () => {
+      expect(process.pid > 0).toBeTruthy();
+      expect(Number.isInteger(process.pid)).toBeTruthy();
+    });
 
-export default async () => {
-  await describe("Progress", async () => {
-    await it("process.arch should be a string", async () => {
-      await expect(typeof process.arch).toBe("string");
+    await it("process.ppid should be a positive integer", async () => {
+      expect(process.ppid > 0).toBeTruthy();
+      expect(Number.isInteger(process.ppid)).toBeTruthy();
+    });
+
+    await it("process.version should be a string starting with v", async () => {
+      expect(typeof process.version).toBe("string");
+      expect(process.version[0]).toBe("v");
+    });
+
+    await it("process.version should match semver pattern", async () => {
+      expect(process.version).toMatch(/^v\d+/);
+    });
+
+    await it("process.versions should be an object", async () => {
+      expect(typeof process.versions).toBe("object");
+    });
+
+    await it("process.argv should be an array", async () => {
+      expect(Array.isArray(process.argv)).toBeTruthy();
+    });
+
+    await it("process.argv should have at least 1 element", async () => {
+      expect(process.argv.length >= 1).toBeTruthy();
+    });
+
+    await it("process.argv first element should be a string", async () => {
+      expect(typeof process.argv[0]).toBe("string");
+    });
+
+    await it("process.env should be an object", async () => {
+      expect(typeof process.env).toBe("object");
+    });
+
+    await it("process.execPath should be a string", async () => {
+      expect(typeof process.execPath).toBe("string");
+    });
+
+    await it("process.execPath should be a non-empty string", async () => {
+      expect(process.execPath.length > 0).toBeTruthy();
+    });
+
+    await it("process.platform should be a known platform", async () => {
+      const knownPlatforms = ['aix', 'darwin', 'freebsd', 'linux', 'openbsd', 'sunos', 'win32'];
+      expect(knownPlatforms).toContain(process.platform);
+    });
+
+    await it("process.arch should be a known architecture", async () => {
+      const knownArchs = ['arm', 'arm64', 'ia32', 'loong64', 'mips', 'mipsel', 'ppc', 'ppc64', 'riscv64', 's390', 's390x', 'x64'];
+      expect(knownArchs).toContain(process.arch);
+    });
+
+    await it("process.config should be an object", async () => {
+      expect(typeof process.config).toBe("object");
+    });
+
+    await it("process.execArgv should be an array", async () => {
+      expect(Array.isArray(process.execArgv)).toBeTruthy();
+    });
+
+    await it("process.argv0 should be a string", async () => {
+      expect(typeof process.argv0).toBe("string");
+      expect(process.argv0.length > 0).toBeTruthy();
+    });
+  });
+
+  await describe("process: methods", async () => {
+    await it("process.cwd() should return a string", async () => {
+      expect(typeof process.cwd()).toBe("string");
+    });
+
+    await it("process.cwd() should return an absolute path", async () => {
+      const cwd = process.cwd();
+      expect(cwd[0]).toBe("/");
+    });
+
+    await it("process.cwd() should return a path containing /", async () => {
+      const cwd = process.cwd();
+      expect(cwd).toContain("/");
+    });
+
+    await it("process.uptime() should return a number", async () => {
+      expect(typeof process.uptime()).toBe("number");
+    });
+
+    await it("process.uptime() should be >= 0", async () => {
+      expect(process.uptime() >= 0).toBeTruthy();
+    });
+
+    await it("process.uptime() should increase over time", async () => {
+      const a = process.uptime();
+      const b = process.uptime();
+      expect(b >= a).toBeTruthy();
+    });
+
+    await it("process.hrtime() should return an array of 2 numbers", async () => {
+      const hr = process.hrtime();
+      expect(Array.isArray(hr)).toBeTruthy();
+      expect(hr.length).toBe(2);
+      expect(typeof hr[0]).toBe("number");
+      expect(typeof hr[1]).toBe("number");
+    });
+
+    await it("process.hrtime() should return non-negative values", async () => {
+      const hr = process.hrtime();
+      expect(hr[0] >= 0).toBeTruthy();
+      expect(hr[1] >= 0).toBeTruthy();
+    });
+
+    await it("process.hrtime() nanoseconds should be less than 1e9", async () => {
+      const hr = process.hrtime();
+      expect(hr[1] < 1e9).toBeTruthy();
+    });
+
+    await it("process.memoryUsage() should return an object", async () => {
+      const mem = process.memoryUsage();
+      expect(typeof mem).toBe("object");
+      expect(typeof mem.rss).toBe("number");
+    });
+
+    await it("process.memoryUsage() should have heapTotal and heapUsed", async () => {
+      const mem = process.memoryUsage();
+      expect(typeof mem.heapTotal).toBe("number");
+      expect(typeof mem.heapUsed).toBe("number");
+      expect(typeof mem.external).toBe("number");
+    });
+
+    await it("process.memoryUsage() rss should be positive", async () => {
+      const mem = process.memoryUsage();
+      expect(mem.rss > 0).toBeTruthy();
+    });
+
+    await it("process.nextTick should be a function", async () => {
+      expect(typeof process.nextTick).toBe("function");
+    });
+
+    await it("process.nextTick should execute callback", async () => {
+      let called = false;
+      process.nextTick(() => { called = true; });
+      // Wait for microtask
+      await new Promise<void>(resolve => {
+        process.nextTick(resolve);
+      });
+      expect(called).toBeTruthy();
+    });
+
+    await it("process.nextTick should pass arguments", async () => {
+      const result = await new Promise<string>(resolve => {
+        process.nextTick((a: string, b: string) => resolve(a + b), 'hello', ' world');
+      });
+      expect(result).toBe('hello world');
+    });
+
+    await it("process.nextTick ordering: first scheduled runs first", async () => {
+      const order: number[] = [];
+      await new Promise<void>(resolve => {
+        process.nextTick(() => { order.push(1); });
+        process.nextTick(() => { order.push(2); });
+        process.nextTick(() => {
+          order.push(3);
+          resolve();
+        });
+      });
+      expect(order.length).toBe(3);
+      expect(order[0]).toBe(1);
+      expect(order[1]).toBe(2);
+      expect(order[2]).toBe(3);
+    });
+
+    await it("process.exit should be a function", async () => {
+      expect(typeof process.exit).toBe("function");
+    });
+
+    await it("process.kill should be a function", async () => {
+      expect(typeof process.kill).toBe("function");
+    });
+
+    await it("process.abort should be a function", async () => {
+      expect(typeof process.abort).toBe("function");
+    });
+
+    await it("process.umask should be a function", async () => {
+      expect(typeof process.umask).toBe("function");
+    });
+
+    await it("process.cpuUsage should be a function", async () => {
+      expect(typeof process.cpuUsage).toBe("function");
+    });
+
+    await it("process.cpuUsage() should return user and system", async () => {
+      const usage = process.cpuUsage();
+      expect(typeof usage.user).toBe("number");
+      expect(typeof usage.system).toBe("number");
+    });
+  });
+
+  // ==================== env ====================
+
+  await describe("process: env manipulation", async () => {
+    await it("should set and get env variables", async () => {
+      process.env.TEST_GJSIFY_VAR = 'test_value';
+      expect(process.env.TEST_GJSIFY_VAR).toBe('test_value');
+      delete process.env.TEST_GJSIFY_VAR;
+    });
+
+    await it("should delete env variables", async () => {
+      process.env.TEST_GJSIFY_DELETE = 'to_delete';
+      delete process.env.TEST_GJSIFY_DELETE;
+      expect(process.env.TEST_GJSIFY_DELETE).toBeUndefined();
+    });
+
+    await it("should coerce values to strings", async () => {
+      process.env.TEST_GJSIFY_NUM = '42';
+      expect(typeof process.env.TEST_GJSIFY_NUM).toBe('string');
+      delete process.env.TEST_GJSIFY_NUM;
+    });
+
+    await it("PATH should be defined", async () => {
+      expect(typeof process.env.PATH).toBe('string');
+      expect(process.env.PATH!.length > 0).toBeTruthy();
+    });
+
+    await it("should enumerate keys with Object.keys()", async () => {
+      const keys = Object.keys(process.env);
+      expect(Array.isArray(keys)).toBeTruthy();
+      expect(keys.length > 0).toBeTruthy();
+      expect(keys).toContain('PATH');
+    });
+
+    await it("non-existent key should return undefined", async () => {
+      expect(process.env.THIS_VAR_DOES_NOT_EXIST_GJSIFY_XYZ).toBeUndefined();
+    });
+
+    await it("should overwrite existing value", async () => {
+      process.env.TEST_GJSIFY_OVERWRITE = 'first';
+      expect(process.env.TEST_GJSIFY_OVERWRITE).toBe('first');
+      process.env.TEST_GJSIFY_OVERWRITE = 'second';
+      expect(process.env.TEST_GJSIFY_OVERWRITE).toBe('second');
+      delete process.env.TEST_GJSIFY_OVERWRITE;
+    });
+
+    await it("HOME should match os.homedir()", async () => {
+      const home = process.env.HOME;
+      expect(home).toBeDefined();
+      expect(home).toBe(os.homedir());
+    });
+  });
+
+  // ==================== hrtime.bigint ====================
+
+  await describe("process: hrtime.bigint", async () => {
+    await it("should be a function", async () => {
+      expect(typeof process.hrtime.bigint).toBe('function');
+    });
+
+    await it("should return a bigint", async () => {
+      const result = process.hrtime.bigint();
+      expect(typeof result).toBe('bigint');
+    });
+
+    await it("should be monotonically increasing", async () => {
+      const a = process.hrtime.bigint();
+      const b = process.hrtime.bigint();
+      expect(b >= a).toBeTruthy();
+    });
+
+    await it("consecutive calls should increase", async () => {
+      const first = process.hrtime.bigint();
+      // Do a tiny bit of work
+      let sum = 0;
+      for (let i = 0; i < 1000; i++) sum += i;
+      const second = process.hrtime.bigint();
+      expect(second > first).toBeTruthy();
+    });
+  });
+
+  // ==================== hrtime diff ====================
+
+  await describe("process: hrtime diff", async () => {
+    await it("should return diff when passed previous hrtime", async () => {
+      const start = process.hrtime();
+      const diff = process.hrtime(start);
+      expect(Array.isArray(diff)).toBeTruthy();
+      expect(diff.length).toBe(2);
+      expect(diff[0] >= 0).toBeTruthy();
+      expect(diff[1] >= 0).toBeTruthy();
+    });
+
+    await it("diff nanoseconds should be less than 1e9", async () => {
+      const start = process.hrtime();
+      const diff = process.hrtime(start);
+      expect(diff[1] < 1e9).toBeTruthy();
+    });
+  });
+
+  // ==================== additional properties ====================
+
+  await describe("process: additional properties", async () => {
+    await it("process.ppid should be a number", async () => {
+      expect(typeof process.ppid).toBe("number");
+    });
+
+    await it("process.exitCode should be settable", async () => {
+      const orig = process.exitCode;
+      process.exitCode = 42;
+      expect(process.exitCode).toBe(42);
+      process.exitCode = orig as any;
+    });
+
+    await it("process.title should be a string", async () => {
+      expect(typeof process.title).toBe("string");
+    });
+
+    await it("process.title should be non-empty", async () => {
+      expect(process.title.length > 0).toBeTruthy();
+    });
+
+    await it("process.stdout should be defined", async () => {
+      expect(process.stdout).toBeDefined();
+    });
+
+    await it("process.stderr should be defined", async () => {
+      expect(process.stderr).toBeDefined();
+    });
+
+    await it("process.stdin should be defined", async () => {
+      expect(process.stdin).toBeDefined();
+    });
+
+    await it("process.stdout should have write method", async () => {
+      expect(typeof process.stdout.write).toBe("function");
+    });
+
+    await it("process.stderr should have write method", async () => {
+      expect(typeof process.stderr.write).toBe("function");
+    });
+
+    await it("process.versions should contain a runtime version string", async () => {
+      // On Node.js: process.versions.node, on GJS: process.versions.gjs
+      const hasNodeVersion = typeof process.versions.node === 'string';
+      const hasGjsVersion = typeof process.versions.gjs === 'string';
+      expect(hasNodeVersion || hasGjsVersion).toBe(true);
+    });
+  });
+
+  // ==================== chdir ====================
+
+  await describe("process: chdir", async () => {
+    await it("should change and restore directory", async () => {
+      const original = process.cwd();
+      process.chdir('/tmp');
+      expect(process.cwd()).toBe('/tmp');
+      process.chdir(original);
+      expect(process.cwd()).toBe(original);
+    });
+
+    await it("chdir to non-existent dir should throw", async () => {
+      const fn = () => process.chdir('/this/path/does/not/exist/gjsify');
+      expect(fn).toThrow();
+    });
+  });
+
+  // ==================== emitWarning ====================
+
+  await describe("process: emitWarning", async () => {
+    await it("should be a function", async () => {
+      expect(typeof process.emitWarning).toBe("function");
+    });
+  });
+
+  // ==================== EventEmitter interface ====================
+
+  await describe("process: EventEmitter", async () => {
+    await it("should have on method", async () => {
+      expect(typeof process.on).toBe("function");
+    });
+
+    await it("should have emit method", async () => {
+      expect(typeof process.emit).toBe("function");
+    });
+
+    await it("should have removeListener method", async () => {
+      expect(typeof process.removeListener).toBe("function");
+    });
+
+    await it("should have once method", async () => {
+      expect(typeof process.once).toBe("function");
+    });
+
+    await it("should have removeAllListeners method", async () => {
+      expect(typeof process.removeAllListeners).toBe("function");
+    });
+
+    await it("should be able to register exit listener", async () => {
+      const handler = () => {};
+      process.on('exit', handler);
+      // Should not throw — just register
+      process.removeListener('exit', handler);
+    });
+
+    await it("should emit and receive custom events", async () => {
+      let received = false;
+      const handler = () => { received = true; };
+      process.on('test-custom-event', handler);
+      process.emit('test-custom-event');
+      expect(received).toBeTruthy();
+      process.removeListener('test-custom-event', handler);
     });
   });
-};
+};