kempo-testing-framework 1.4.8 → 1.4.10

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "kempo-testing-framework",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "description": "The Kempo Testing Framework is a simple testing framework built on the principle that code intended to be ran in the browser should be tested in the browser, code intended to be ran in Node should be tested in Node, and code intended to be ran in both should be tested in both. No mocking, no complexity—just testing.",
   "main": "index.js",
   "bin": {
     "kempo-test": "./index.js"
   },
   "scripts": {
-    "test": "npx kempo-test",
-    "test:gui": "npx kempo-test --gui"
+    "test": "npx kempo-test -t 90000",
+    "test:gui": "npx kempo-test -t 90000 --gui"
   },
   "keywords": [],
   "author": "",
@@ -16,7 +16,7 @@
   "type": "module",
   "dependencies": {
     "kempo-css": "^2.1.9",
-    "puppeteer": "^24.9.0"
+    "puppeteer": "^25.6.0"
   },
   "repository": {
     "type": "git",

package/tests/src/browserTestServer.node-test.js

@@ -1,8 +1,15 @@
 import http from 'http';
 import { startServer, stopServer } from '../../src/browserTestServer.js';
 
+/*
+  agent: false opts out of the global agent's connection pool. Node keeps that pool alive by
+  default, so a socket left over from an earlier test survives the server being stopped, and the
+  next test — which restarts a server on the same port — reuses a connection the previous server
+  already destroyed. The result is an intermittent "socket hang up" that has nothing to do with
+  what is being tested.
+*/
 const get = (port, path) => new Promise((resolve, reject) => {
-  const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
+  const req = http.request({ hostname: 'localhost', port, path, method: 'GET', agent: false }, (res) => {
     let data = '';
     res.on('data', chunk => { data += chunk.toString(); });
     res.on('end', () => resolve({ status: res.statusCode, body: data }));

package/tests/src/cli.node-test.js

@@ -2,28 +2,58 @@ import { spawn } from 'child_process';
 
 const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
 
-const run = (args, timeoutMs = 10000) => new Promise((resolve) => {
+/*
+  Resolves with { out, timedOut }. The distinction matters: this used to resolve with whatever had
+  been printed so far when the timer fired, so a run that was merely slow failed as though the CLI
+  had printed the wrong thing. Callers can now tell "did not finish" apart from "finished and said
+  something unexpected", and only retry the former.
+*/
+const run = (args, timeoutMs = 25000) => new Promise((resolve) => {
   const child = spawn(process.execPath, ['index.js', ...args], {
     cwd: process.cwd(),
     stdio: ['ignore', 'pipe', 'pipe']
   });
   let out = '';
-  const finish = () => { try { child.kill('SIGTERM'); } catch {} resolve(out); };
+  let settled = false;
+  const finish = (timedOut) => {
+    if(settled) return;
+    settled = true;
+    clearTimeout(timer);
+    try { child.kill('SIGTERM'); } catch {}
+    resolve({ out, timedOut });
+  };
+  const timer = setTimeout(() => finish(true), timeoutMs);
   child.stdout.on('data', c => { out += c.toString(); });
   child.stderr.on('data', c => { out += c.toString(); });
-  child.on('exit', finish);
-  setTimeout(finish, timeoutMs);
+  child.on('exit', () => finish(false));
 });
 
 export default {
+  /*
+    The post-test log only prints once the in-page run has reported results, so this depends on a
+    headful Chromium completing a full round trip. That normally takes ~2.5s but occasionally
+    stalls past the runner's own 30s page timeout, at which point the CLI legitimately never gets
+    there. One retry covers that, and only when the run did not finish — output that came back
+    wrong is a real failure and is never retried.
+  */
   'passes delay to browser runner and prints delay logs in verbose': async ({ pass, fail }) => {
-    const out = await run(['-b', '-w', '-l', 'verbose', '-d', '200', 'counter']);
+    /*
+      A port of its own. The child starts a browser test server, and the suite running this test
+      starts one too — both defaulted to 3000, so whichever bound second died with EADDRINUSE and
+      took the whole run down.
+    */
+    const args = ['-b', '-w', '-l', 'verbose', '-d', '200', '-p', '3211', 'counter'];
+    let { out, timedOut } = await run(args);
+    if(timedOut) ({ out, timedOut } = await run(args));
+    if(timedOut) return fail('CLI did not finish within 25s on two consecutive attempts');
+
     const txt = stripAnsi(out);
     const ok = /Applying pre-test browser delay: 200ms/.test(txt) && /Applying post-test browser delay: 200ms/.test(txt);
-  ok ? pass('CLI printed verbose delay logs for browser run') : fail(`Unexpected CLI output:\n${out}`);
+    ok ? pass('CLI printed verbose delay logs for browser run') : fail(`Unexpected CLI output:\n${out}`);
   },
   'node-only ignores delay and still runs filtered tests': async ({ pass, fail }) => {
-    const out = await run(['-n', '-l', 'minimal', 'example']);
+    const { out, timedOut } = await run(['-n', '-l', 'minimal', '-p', '3212', 'example']);
+    if(timedOut) return fail('CLI did not finish within 25s');
     const txt = stripAnsi(out);
     const hasSummary = /=== Test Summary ===/.test(txt) && /Total Tests:\s*\d+/.test(txt);
     const noBrowser = !/=== Browser Test Results ===/.test(txt) && !/Running Browser test:/.test(txt);