fullstack-critic 1.0.0 → 1.0.3

package/tests/sysinfo.test.js

@@ -0,0 +1,121 @@
+'use strict';
+/**
+ * sysinfo unit tests — deliberately exercise the PURE, deterministic parts of the
+ * OS telemetry (grouping, CPU-delta, categorisation, ETA math) so they pass on
+ * any machine, plus a bounded check that the live process probe never throws.
+ */
+const test = require('node:test');
+const assert = require('node:assert');
+
+const sys = require('../src/sysinfo');
+
+test('classify() folds process names into structured categories', () => {
+  assert.strictEqual(sys.classify('node'), 'runtime');
+  assert.strictEqual(sys.classify('chrome'), 'browser');
+  assert.strictEqual(sys.classify('MicrosoftEdge'), 'browser');
+  assert.strictEqual(sys.classify('powershell'), 'terminal');
+  assert.strictEqual(sys.classify('Code'), 'editor');
+  assert.strictEqual(sys.classify('postgres'), 'database');
+  assert.strictEqual(sys.classify('com.docker.backend'), 'container');
+  assert.strictEqual(sys.classify('git'), 'vcs');
+  assert.strictEqual(sys.classify('svchost'), 'system');
+  assert.strictEqual(sys.classify('mystery-thing'), 'other');
+});
+
+test('toAppRows() computes real per-app CPU% from a sample delta', () => {
+  const procs = [
+    { pid: 1, name: 'node', cpuSec: 2, memBytes: 1000 },
+    { pid: 2, name: 'node', cpuSec: 1, memBytes: 500 },
+    { pid: 3, name: 'chrome', cpuSec: 0.5, memBytes: 4000 },
+  ];
+  // One second earlier: node pid1 used 1s CPU, pid2 1s, chrome 0.5s (no change).
+  const prev = new Map([
+    [1, { cpuSec: 1, ts: 0 }],
+    [2, { cpuSec: 1, ts: 0 }],
+    [3, { cpuSec: 0.5, ts: 0 }],
+  ]);
+  const { rows } = sys.toAppRows(procs, prev, 1000, /* cores */ 8);
+  const node = rows.find((r) => r.app === 'node');
+  const chrome = rows.find((r) => r.app === 'chrome');
+  assert.strictEqual(node.count, 2, 'two node processes folded into one app');
+  assert.ok(Math.abs(node.cpuPct - 100) < 1, 'pid1 grew 1 CPU-sec in 1 wall-sec = ~100% (pid2 flat)');
+  assert.strictEqual(chrome.cpuPct, 0, 'no CPU-sec delta → 0%');
+  assert.strictEqual(node.category, 'runtime');
+});
+
+test('toAppRows() uses ps instantaneous % on POSIX-style rows and clamps to cores', () => {
+  const procs = [{ pid: 9, name: 'python', memBytes: 10, cpuPctRaw: 1600 }]; // absurd value
+  const { rows } = sys.toAppRows(procs, null, 1000, /* cores */ 8);
+  assert.strictEqual(rows[0].cpuPct, 800, 'clamped to cores*100');
+});
+
+test('byCategory() aggregates counts and memory per category', () => {
+  const rows = [
+    { app: 'node', category: 'runtime', count: 2, cpuPct: 10, memBytes: 1000 },
+    { app: 'deno', category: 'runtime', count: 1, cpuPct: 5, memBytes: 1000 },
+    { app: 'chrome', category: 'browser', count: 4, cpuPct: 20, memBytes: 9999 },
+  ];
+  const by = sys.byCategory(rows);
+  assert.strictEqual(by.runtime.count, 3);
+  assert.strictEqual(by.runtime.apps, 2);
+  assert.strictEqual(by.browser.memBytes, 9999);
+});
+
+test('cpuPctFrom() turns two os.cpus() readings into a 0-100 percentage', () => {
+  const prev = [{ times: { user: 0, nice: 0, sys: 0, idle: 100, irq: 0 } }];
+  const cur = [{ times: { user: 50, nice: 0, sys: 0, idle: 150, irq: 0 } }];
+  assert.strictEqual(sys.cpuPctFrom(prev, cur), 50);
+  assert.strictEqual(sys.cpuPctFrom(null, cur), null, 'no previous reading → null (caller degrades)');
+});
+
+test('computeEstimate(): a finished review pass reports throughput + a completed ETA', () => {
+  const e = sys.computeEstimate({ mode: 'review', passNo: 1, lastPassMs: 420, filesTotal: 30, totalLines: 1500, cores: 8 });
+  assert.strictEqual(e.complete, true);
+  assert.match(e.etaLabel, /completed in/);
+  assert.ok(e.scanRateFps > 70 && e.scanRateFps < 72, 'files/sec from measured duration (' + e.scanRateFps + ')');
+  assert.strictEqual(e.lastPassMs, 420);
+});
+
+test('computeEstimate(): watch mode never claims completion and stretches under load', () => {
+  const calm = sys.computeEstimate({ mode: 'watch', passNo: 3, durationsMs: [200, 300, 400], filesTotal: 50, cores: 4, cpuPct: 20 });
+  assert.strictEqual(calm.complete, false);
+  assert.match(calm.etaLabel, /re-scan/);
+  assert.strictEqual(calm.avgPassMs, 300, 'rolling average of prior passes');
+  assert.strictEqual(calm.loadFactor, 1, 'no load penalty below 60% CPU');
+
+  const hot = sys.computeEstimate({ mode: 'watch', passNo: 3, durationsMs: [300], filesTotal: 50, cores: 4, cpuPct: 100 });
+  assert.strictEqual(hot.loadFactor, 1.4, 'ETA scales up under heavy system load');
+});
+
+test('systemStatic() / memInfo() always return sane, bounded numbers', () => {
+  const s = sys.systemStatic();
+  assert.ok(s.cores >= 1);
+  assert.ok(typeof s.platform === 'string' && s.platform.length);
+  const m = sys.memInfo();
+  assert.ok(m.memPct >= 0 && m.memPct <= 100, 'memory % bounded');
+  assert.ok(m.memUsed >= 0 && m.memUsed <= m.memTotal);
+});
+
+test('createMonitor().sample() advances a bounded rolling history', () => {
+  const mon = sys.createMonitor('.');
+  const a = mon.sample();
+  const b = mon.sample();
+  assert.ok(a.system.cpuPct >= 0 && a.system.cpuPct <= 100);
+  assert.ok(b.history.length >= a.history.length, 'each sample appends a point');
+  assert.ok(mon.historyLen <= 60, 'history capped');
+  assert.ok(a.self && typeof a.self.rss === 'number' && a.self.rss > 0, 'critic self memory is real');
+});
+
+test('processesAsync() resolves with an array and never throws (bounded, offline-safe)', (_t, done) => {
+  const to = setTimeout(() => assert.fail('processesAsync did not call back in 12s'), 12000);
+  sys.processesAsync((err, rows) => {
+    clearTimeout(to);
+    assert.ok(Array.isArray(rows) || err, 'either an array (possibly empty on a locked-down box) or an err');
+    if (Array.isArray(rows) && rows.length) {
+      const p = rows[0];
+      assert.ok(Number.isInteger(p.pid) && p.pid > 0, 'a process row has an integer pid');
+      assert.ok(typeof p.name === 'string' && p.name.length, 'and a name');
+    }
+    done();
+  });
+});