@jskit-ai/jskit-catalog 0.2.34 → 0.2.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-catalog",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "Published metadata catalog for JSKIT package metadata.",
   "type": "module",
   "files": [

package/scripts/browser-test-servers.mjs

@@ -4,10 +4,15 @@
 // Each worker's server environment is also left, readable only by this user, where the worker's own process takes it
 // (browser-tests.mjs). With the app's `signIn` module, each server is then signed in once, and its storage state left
 // for its worker. Each server's output goes to test-results/browser-test-servers/worker-<n>.log; a server that stops
-// ends the run.
+// ends the run. A port that already answers is refused before anything is built or started: a server left there by an
+// earlier run would answer for this run's. Stopped by Playwright (SIGTERM), by Ctrl-C, or by the end of the stdin pipe
+// Playwright gives its webServer (a Playwright that ended without stopping it), the launcher stops its servers and
+// waits for them, within Playwright's grace, before it exits.
 import { spawn } from "node:child_process";
-import { createWriteStream, mkdirSync, writeFileSync } from "node:fs";
+import { once } from "node:events";
+import { createWriteStream, fstatSync, mkdirSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import net from "node:net";
 import path from "node:path";
 import process from "node:process";
 import { pathToFileURL } from "node:url";
@@ -16,6 +21,8 @@ import { buildFrontend } from "./browser-test-build.mjs";
 const SETTINGS_VARIABLE = "JSKIT_BROWSER_TESTS";
 const LOG_DIRECTORY = path.join("test-results", "browser-test-servers");
 const READY_TIMEOUT_MS = 60_000;
+// Within the 10 s gracefulShutdown browser-tests.mjs gives Playwright's webServer; a server still running then is killed.
+const STOP_WAIT_MS = 9_000;
 
 const seconds = (since) => `${((performance.now() - since) / 1000).toFixed(1)}s`;
 const words = (command) => String(command).trim().split(/\s+/u).filter(Boolean);
@@ -51,6 +58,21 @@ async function signInWorkers(appRoot, signIn, baseUrls, environments, signedInSt
   console.log(`[browser-tests] ${baseUrls.length} worker(s) signed in in ${seconds(started)}.`);
 }
 
+const answers = (host, port) => new Promise((resolve) => {
+  const socket = net.connect(port, host);
+  socket.once("connect", () => { socket.destroy(); resolve(true); });
+  socket.once("error", () => resolve(false));
+});
+
+async function refuseBusyPorts(host, ports) {
+  const taken = await Promise.all(ports.map((port) => answers(host, port)));
+  const busy = ports.filter((_, index) => taken[index]);
+  if (busy.length > 0) {
+    throw new Error(`Port ${busy.join(", ")} on ${host} already answers: a server left there would answer for this run's. ` +
+      "Stop it, or set PLAYWRIGHT_PORT to free ports.");
+  }
+}
+
 async function waitUntilReady(url, server, name) {
   const started = performance.now();
   const deadline = Date.now() + READY_TIMEOUT_MS;
@@ -72,12 +94,27 @@ async function waitUntilReady(url, server, name) {
 
 const servers = [];
 let stopping = false;
+const running = (server) => server.exitCode === null && server.signalCode === null;
 function stopServers() {
   stopping = true;
-  for (const server of servers) server.kill("SIGTERM");
+  for (const server of servers) if (running(server)) server.kill("SIGTERM");
+}
+async function stopAndExit(code) {
+  if (stopping) return;
+  stopServers();
+  const stopped = Promise.all(servers.filter(running).map((server) => once(server, "exit")));
+  await Promise.race([stopped, new Promise((resolve) => setTimeout(resolve, STOP_WAIT_MS))]);
+  for (const server of servers) if (running(server)) server.kill("SIGKILL");
+  process.exit(code);
+}
+process.once("SIGINT", () => stopAndExit(130));
+process.once("SIGTERM", () => stopAndExit(143));
+// Only a pipe ends when Playwright does; a launcher started without one (stdin ignored, /dev/null) would end at once.
+const input = fstatSync(0);
+if (input.isFIFO() || input.isSocket()) {
+  process.stdin.once("end", () => stopAndExit(1));
+  process.stdin.resume();
 }
-process.once("SIGINT", () => { stopServers(); process.exit(130); });
-process.once("SIGTERM", () => { stopServers(); process.exit(143); });
 process.once("exit", stopServers);
 
 const started = performance.now();
@@ -90,6 +127,7 @@ const baseEnvironment = { ...process.env };
 delete baseEnvironment[SETTINGS_VARIABLE];
 const baseUrls = Array.from({ length: workers }, (_, index) => `http://${host}:${basePort + index}`);
 try {
+  await refuseBusyPorts(host, baseUrls.map((_, index) => basePort + index));
   const [, workerEnvironments] = await Promise.all([
     buildFrontend({ appRoot, build }),
     prepareWorkers(appRoot, prepare, workers, baseUrls)
@@ -117,8 +155,7 @@ try {
     child.once("exit", (code, signal) => {
       if (stopping) return;
       console.error(`[browser-tests] ${name} stopped (${signal || `exit ${code}`}); log: ${log}`);
-      stopServers();
-      process.exit(1);
+      stopAndExit(1);
     });
     servers.push(child);
     return waitUntilReady(new URL(health, baseUrl), child, name);
@@ -127,6 +164,5 @@ try {
   console.log(`jskit browser tests: ${workers} server(s) ready in ${seconds(started)}; logs in ${LOG_DIRECTORY}.`);
 } catch (error) {
   console.error(`[browser-tests] ${error.message}`);
-  stopServers();
-  process.exit(1);
+  await stopAndExit(1);
 }

package/scripts/browser-tests.mjs

@@ -21,6 +21,11 @@ const DEFAULT_PORT = 4173;
 // A whole run's default bound: a suite that would take hours stops instead, and says so. A suite measured to need
 // longer passes its own globalTimeout, with the measurement beside it.
 const GLOBAL_TIMEOUT_MS = 20 * 60_000;
+// A click, fill or navigation waiting on something that never comes (a stale locator) fails in seconds, with its own
+// error, instead of holding the test until its 60 s timeout. Over 652 passing app tests the slowest action or page
+// load took 9.0 s, and expect already waits 10 s.
+const ACTION_TIMEOUT_MS = 15_000;
+const NAVIGATION_TIMEOUT_MS = 30_000;
 // Building the frontend when its sources changed, preparing the databases and starting every server.
 const SERVERS_TIMEOUT_MS = 180_000;
 // Where the servers' launcher leaves each worker's server environment, for that worker's own process.
@@ -90,6 +95,8 @@ function preparedWorkerEnvironment(file, index) {
  * @param {Record<string, string>} [options.env] Environment every server gets, such as its test-only drivers.
  * @param {string} [options.health] The path that answers 200 once a server is ready.
  * @param {number} [options.globalTimeout] The whole run's bound in milliseconds (20 minutes); never 0.
+ * @param {number} [options.actionTimeout] One click, fill or other action's bound in milliseconds (15 s); never 0.
+ * @param {number} [options.navigationTimeout] One navigation's bound in milliseconds (30 s); never 0.
  * @param {Record<string, string | undefined>} [options.environment] Read, and given a worker's prepared environment,
  *   instead of process.env (tests).
  * @param {string} [options.cwd] The directory Playwright runs in (tests).
@@ -104,12 +111,19 @@ function browserTestConfig({
   env = {},
   health = "/api/health",
   globalTimeout = GLOBAL_TIMEOUT_MS,
+  actionTimeout = ACTION_TIMEOUT_MS,
+  navigationTimeout = NAVIGATION_TIMEOUT_MS,
   environment = process.env,
   cwd = process.cwd()
 } = {}) {
   if (!Number.isInteger(globalTimeout) || globalTimeout < 1) {
     throw new Error("browserTestConfig() needs a globalTimeout of at least 1 ms; a run is always bounded.");
   }
+  for (const [name, value] of Object.entries({ actionTimeout, navigationTimeout })) {
+    if (!Number.isInteger(value) || value < 1) {
+      throw new Error(`browserTestConfig() needs an ${name} of at least 1 ms; a stale locator fails in seconds, not minutes.`);
+    }
+  }
   const managed = managedBaseUrl(environment);
   const workers = browserTestWorkers({ env: environment });
   const basePort = positiveInteger(environment.PLAYWRIGHT_PORT) || port;
@@ -145,9 +159,8 @@ function browserTestConfig({
     use: {
       baseURL: managed || `http://${HOST}:${basePort + workerIndex}`,
       headless: true,
-      // A click, fill or navigation waiting on something that never comes fails in seconds, with its own error.
-      actionTimeout: 15_000,
-      navigationTimeout: 30_000,
+      actionTimeout,
+      navigationTimeout,
       // A failed test keeps its trace to read; no screencast is recorded while tests run.
       trace: { mode: "retain-on-failure", screenshots: false, snapshots: true, sources: true },
       ...(storageState ? { storageState } : {})