a9a7a328e6
Mechanical rename produced by scripts/msd-rename.cjs: gsd/Gsd/GSD -> msd/Msd/MSD across contents and paths, upstream package/repo coordinates -> @golem15/msd-core and golem15com/msd-core. Deep links into upstream history, sibling upstream packages, the GSD-2 import feature, CHANGELOG.md and .changeset/ are kept as-is. Hand edits on top: MSD block-letter banner and logos, LICENSE copyright line, package/plugin identity, regenerated lockfile, install-tree fixtures, derived registries and benchmark baseline; migration checksum baseline re-locked (MSD keeps its own install state, so no install had applied the old sums); sort-order and regex-escaped expectations in tests adjusted.
369 lines
15 KiB
JavaScript
369 lines
15 KiB
JavaScript
'use strict';
|
|
|
|
const { describe, test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const path = require('node:path');
|
|
const fs = require('node:fs');
|
|
|
|
const {
|
|
resolveFallowBinary,
|
|
requireFallowBinary,
|
|
} = require(path.join(__dirname, '..', 'msd-core', 'bin', 'lib', 'fallow-runner.cjs'));
|
|
const {
|
|
resolveExecutableBinary,
|
|
} = require(path.join(__dirname, '..', 'msd-core', 'bin', 'lib', 'shell-command-projection.cjs'));
|
|
|
|
const { createTempDir, cleanup } = require('./helpers.cjs');
|
|
|
|
// `resolveFallowBinary` resolves through the seam using the REAL process.platform —
|
|
// it has no platform injection. So the fixture, not the assertion, is what varies:
|
|
// on win32 the seam only accepts a PATHEXT-listed extension (never a bare name, by
|
|
// design — the #3275 npm sh-shim trap), so the staged file must carry one there.
|
|
// This keeps every row genuinely executing on all three CI lanes instead of
|
|
// silently no-opping on one.
|
|
//
|
|
// The extension's CASE must come from the same source the seam itself falls
|
|
// back to (fallow-runner.cjs passes `process.env.PATHEXT ?? ''`, and the seam
|
|
// falls back to its own DEFAULT_PATHEXT `.EXE;.CMD;.BAT;.COM` when that's
|
|
// empty) — resolveExecutableBinary returns `name + <PATHEXT entry AS-IS>`,
|
|
// never the on-disk file's own casing, so a hardcoded 'fallow.cmd' would
|
|
// silently mismatch a real Windows PATHEXT of '.CMD' with a strict
|
|
// assert.equal (case-insensitive filesystem, case-SENSITIVE string compare).
|
|
const WIN32_CMD_EXT = (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
|
|
.split(';')
|
|
.find((ext) => ext.toLowerCase() === '.cmd') ?? '.CMD';
|
|
const FALLOW_FIXTURE = process.platform === 'win32' ? `fallow${WIN32_CMD_EXT}` : 'fallow';
|
|
|
|
// ─── fallow-runner (#3618 Phase 2) ──────────────────────────────────────────
|
|
// Fold of the prior private resolver onto the seam's resolveExecutableBinary.
|
|
// See .msd/phase/chore-3618-fallow-binary-resolution/50-test-matrix.md (F1-F15).
|
|
//
|
|
// Executability (X_OK) cannot be forced via chmod — root Docker bypasses mode
|
|
// bits, which would silently zero out coverage. Every case that needs a POSIX
|
|
// "is executable" or "is not executable" outcome monkeypatches fs.accessSync
|
|
// instead, restored in a finally.
|
|
//
|
|
// F7-F10 (the win32 rows) cannot inject a platform through
|
|
// resolveFallowBinary's public signature, so they are asserted directly
|
|
// against resolveExecutableBinary with platform:'win32' plus the same
|
|
// prependPaths/requireExecutable shape resolveFallowBinary passes — a
|
|
// projection of fallow's call, not fallow's own entry point (approach (a)
|
|
// from the phase brief).
|
|
function resolveFallowBinaryWin32({ cwd, envPath = '' }) {
|
|
return resolveExecutableBinary('fallow', {
|
|
platform: 'win32',
|
|
prependPaths: [path.join(cwd, 'node_modules', '.bin')],
|
|
env: { PATH: envPath, PATHEXT: process.env['PATHEXT'] ?? '' },
|
|
requireExecutable: true,
|
|
});
|
|
}
|
|
|
|
describe('resolveFallowBinary (#3618)', () => {
|
|
test('F1: POSIX, executable fallow in <cwd>/node_modules/.bin only — the .bin path', () => {
|
|
const cwd = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(binDir, { recursive: true });
|
|
const fallowPath = path.join(binDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => {};
|
|
const resolved = resolveFallowBinary({ cwd, envPath: '' });
|
|
assert.equal(resolved, fallowPath);
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F2: POSIX, fallow on envPath only — the PATH copy', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const fallowPath = path.join(pathDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => {};
|
|
const resolved = resolveFallowBinary({ cwd, envPath: pathDir });
|
|
assert.equal(resolved, fallowPath);
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F3: POSIX, executable fallow in BOTH .bin and PATH — .bin wins (documented-backwards precedence)', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(binDir, { recursive: true });
|
|
const binFallow = path.join(binDir, FALLOW_FIXTURE);
|
|
const pathFallow = path.join(pathDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(binFallow, '');
|
|
fs.writeFileSync(pathFallow, '');
|
|
fs.accessSync = () => {};
|
|
const resolved = resolveFallowBinary({ cwd, envPath: pathDir });
|
|
assert.equal(resolved, binFallow);
|
|
assert.notEqual(resolved, pathFallow);
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F4: accessSync failure yields null on POSIX; on win32 requireExecutable is a documented no-op', () => {
|
|
const cwd = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(binDir, { recursive: true });
|
|
const fallowPath = path.join(binDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => { throw Object.assign(new Error('EACCES'), { code: 'EACCES' }); };
|
|
const resolved = resolveFallowBinary({ cwd, envPath: '' });
|
|
if (process.platform === 'win32') {
|
|
// requireExecutable is a documented no-op on win32 (mode bits don't
|
|
// mean execute there), so accessSync throwing must NOT block resolution.
|
|
assert.equal(resolved, fallowPath);
|
|
} else {
|
|
// POSIX: the X_OK check is consulted, so a throwing accessSync must null out.
|
|
assert.equal(resolved, null);
|
|
}
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F5: absent everywhere — null', () => {
|
|
const cwd = createTempDir();
|
|
try {
|
|
const resolved = resolveFallowBinary({ cwd, envPath: '' });
|
|
assert.equal(resolved, null);
|
|
} finally {
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F6: envPath omitted (default from process.env.PATH), binary in .bin — resolves from .bin', () => {
|
|
const cwd = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
const originalPath = process.env.PATH;
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(binDir, { recursive: true });
|
|
const fallowPath = path.join(binDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => {};
|
|
process.env.PATH = '';
|
|
// Call shape production uses (structural-pre-pass.md): no envPath.
|
|
const resolved = resolveFallowBinary({ cwd });
|
|
assert.equal(resolved, fallowPath);
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
process.env.PATH = originalPath;
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F7: win32, fallow.CMD in .bin — resolves .bin/fallow.CMD', () => {
|
|
const cwd = createTempDir();
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(binDir, { recursive: true });
|
|
const fallowCmd = path.join(binDir, 'fallow.CMD');
|
|
fs.writeFileSync(fallowCmd, '');
|
|
const resolved = resolveFallowBinaryWin32({ cwd, envPath: '' });
|
|
assert.equal(resolved, fallowCmd);
|
|
} finally {
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F8: win32, fallow.EXE and fallow.CMD both on PATH — .EXE wins (PATHEXT default order)', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
try {
|
|
const exePath = path.join(pathDir, 'fallow.EXE');
|
|
const cmdPath = path.join(pathDir, 'fallow.CMD');
|
|
fs.writeFileSync(exePath, '');
|
|
fs.writeFileSync(cmdPath, '');
|
|
const resolved = resolveFallowBinaryWin32({ cwd, envPath: pathDir });
|
|
assert.equal(resolved, exePath);
|
|
assert.notEqual(resolved, cmdPath);
|
|
} finally {
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F9: win32, extensionless fallow beside fallow.CMD — resolves fallow.CMD, never the shim (#3275 trap)', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
try {
|
|
const bareFallow = path.join(pathDir, 'fallow');
|
|
const cmdFallow = path.join(pathDir, 'fallow.CMD');
|
|
fs.writeFileSync(bareFallow, '');
|
|
fs.writeFileSync(cmdFallow, '');
|
|
const resolved = resolveFallowBinaryWin32({ cwd, envPath: pathDir });
|
|
assert.equal(resolved, cmdFallow);
|
|
assert.notEqual(resolved, bareFallow);
|
|
} finally {
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F10: win32, only an extensionless fallow — null (intentional change)', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
try {
|
|
fs.writeFileSync(path.join(pathDir, 'fallow'), '');
|
|
const resolved = resolveFallowBinaryWin32({ cwd, envPath: pathDir });
|
|
assert.equal(resolved, null);
|
|
} finally {
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F11: requireFallowBinary with a binary present — returns the path, does not throw', () => {
|
|
const cwd = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(binDir, { recursive: true });
|
|
const fallowPath = path.join(binDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => {};
|
|
const resolved = requireFallowBinary({ cwd, envPath: '' });
|
|
assert.equal(resolved, fallowPath);
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F12: requireFallowBinary with nothing found — throws the byte-identical install-instructions message', () => {
|
|
const cwd = createTempDir();
|
|
try {
|
|
let caught = null;
|
|
try {
|
|
requireFallowBinary({ cwd, envPath: '' });
|
|
} catch (err) {
|
|
caught = err;
|
|
}
|
|
assert.ok(caught instanceof Error, 'requireFallowBinary must throw when nothing is found');
|
|
assert.equal(
|
|
caught.message,
|
|
'Fallow is enabled but no binary was found. Please install fallow via `npm install -D fallow` or `cargo install fallow`.',
|
|
);
|
|
} finally {
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
test('F13: <cwd> has no node_modules at all — no throw; falls through to PATH', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
const originalPath = process.env.PATH;
|
|
try {
|
|
const fallowPath = path.join(pathDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => {};
|
|
process.env.PATH = pathDir;
|
|
// Call shape production uses (structural-pre-pass.md): no envPath.
|
|
assert.doesNotThrow(() => {
|
|
const resolved = resolveFallowBinary({ cwd });
|
|
assert.equal(resolved, fallowPath);
|
|
});
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
process.env.PATH = originalPath;
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F14: <cwd>/node_modules/.bin exists but is a file, not a directory — no throw; falls through', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const nodeModulesDir = path.join(cwd, 'node_modules');
|
|
fs.mkdirSync(nodeModulesDir, { recursive: true });
|
|
fs.writeFileSync(path.join(nodeModulesDir, '.bin'), ''); // .bin is a FILE, not a dir
|
|
const fallowPath = path.join(pathDir, FALLOW_FIXTURE);
|
|
fs.writeFileSync(fallowPath, '');
|
|
fs.accessSync = () => {};
|
|
assert.doesNotThrow(() => {
|
|
const resolved = resolveFallowBinary({ cwd, envPath: pathDir });
|
|
assert.equal(resolved, fallowPath);
|
|
});
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
|
|
test('F15: a directory named fallow in .bin — not resolved (isFile() is the predicate)', () => {
|
|
const cwd = createTempDir();
|
|
const originalAccessSync = fs.accessSync;
|
|
try {
|
|
const binDir = path.join(cwd, 'node_modules', '.bin');
|
|
fs.mkdirSync(path.join(binDir, FALLOW_FIXTURE), { recursive: true }); // fallow is a DIRECTORY
|
|
fs.accessSync = () => {};
|
|
const resolved = resolveFallowBinary({ cwd, envPath: '' });
|
|
assert.equal(resolved, null);
|
|
} finally {
|
|
fs.accessSync = originalAccessSync;
|
|
cleanup(cwd);
|
|
}
|
|
});
|
|
|
|
// P3 (#3619, epic #3411 Phase 3): resolveFallowBinary switched from
|
|
// `env: { PATH: envPath, PATHEXT: process.env['PATHEXT'] ?? '' }` to
|
|
// `pathOverride: envPath` so this module never reads PATHEXT itself (the
|
|
// shape local/no-private-binary-resolution forbids outside the seam). The
|
|
// seam's `env` param is left unset, so it defaults to `process.env` inside
|
|
// resolveExecutableBinary — a REAL ambient process.env.PATHEXT must still
|
|
// govern win32 resolution exactly as it did before the switch. This is the
|
|
// row the whole switch could have silently broken.
|
|
//
|
|
// PATHEXT is meaningless on POSIX (R21), so per F4's pattern above, BOTH
|
|
// platform contracts are asserted explicitly rather than skipping either:
|
|
// a `t.skip()`/bare `return` would make this a vacuous pass on that lane.
|
|
test('P3: a real ambient process.env.PATHEXT still governs win32 resolution after the env -> pathOverride switch', () => {
|
|
const cwd = createTempDir();
|
|
const pathDir = createTempDir();
|
|
const originalPathext = process.env.PATHEXT;
|
|
try {
|
|
process.env.PATHEXT = '.XYZ';
|
|
const distinctiveFixture = path.join(pathDir, 'fallow.XYZ');
|
|
fs.writeFileSync(distinctiveFixture, '');
|
|
const resolved = resolveFallowBinary({ cwd, envPath: pathDir });
|
|
if (process.platform === 'win32') {
|
|
// win32: ambient process.env.PATHEXT ('.XYZ') is consulted, so the
|
|
// distinctively-extensioned fixture resolves — proving the pass-through
|
|
// was preserved by pathOverride, not silently dropped.
|
|
assert.equal(resolved, distinctiveFixture);
|
|
} else {
|
|
// POSIX: PATHEXT plays no role in resolution at all (resolveExecutableBinary
|
|
// matches the bare name 'fallow' exactly); a file named 'fallow.XYZ' is not
|
|
// that name, so nothing is found.
|
|
assert.equal(resolved, null);
|
|
}
|
|
} finally {
|
|
if (originalPathext === undefined) delete process.env.PATHEXT; else process.env.PATHEXT = originalPathext;
|
|
cleanup(cwd);
|
|
cleanup(pathDir);
|
|
}
|
|
});
|
|
});
|