@bongos/core 1.19.376 → 1.19.378

package/tests/setup_smoke.mjs

@@ -22,8 +22,9 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const REPO_ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const SETUP_JS = path.join(REPO_ROOT, 'scripts/gds/setup.js');
 
 const tests = [];
@@ -36,7 +37,8 @@ function makeFreshHome() {
 
 function runSetup(args, env = {}) {
   return spawnSync('node', [SETUP_JS, ...args], {
-    env: { ...process.env, ...env },
+    // os.homedir() reads USERPROFILE on Windows, so a HOME override alone leaks the real home there.
+    env: { ...process.env, ...env, ...(env.HOME ? { USERPROFILE: env.HOME } : {}) },
     encoding: 'utf8',
     timeout: 15000,
   });

package/tests/test_path_guard.mjs

@@ -0,0 +1,126 @@
+// tests/test_path_guard.mjs — the guard that keeps a test runnable on a checkout
+// whose path has a space in it (task 1002889).
+//
+// Four tests built their repo root from URL.pathname and threw MODULE_NOT_FOUND at
+// load on the owner's Windows checkout, while CI (no space in its path) stayed
+// green. The guard is tested on synthetic sources, not only the live tree: a scan
+// that passes because the tree is clean today proves nothing about what it REFUSES.
+//
+// The defective form is spelled by concatenation below so this file never trips the
+// guard it tests.
+//
+// Of the four files the task named, tests/provisioning_github_app_routes.mjs had
+// already been converted before this landed (915d273b, task 1003236 — fileURLToPath
+// at its line 17), so it is absent from this change on purpose; the live-tree case
+// at the bottom is what proves all four are clean.
+//
+// Run:  node tests/test_path_guard.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { checkTestsUseFileUrlToPath, scanTests } = require('../scripts/gds/test-path-guard.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+const from = (map) => ({
+  files: Object.keys(map),
+  read: (rel) => (rel in map ? map[rel] : null),
+});
+
+const BAD_TAIL = 'import.meta.url)' + '.pathname';
+
+// --- THE DEFECT ------------------------------------------------------------
+
+test('the shipped defect is refused, with its line and the fix', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/bad.mjs':
+      "import { createRequire } from 'node:module';\n"
+      + `const ROOT = new URL('..', ${BAD_TAIL};\n`
+      + 'const mod = require(`${ROOT}/modules/x.js`);\n',
+  })));
+  assert.equal(violations.length, 1);
+  assert.match(violations[0], /bad\.mjs:2/, 'names the file and line');
+  assert.match(violations[0], /%20/, 'says WHY it breaks');
+  assert.match(violations[0], /fileURLToPath/, 'and what to write instead');
+});
+
+test('the dirname form is the same defect', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/smoke.mjs': `const REPO_ROOT = path.resolve(path.dirname(new URL(${BAD_TAIL}), '..');\n`,
+  })));
+  assert.equal(violations.length, 1);
+});
+
+test('every site in a file is reported, not just the first', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/two.mjs':
+      `const a = path.resolve(new URL('..', ${BAD_TAIL});\n`
+      + 'x();\n'
+      + `const b = path.resolve(new URL('..', ${BAD_TAIL});\n`,
+  })));
+  assert.equal(violations.length, 2);
+  assert.match(violations[1], /two\.mjs:3/);
+});
+
+// --- WHAT IT MUST NOT FLAG -------------------------------------------------
+
+test('fileURLToPath and a relative createRequire are the correct forms — never flagged', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/good_a.mjs':
+      "import { fileURLToPath } from 'node:url';\n"
+      + "const ROOT = fileURLToPath(new URL('..', import.meta.url));\n",
+    'tests/good_b.mjs':
+      "const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');\n",
+    'tests/good_c.mjs':
+      "const require = createRequire(import.meta.url);\n"
+      + "const mod = require('../modules/x.js');\n",
+  })));
+  assert.deepEqual(violations, []);
+});
+
+test('a request URL parsed for its pathname is not the defect', () => {
+  // http tests routinely do this; the guard is about import.meta.url only.
+  const { violations } = scanTests(...Object.values(from({
+    'tests/routes.mjs': "const { pathname } = new URL(req.url, 'http://x');\nconst p = new URL(req.url, base).pathname;\n",
+  })));
+  assert.deepEqual(violations, []);
+});
+
+// --- THE SCAN MUST NOT SILENTLY SUCCEED ------------------------------------
+
+test('an empty enumeration is a hard FAIL, not a clean pass', () => {
+  const r = checkTestsUseFileUrlToPath({ files: [], read: () => null });
+  assert.equal(r.hardFail, true);
+  assert.match(r.violations[0], /scan defect/);
+});
+
+test('an unreadable file is skipped without being counted as scanned', () => {
+  const { scanned } = scanTests(['gone.mjs'], () => null);
+  assert.equal(scanned, 0);
+});
+
+test('the check reports hardFail so CI actually stops', () => {
+  const r = checkTestsUseFileUrlToPath(from({
+    'tests/bad.mjs': `const ROOT = new URL('..', ${BAD_TAIL};\n`,
+  }));
+  assert.equal(r.ok, false);
+  assert.equal(r.hardFail, true);
+});
+
+// --- THE LIVE TREE ---------------------------------------------------------
+
+test('the tracked tests/ tree is clean (the four sites of task 1002889 are fixed)', () => {
+  const r = checkTestsUseFileUrlToPath();
+  assert.equal(r.hardFail, false, r.violations.join('\n'));
+  assert.ok(/^\d+ test file\(s\) scanned/.test(r.note) && !r.note.startsWith('0 '), r.note);
+});
+
+console.log(`\ntest_path_guard: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);