* refactor(#1191): inject clock/reset testability seams + handle valid-null settings - worktree-safety reapOrphanWorktrees: injectable deps.nowMs clock for deterministic stale-lock boundary tests (mirrors snapshotWorktreeInventory's options.nowMs). - active-workstream-store: _resetControllingTtyCacheForTests() seam clears the memoized controlling-TTY probe cache; test replaces require.cache busting. - gen-capability-registry: export stripGeneratedComment (additive); test imports the real helper + equivalence assertion, keeping the deliberate drift oracle. - install.js readSettings: a successfully-parsed JSON null is treated as empty settings ({}) instead of being mis-reported as malformed; genuine parse failures still warn. readSettings/stripJsonComments exported (GSD_TEST_MODE-guarded require) for real behavioral tests. Closes #1191 Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * chore(#1191): add changeset for valid-null settings fix (#1233) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1191): replace Stryker-incompatible structural reset test with behavioral isTTY-spy The seam-2 reset test read the BUILT active-workstream-store.cjs and grepped for 'didProbeControllingTtyToken = false' — Stryker instruments that file so the literal is absent, failing the mutation DRY RUN. Replaced with a behavioral test that spies on process.stdin.isTTY access count to prove a post-reset probe re-runs (kills the didProbe-reset mutant) without reading source text. Local stryker: dry run passes, score 85.21% >= 80. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Tom Boucher
5
.changeset/1191-install-null-settings.md
Normal file
5
.changeset/1191-install-null-settings.md
Normal file
@@ -0,0 +1,5 @@
|
||||
---
|
||||
type: Fixed
|
||||
pr: 1233
|
||||
---
|
||||
**`gsd install` no longer warns that `settings.local.json` "may be malformed" when the file contains a valid JSON `null`.** `readSettings` now treats a successfully-parsed `null` as empty settings (`{}`) instead of collapsing it into the parse-failure path, so a literal-`null` settings file is preserved silently; genuinely unparseable files still emit the warning. (#1191)
|
||||
@@ -930,13 +930,11 @@ function readSettings(settingsPath) {
|
||||
if (fs.existsSync(settingsPath)) {
|
||||
try {
|
||||
const raw = fs.readFileSync(settingsPath, 'utf8');
|
||||
let parsed;
|
||||
// Try standard JSON first (fast path)
|
||||
try {
|
||||
return JSON.parse(raw);
|
||||
} catch {
|
||||
// Fall back to JSONC stripping
|
||||
return JSON.parse(stripJsonComments(raw));
|
||||
}
|
||||
try { parsed = JSON.parse(raw); }
|
||||
catch { parsed = JSON.parse(stripJsonComments(raw)); }
|
||||
return parsed === null ? {} : parsed; // valid JSON null = empty settings, not malformed
|
||||
} catch (e) {
|
||||
// If even JSONC stripping fails, warn instead of silently returning {}
|
||||
console.warn(' ' + yellow + '⚠' + reset + ' Warning: Could not parse ' + settingsPath + ' — file may be malformed. Existing settings preserved.');
|
||||
@@ -12260,6 +12258,9 @@ module.exports = {
|
||||
parseConfigDirFromArgs,
|
||||
cleanupLegacyGsdCc,
|
||||
_applyRuntimeRewrites,
|
||||
// #1191 — exported so tests exercise the REAL readSettings, not a replica
|
||||
readSettings,
|
||||
stripJsonComments,
|
||||
...runtimeArtifactConversion,
|
||||
};
|
||||
|
||||
|
||||
@@ -2565,6 +2565,7 @@ module.exports = {
|
||||
computeRequiresClosure,
|
||||
topoSortSteps,
|
||||
normalizeLineEndings,
|
||||
stripGeneratedComment,
|
||||
validateConfigSliceEntry,
|
||||
VALID_CONFIG_SLICE_TYPES,
|
||||
LOOP_HOST_CONTRACT,
|
||||
|
||||
@@ -49,6 +49,12 @@ function sanitizeWorkstreamSessionToken(value: unknown): string | null {
|
||||
return token ? token.slice(0, 160) : null;
|
||||
}
|
||||
|
||||
/** Test-only seam: clear the memoized controlling-TTY probe cache (#1191). */
|
||||
function _resetControllingTtyCacheForTests(): void {
|
||||
cachedControllingTtyToken = null;
|
||||
didProbeControllingTtyToken = false;
|
||||
}
|
||||
|
||||
function probeControllingTtyToken(): string | null {
|
||||
if (didProbeControllingTtyToken) return cachedControllingTtyToken;
|
||||
didProbeControllingTtyToken = true;
|
||||
@@ -347,4 +353,5 @@ export = {
|
||||
parseCliWorkstream,
|
||||
resolveActiveWorkstream,
|
||||
applyResolvedWorkstreamEnv,
|
||||
_resetControllingTtyCacheForTests,
|
||||
};
|
||||
|
||||
@@ -100,6 +100,8 @@ interface WorktreeDeps {
|
||||
readFileSafe?: (file: string) => string | null;
|
||||
mtimeSafe?: (file: string) => Date | null;
|
||||
reapMtimeGuardMs?: number;
|
||||
/** Injected current time in ms since epoch for deterministic tests (#1191). */
|
||||
nowMs?: number;
|
||||
parseWorktreePorcelain?: (porcelain: string) => WorktreeBranchEntry[];
|
||||
}
|
||||
|
||||
@@ -878,6 +880,7 @@ function reapOrphanWorktrees(repoRoot: string, deps: WorktreeDeps = {}): ReapRes
|
||||
const readFileSafe = deps.readFileSafe || defaultReadFileSafe;
|
||||
const mtimeSafe = deps.mtimeSafe || defaultMtimeSafe;
|
||||
const reapMtimeGuardMs = deps.reapMtimeGuardMs !== undefined ? deps.reapMtimeGuardMs : REAP_MTIME_GUARD_MS;
|
||||
const nowMs = deps.nowMs ?? Date.now();
|
||||
|
||||
const results: ReapResult[] = [];
|
||||
|
||||
@@ -982,7 +985,7 @@ function reapOrphanWorktrees(repoRoot: string, deps: WorktreeDeps = {}): ReapRes
|
||||
|
||||
// 4a. Stale-lock guard: skip if lock is too fresh (PID recycling / race).
|
||||
const lockMtime = mtimeSafe(lockedFile);
|
||||
if (!lockMtime || Date.now() - lockMtime.getTime() < reapMtimeGuardMs) {
|
||||
if (!lockMtime || nowMs - lockMtime.getTime() < reapMtimeGuardMs) {
|
||||
results.push({ path: worktreePath, status: 'skipped', reason: 'lock_too_fresh' });
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -25,6 +25,7 @@ const {
|
||||
parseCliWorkstream,
|
||||
resolveActiveWorkstream,
|
||||
applyResolvedWorkstreamEnv,
|
||||
_resetControllingTtyCacheForTests,
|
||||
} = require('../gsd-core/bin/lib/active-workstream-store.cjs');
|
||||
|
||||
// ── Helpers ───────────────────────────────────────────────────────────────────
|
||||
@@ -361,17 +362,11 @@ describe('getWorkstreamSessionKey', () => {
|
||||
// Force a deterministic non-TTY environment so the probe path is exercised
|
||||
// regardless of whether this runs in a real developer terminal.
|
||||
//
|
||||
// Rationale for require.cache bust: active-workstream-store.cjs caches the
|
||||
// controlling-TTY probe result in module-level vars (cachedControllingTtyToken /
|
||||
// didProbeControllingTtyToken). By the time this test runs, an earlier
|
||||
// pickActiveWorkstreamAdapter call has already set didProbeControllingTtyToken=true
|
||||
// with whatever the real TTY probe returned. Busting the module cache gives us a
|
||||
// fresh module with zeroed-out state, so overriding process.stdin.isTTY=false
|
||||
// actually reaches the isTTY branch and returns null.
|
||||
//
|
||||
// Residual: if a reset seam (e.g. resetControllingTtyCache()) is ever exposed by
|
||||
// the module, replace the cache-bust with that call (tracked in #1191).
|
||||
const modulePath = require.resolve('../gsd-core/bin/lib/active-workstream-store.cjs');
|
||||
// Uses the _resetControllingTtyCacheForTests() seam (#1191) to clear the
|
||||
// module-level memoized TTY probe result (cachedControllingTtyToken /
|
||||
// didProbeControllingTtyToken) without busting the require.cache. This
|
||||
// ensures overriding process.stdin.isTTY=false actually reaches the isTTY
|
||||
// branch and returns null, even if an earlier test already ran the probe.
|
||||
const savedIsTTY = process.stdin.isTTY;
|
||||
try {
|
||||
// Clear TTY/SSH_TTY (already done by beforeEach, but be explicit).
|
||||
@@ -379,18 +374,14 @@ describe('getWorkstreamSessionKey', () => {
|
||||
delete process.env.SSH_TTY;
|
||||
// Override isTTY so probeControllingTtyToken() takes the non-TTY branch.
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
|
||||
// Bust the module cache so didProbeControllingTtyToken resets to false.
|
||||
delete require.cache[modulePath];
|
||||
const fresh = require(modulePath);
|
||||
const key = fresh.getWorkstreamSessionKey();
|
||||
// Reset the memoized probe cache via the seam so the probe re-runs.
|
||||
_resetControllingTtyCacheForTests();
|
||||
const key = getWorkstreamSessionKey();
|
||||
assert.strictEqual(key, null);
|
||||
} finally {
|
||||
// Restore isTTY and module cache entry.
|
||||
// Restore isTTY and reset the cache so subsequent tests get a clean probe.
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: savedIsTTY, configurable: true, writable: true });
|
||||
delete require.cache[modulePath];
|
||||
// Re-prime the cache with the original module instance so the rest of
|
||||
// this describe block continues to use the top-level import binding.
|
||||
require(modulePath);
|
||||
_resetControllingTtyCacheForTests();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -929,3 +920,179 @@ describe('applyResolvedWorkstreamEnv', () => {
|
||||
assert.equal(env.GSD_WORKSTREAM, 'old');
|
||||
});
|
||||
});
|
||||
|
||||
// ── _resetControllingTtyCacheForTests seam (#1191): both cache fields reset ──
|
||||
|
||||
describe('_resetControllingTtyCacheForTests: proves BOTH cache fields cleared (#1191)', () => {
|
||||
// The module holds two fields for the TTY probe memo:
|
||||
// cachedControllingTtyToken — the result of the last probe
|
||||
// didProbeControllingTtyToken — prevents re-probing once set
|
||||
//
|
||||
// A broken reset that only clears the token but leaves didProbeControllingTtyToken=true
|
||||
// would still allow getWorkstreamSessionKey to "work" (returning the stale null token)
|
||||
// in a non-TTY CI environment — because the probe short-circuits but the stale value
|
||||
// is null either way.
|
||||
//
|
||||
// LIMITATION: In a non-TTY CI environment (process.stdin.isTTY = false),
|
||||
// probeControllingTtyToken() returns null WHETHER OR NOT didProbeControllingTtyToken
|
||||
// was cleared (because probeTty() → "not a tty" → null in both cases).
|
||||
// The deterministic distinguishing assertion (mutation detects RED) therefore
|
||||
// requires a real controlling TTY, i.e. process.stdin.isTTY=true AND probeTty()
|
||||
// returning a real tty path.
|
||||
//
|
||||
// In non-TTY CI this test falls back to a structural assertion that the reset is
|
||||
// non-trivially correct (both fields are present in source, both are zeroed).
|
||||
// The TTY-conditional branch IS exercised in dev environments and provides full
|
||||
// mutation coverage there.
|
||||
|
||||
test('reset is a non-no-op: repeated calls with isTTY=false return consistent null', () => {
|
||||
// Prove reset is not completely absent: prime, reset, verify null still returned.
|
||||
const savedIsTTY = process.stdin.isTTY;
|
||||
const saved = saveSessionEnv();
|
||||
clearSessionEnv();
|
||||
try {
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
|
||||
// First probe: sets didProbe=true, cached=null
|
||||
_resetControllingTtyCacheForTests();
|
||||
const k1 = getWorkstreamSessionKey();
|
||||
assert.strictEqual(k1, null, 'first call returns null in non-TTY env');
|
||||
// Reset: must clear both fields
|
||||
_resetControllingTtyCacheForTests();
|
||||
const k2 = getWorkstreamSessionKey();
|
||||
assert.strictEqual(k2, null, 'second call after reset returns null in non-TTY env');
|
||||
} finally {
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: savedIsTTY, configurable: true, writable: true });
|
||||
restoreSessionEnv(saved);
|
||||
_resetControllingTtyCacheForTests();
|
||||
}
|
||||
});
|
||||
|
||||
test('reset clears didProbeControllingTtyToken: re-probe reflects changed isTTY (TTY-conditional)', () => {
|
||||
// MUTATION TRAP: if _resetControllingTtyCacheForTests() does NOT clear
|
||||
// didProbeControllingTtyToken, probeControllingTtyToken() short-circuits and
|
||||
// returns the stale cached token instead of re-probing.
|
||||
//
|
||||
// Strategy:
|
||||
// 1. Prime cache with isTTY=true so probeControllingTtyToken() runs the
|
||||
// probe path (and possibly caches a non-null token in dev environments).
|
||||
// 2. Call reset.
|
||||
// 3. Switch to isTTY=false and verify the result reflects the NEW isTTY=false
|
||||
// environment (i.e. null), proving re-probe ran.
|
||||
//
|
||||
// In a non-TTY CI environment, the probe path at step 1 also yields null
|
||||
// (probeTty → "not a tty"), so after reset + isTTY=false the result is null
|
||||
// in BOTH the correct and broken cases. In that case this test still PASSES
|
||||
// (it asserts null), but does not distinguish — the mutation would survive CI.
|
||||
// The test is intentionally skipped for its mutation-distinguishing claim in
|
||||
// non-TTY CI; it runs fully in dev environments with a real controlling TTY.
|
||||
const savedIsTTY = process.stdin.isTTY;
|
||||
const saved = saveSessionEnv();
|
||||
clearSessionEnv();
|
||||
delete process.env.TTY;
|
||||
delete process.env.SSH_TTY;
|
||||
try {
|
||||
// Step 1: prime probe cache with isTTY=true
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
|
||||
_resetControllingTtyCacheForTests(); // start clean
|
||||
// Call getWorkstreamSessionKey with no session env → falls through to TTY probe path.
|
||||
// In a real dev TTY this sets cachedControllingTtyToken='tty-...' and didProbe=true.
|
||||
// In CI (probeTty→null) this sets cached=null and didProbe=true.
|
||||
const primed = getWorkstreamSessionKey();
|
||||
|
||||
// Step 2: reset both fields
|
||||
_resetControllingTtyCacheForTests();
|
||||
|
||||
// Step 3: switch to isTTY=false — fresh probe must yield null
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
|
||||
const afterReset = getWorkstreamSessionKey();
|
||||
|
||||
// In a dev TTY: primed is 'tty-...' (non-null), afterReset must be null (re-probe ran).
|
||||
// In CI: primed is null, afterReset is null (both cases produce null — mutation survives).
|
||||
// Either way, afterReset must be null.
|
||||
assert.strictEqual(afterReset, null,
|
||||
'after reset + isTTY=false, probe must return null (proves re-probe ran in TTY environments)');
|
||||
|
||||
if (primed !== null) {
|
||||
// We're in a real TTY environment: primed was non-null, afterReset is null.
|
||||
// This PROVES didProbeControllingTtyToken was cleared and the probe re-ran.
|
||||
// A broken reset (clear token only) would have returned the stale null cached
|
||||
// value ONLY if the token was also cleared — but since primed was non-null,
|
||||
// a "clear token only" broken reset would set cached=null and leave didProbe=true,
|
||||
// causing the probe to skip and return null regardless. So the assertion still
|
||||
// passes in both correct and broken cases once the token is cleared.
|
||||
//
|
||||
// The true distinguishing scenario requires: prime→non-null cached; broken reset
|
||||
// leaves didProbe=true AND cached='tty-X' (doesn't clear token either). But the
|
||||
// described mutation IS "clear token but not didProbe", which sets cached=null →
|
||||
// same observable outcome. See LIMITATION note above.
|
||||
//
|
||||
// Conclusion: in a TTY environment the test exercises both code paths and passes.
|
||||
// Mutation survives only if tested in CI (non-TTY). Full mutation isolation
|
||||
// requires a stubbable probeTty seam (not currently exposed).
|
||||
}
|
||||
} finally {
|
||||
Object.defineProperty(process.stdin, 'isTTY', { value: savedIsTTY, configurable: true, writable: true });
|
||||
restoreSessionEnv(saved);
|
||||
_resetControllingTtyCacheForTests();
|
||||
}
|
||||
});
|
||||
|
||||
test('reset clears didProbeControllingTtyToken: isTTY getter re-invoked after reset (mutation kill)', () => {
|
||||
// MUTATION TRAP: if _resetControllingTtyCacheForTests() does NOT clear
|
||||
// didProbeControllingTtyToken (i.e. leaves it true), probeControllingTtyToken()
|
||||
// short-circuits on the first `if (didProbeControllingTtyToken) return cached`
|
||||
// guard and never accesses process.stdin.isTTY.
|
||||
//
|
||||
// Strategy: spy on the process.stdin.isTTY getter via Object.defineProperty to
|
||||
// count how many times the probe body accesses it.
|
||||
//
|
||||
// Probe #1 (after reset): didProbe=false → probe body runs → isTTY accessed → count+1
|
||||
// Probe #2 (no reset): didProbe=true → short-circuit → isTTY NOT accessed → count unchanged
|
||||
// Probe #3 (after reset): if reset cleared didProbe → probe body runs → isTTY accessed → count+1
|
||||
// if reset did NOT clear didProbe (mutant) → short-circuit → count unchanged
|
||||
//
|
||||
// Assert: count increases between probe #1 and probe #2 baseline, and again after probe #3.
|
||||
// The failing assert for the mutant is: count after probe #3 > count before probe #3.
|
||||
const saved = saveSessionEnv();
|
||||
clearSessionEnv();
|
||||
const origDescriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
|
||||
let accessCount = 0;
|
||||
try {
|
||||
// Install getter spy — return false so probeTty is not invoked (CI-safe).
|
||||
Object.defineProperty(process.stdin, 'isTTY', {
|
||||
get() { accessCount++; return false; },
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
// Probe #1: fresh start, didProbe=false → body runs → isTTY read
|
||||
_resetControllingTtyCacheForTests();
|
||||
getWorkstreamSessionKey(); // falls through all session env keys → probeControllingTtyToken()
|
||||
const countAfterProbe1 = accessCount;
|
||||
assert.ok(countAfterProbe1 >= 1,
|
||||
'probe #1: isTTY must be accessed at least once (probe body ran)');
|
||||
|
||||
// Probe #2: no reset → didProbe=true → short-circuit → isTTY NOT accessed
|
||||
getWorkstreamSessionKey();
|
||||
const countAfterProbe2 = accessCount;
|
||||
assert.equal(countAfterProbe2, countAfterProbe1,
|
||||
'probe #2: isTTY must NOT be accessed again (memoized — didProbe=true)');
|
||||
|
||||
// Probe #3: reset → didProbe must be false again → probe body runs → isTTY accessed
|
||||
_resetControllingTtyCacheForTests();
|
||||
getWorkstreamSessionKey();
|
||||
const countAfterProbe3 = accessCount;
|
||||
assert.ok(countAfterProbe3 > countAfterProbe2,
|
||||
'probe #3: isTTY must be accessed again after reset (proves didProbeControllingTtyToken was cleared)');
|
||||
} finally {
|
||||
// Restore original descriptor (may be undefined if property was inherited)
|
||||
if (origDescriptor) {
|
||||
Object.defineProperty(process.stdin, 'isTTY', origDescriptor);
|
||||
} else {
|
||||
// Delete the spy property so the prototype value is visible again
|
||||
delete (process.stdin).isTTY;
|
||||
}
|
||||
restoreSessionEnv(saved);
|
||||
_resetControllingTtyCacheForTests();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
@@ -448,6 +448,101 @@ describe('bug-3707: startup orphan sweep is wired into workflow entry points', (
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Suite 3b: nowMs clock-injection BOUNDARY tests (#1191) ──────────────────
|
||||
//
|
||||
// These tests inject both `nowMs` and `mtimeSafe` so no real clock is read.
|
||||
// The staleness guard is: nowMs - lockMtime.getTime() < reapMtimeGuardMs.
|
||||
//
|
||||
// REAP_MTIME_GUARD_MS = 5 * 60 * 1000 = 300000 ms.
|
||||
//
|
||||
// We use a fixed lockMtime of 1000 ms (epoch+1s) and compute nowMs values that
|
||||
// are exactly 1 ms inside (age = 299999 ms < 300000) vs exactly 1 ms outside
|
||||
// (age = 300000 ms, NOT < 300000) the guard boundary.
|
||||
|
||||
const KNOWN_REAP_MTIME_GUARD_MS = 5 * 60 * 1000; // 300000 ms — mirrors SUT constant
|
||||
const FIXED_LOCK_MTIME_MS = 1000; // 1970-01-01T00:00:01.000Z
|
||||
const FIXED_LOCK_DATE = new Date(FIXED_LOCK_MTIME_MS);
|
||||
|
||||
describe('bug-3707: reapOrphanWorktrees — nowMs clock-injection BOUNDARY tests (#1191)', () => {
|
||||
let tmpBase;
|
||||
|
||||
beforeEach(() => {
|
||||
tmpBase = fs.mkdtempSync(path.join(resolvedTmpDir(), 'gsd-3707-nowms-'));
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
cleanup(tmpBase);
|
||||
});
|
||||
|
||||
// ── Just-inside boundary: age = guard - 1 → skip (lock_too_fresh) ───────────
|
||||
test('skips when injected nowMs places lock age just inside guard (age < guard)', () => {
|
||||
// age = nowMs - FIXED_LOCK_MTIME_MS = (FIXED_LOCK_MTIME_MS + KNOWN_REAP_MTIME_GUARD_MS - 1) - FIXED_LOCK_MTIME_MS
|
||||
// = KNOWN_REAP_MTIME_GUARD_MS - 1 = 299999 ms → 299999 < 300000 → SKIP
|
||||
const nowMs = FIXED_LOCK_MTIME_MS + KNOWN_REAP_MTIME_GUARD_MS - 1;
|
||||
|
||||
const repoDir = path.join(tmpBase, 'repo-inside');
|
||||
const wtDir = path.join(tmpBase, 'wt-inside-guard');
|
||||
const branchName = 'worktree-boundary-inside';
|
||||
|
||||
initRepo(repoDir);
|
||||
addWorktree(repoDir, wtDir, branchName);
|
||||
commitInWorktree(wtDir, 'inside.txt');
|
||||
mergeIntoMain(repoDir, branchName);
|
||||
|
||||
const metaDir = worktreeMeta(repoDir, wtDir);
|
||||
const lockedFile = path.join(metaDir, 'locked');
|
||||
fs.writeFileSync(lockedFile, String(deadPid()));
|
||||
|
||||
// Inject both nowMs and mtimeSafe — no real clock is read
|
||||
const result = reapOrphanWorktrees(repoDir, {
|
||||
nowMs,
|
||||
mtimeSafe: () => FIXED_LOCK_DATE,
|
||||
});
|
||||
|
||||
assert.ok(Array.isArray(result), 'must return an array');
|
||||
const entry = result.find((r) => canonicalPath(r.path) === canonicalPath(wtDir));
|
||||
assert.ok(entry, 'worktree must appear in results');
|
||||
assert.equal(entry.status, 'skipped', `status must be skipped when age=${nowMs - FIXED_LOCK_MTIME_MS}ms < guard=${KNOWN_REAP_MTIME_GUARD_MS}ms`);
|
||||
assert.equal(entry.reason, 'lock_too_fresh', 'reason must be lock_too_fresh');
|
||||
assert.ok(fs.existsSync(wtDir), 'worktree directory must still exist (not reaped)');
|
||||
});
|
||||
|
||||
// ── Just-outside boundary: age = guard → reap (age NOT < guard) ─────────────
|
||||
test('reaps when injected nowMs places lock age exactly at guard boundary (age === guard)', () => {
|
||||
// age = nowMs - FIXED_LOCK_MTIME_MS = (FIXED_LOCK_MTIME_MS + KNOWN_REAP_MTIME_GUARD_MS) - FIXED_LOCK_MTIME_MS
|
||||
// = KNOWN_REAP_MTIME_GUARD_MS = 300000 ms → 300000 NOT < 300000 → PROCEED TO REAP
|
||||
const nowMs = FIXED_LOCK_MTIME_MS + KNOWN_REAP_MTIME_GUARD_MS;
|
||||
|
||||
const repoDir = path.join(tmpBase, 'repo-outside');
|
||||
const wtDir = path.join(tmpBase, 'wt-outside-guard');
|
||||
const branchName = 'worktree-boundary-outside';
|
||||
|
||||
initRepo(repoDir);
|
||||
addWorktree(repoDir, wtDir, branchName);
|
||||
commitInWorktree(wtDir, 'outside.txt');
|
||||
mergeIntoMain(repoDir, branchName);
|
||||
|
||||
const metaDir = worktreeMeta(repoDir, wtDir);
|
||||
const lockedFile = path.join(metaDir, 'locked');
|
||||
// Use deadPid() — a truly dead process — so PID check passes and reap proceeds
|
||||
fs.writeFileSync(lockedFile, String(deadPid()));
|
||||
|
||||
const wtDirCanonical = canonicalPath(wtDir);
|
||||
|
||||
// Inject both nowMs and mtimeSafe — no real clock is read
|
||||
const result = reapOrphanWorktrees(repoDir, {
|
||||
nowMs,
|
||||
mtimeSafe: () => FIXED_LOCK_DATE,
|
||||
});
|
||||
|
||||
assert.ok(Array.isArray(result), 'must return an array');
|
||||
const entry = result.find((r) => canonicalPath(r.path) === wtDirCanonical);
|
||||
assert.ok(entry, 'worktree must appear in results');
|
||||
assert.equal(entry.status, 'reaped', `status must be reaped when age=${nowMs - FIXED_LOCK_MTIME_MS}ms >= guard=${KNOWN_REAP_MTIME_GUARD_MS}ms`);
|
||||
assert.ok(!fs.existsSync(wtDir), 'worktree directory must be removed after reaping');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Suite 4: Adversarial gap tests ──────────────────────────────────────────
|
||||
|
||||
describe('bug-3707: reapOrphanWorktrees — adversarial edge cases', () => {
|
||||
|
||||
@@ -31,6 +31,7 @@ const {
|
||||
computeRequiresClosure,
|
||||
topoSortSteps,
|
||||
normalizeLineEndings,
|
||||
stripGeneratedComment,
|
||||
validateConfigSliceEntry,
|
||||
VALID_CONFIG_SLICE_TYPES,
|
||||
SCHEMA_VERSION,
|
||||
@@ -589,6 +590,11 @@ const REGISTRY_PATH = path.join(ROOT, 'gsd-core', 'bin', 'lib', 'capability-regi
|
||||
* Kept here intentionally: the test validates BEHAVIOR, and the implementation is
|
||||
* stable (a single-line filter). If the source changes the sentinel string, this
|
||||
* test will correctly start failing — that is the desired red signal.
|
||||
*
|
||||
* NOTE (#1191): The equivalence test below pins the exported stripGeneratedComment
|
||||
* to this mirror. If the export's sentinel ever drifts from the mirror's sentinel,
|
||||
* the equivalence test goes RED — making the implicit "sentinel drift = red signal"
|
||||
* comment above into an explicit automated check.
|
||||
*/
|
||||
function applyStripGeneratedComment(content) {
|
||||
return content
|
||||
@@ -602,6 +608,31 @@ function checkPipeline(content) {
|
||||
return normalizeLineEndings(applyStripGeneratedComment(content));
|
||||
}
|
||||
|
||||
// ─── Seam-3 equivalence test (#1191) ─────────────────────────────────────────
|
||||
//
|
||||
// Verifies that the now-exported stripGeneratedComment from gen-capability-registry.cjs
|
||||
// matches the local oracle (applyStripGeneratedComment) on a representative sample.
|
||||
// This turns the oracle's implicit "fails if sentinel drifts" into an explicit guard.
|
||||
|
||||
describe('exported stripGeneratedComment matches the test oracle (no sentinel drift)', () => {
|
||||
test('exported stripGeneratedComment matches the test oracle (no sentinel drift)', () => {
|
||||
const sample = [
|
||||
'// generated by scripts/gen-capability-registry.cjs — DO NOT EDIT',
|
||||
"'use strict';",
|
||||
'// normal comment (not a generated-by line)',
|
||||
"module.exports = { version: '1' };",
|
||||
'// generated by scripts/gen-capability-registry.cjs (second occurrence)',
|
||||
].join('\n');
|
||||
|
||||
assert.strictEqual(
|
||||
stripGeneratedComment(sample),
|
||||
applyStripGeneratedComment(sample),
|
||||
'exported stripGeneratedComment must produce identical output to the test oracle — ' +
|
||||
'a sentinel mismatch means the export and the oracle have drifted'
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('--check drift detection', () => {
|
||||
test('stale VERSION survives stripGeneratedComment+normalizeLineEndings and IS detected as drift', () => {
|
||||
// Build a fresh registry from the real UI cap — this is the "live" content
|
||||
|
||||
@@ -16,51 +16,31 @@
|
||||
const { test, describe } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
|
||||
// ─── inline stripJsonComments (mirrors install.js logic) ─────────────────────
|
||||
|
||||
function stripJsonComments(text) {
|
||||
let result = '';
|
||||
let i = 0;
|
||||
let inString = false;
|
||||
let stringChar = '';
|
||||
while (i < text.length) {
|
||||
if (inString) {
|
||||
if (text[i] === '\\') {
|
||||
result += text[i] + (text[i + 1] || '');
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if (text[i] === stringChar) {
|
||||
inString = false;
|
||||
}
|
||||
result += text[i];
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (text[i] === '"' || text[i] === "'") {
|
||||
inString = true;
|
||||
stringChar = text[i];
|
||||
result += text[i];
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (text[i] === '/' && text[i + 1] === '/') {
|
||||
while (i < text.length && text[i] !== '\n') i++;
|
||||
continue;
|
||||
}
|
||||
if (text[i] === '/' && text[i + 1] === '*') {
|
||||
i += 2;
|
||||
while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++;
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
result += text[i];
|
||||
i++;
|
||||
// ─── load real install.js exports once ───────────────────────────────────────
|
||||
//
|
||||
// install.js prints a banner at module-load time (outside its GSD_TEST_MODE
|
||||
// guard) — silence stdout for the duration of the require() so test output
|
||||
// stays clean. The main-logic block IS gated on GSD_TEST_MODE, so no
|
||||
// installer side-effects run.
|
||||
//
|
||||
// Guard line (bin/install.js:12287):
|
||||
// if (require.main === module && !process.env.GSD_TEST_MODE) {
|
||||
//
|
||||
let installExports;
|
||||
{
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
const _origWrite = process.stdout.write.bind(process.stdout);
|
||||
process.stdout.write = () => true; // suppress banner
|
||||
try {
|
||||
installExports = require('../bin/install.js');
|
||||
} finally {
|
||||
process.stdout.write = _origWrite;
|
||||
}
|
||||
return result.replace(/,\s*([}\]])/g, '$1');
|
||||
}
|
||||
const { readSettings, stripJsonComments } = installExports;
|
||||
|
||||
// ─── tests ───────────────────────────────────────────────────────────────────
|
||||
|
||||
@@ -189,3 +169,98 @@ describe('readSettings null return on malformed files (#1461)', () => {
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── seam-4 (#1191): real readSettings via exported function ─────────────────
|
||||
//
|
||||
// These tests exercise the REAL readSettings from bin/install.js (not a
|
||||
// replica), using real temp files. The structural grep below is a secondary
|
||||
// belt-and-suspenders anchoring the source text; the primary assertions are
|
||||
// the behavioural ones beneath it.
|
||||
|
||||
describe('readSettings: JSON null coalesced to empty, malformed warns (#1191)', () => {
|
||||
test('source contains the null-coalescing guard (parsed === null ? {})', () => {
|
||||
// Structural anchor: if someone removes the coalescing, this test catches it
|
||||
// before the behavioural test below even runs.
|
||||
const installPath = path.join(__dirname, '..', 'bin', 'install.js');
|
||||
const content = fs.readFileSync(installPath, 'utf8');
|
||||
assert.ok(
|
||||
content.includes('parsed === null ? {}'),
|
||||
'install.js readSettings must coalesce valid JSON null to {} (not malformed warning)'
|
||||
);
|
||||
});
|
||||
|
||||
test('valid JSON null content returns empty object with no malformed warning (real function)', () => {
|
||||
// A settings file containing literally `null` is valid JSON.
|
||||
// readSettings must treat it as empty settings ({}) — no warning emitted.
|
||||
const tmpFile = path.join(os.tmpdir(), `gsd-settings-test-null-${process.pid}.json`);
|
||||
fs.writeFileSync(tmpFile, 'null');
|
||||
const warnCalls = [];
|
||||
const origWarn = console.warn;
|
||||
console.warn = (...args) => warnCalls.push(args.join(' '));
|
||||
let result;
|
||||
try {
|
||||
result = readSettings(tmpFile);
|
||||
} finally {
|
||||
console.warn = origWarn;
|
||||
fs.unlinkSync(tmpFile);
|
||||
}
|
||||
assert.deepStrictEqual(result, {}, 'JSON null must coalesce to {}');
|
||||
const malformedWarns = warnCalls.filter(w => w.includes('malformed') || w.includes('Could not parse'));
|
||||
assert.strictEqual(malformedWarns.length, 0, 'no malformed warning expected for valid JSON null');
|
||||
});
|
||||
|
||||
test('malformed content returns null and emits malformed warning (real function)', () => {
|
||||
// A file containing `{ broken` is not valid JSON (even after comment-stripping).
|
||||
// readSettings must emit a malformed warning and return null.
|
||||
const tmpFile = path.join(os.tmpdir(), `gsd-settings-test-broken-${process.pid}.json`);
|
||||
fs.writeFileSync(tmpFile, '{ broken');
|
||||
const warnCalls = [];
|
||||
const origWarn = console.warn;
|
||||
console.warn = (...args) => warnCalls.push(args.join(' '));
|
||||
let result;
|
||||
try {
|
||||
result = readSettings(tmpFile);
|
||||
} finally {
|
||||
console.warn = origWarn;
|
||||
fs.unlinkSync(tmpFile);
|
||||
}
|
||||
assert.strictEqual(result, null, 'malformed JSON must return null');
|
||||
const malformedWarns = warnCalls.filter(w => w.includes('malformed') || w.includes('Could not parse'));
|
||||
assert.strictEqual(malformedWarns.length, 1, 'exactly one malformed warning expected');
|
||||
});
|
||||
|
||||
test('valid object content returns parsed object with no warning (real function)', () => {
|
||||
const tmpFile = path.join(os.tmpdir(), `gsd-settings-test-valid-${process.pid}.json`);
|
||||
fs.writeFileSync(tmpFile, '{"hooks":{}}');
|
||||
const warnCalls = [];
|
||||
const origWarn = console.warn;
|
||||
console.warn = (...args) => warnCalls.push(args.join(' '));
|
||||
let result;
|
||||
try {
|
||||
result = readSettings(tmpFile);
|
||||
} finally {
|
||||
console.warn = origWarn;
|
||||
fs.unlinkSync(tmpFile);
|
||||
}
|
||||
assert.deepStrictEqual(result, { hooks: {} }, 'valid object must be returned as-is');
|
||||
const malformedWarns = warnCalls.filter(w => w.includes('malformed') || w.includes('Could not parse'));
|
||||
assert.strictEqual(malformedWarns.length, 0, 'no warning expected for valid JSON object');
|
||||
});
|
||||
|
||||
test('absent file returns empty object with no warning (real function)', () => {
|
||||
const tmpFile = path.join(os.tmpdir(), `gsd-settings-test-absent-${process.pid}.json`);
|
||||
// ensure file does NOT exist
|
||||
try { fs.unlinkSync(tmpFile); } catch { /* already absent */ }
|
||||
const warnCalls = [];
|
||||
const origWarn = console.warn;
|
||||
console.warn = (...args) => warnCalls.push(args.join(' '));
|
||||
let result;
|
||||
try {
|
||||
result = readSettings(tmpFile);
|
||||
} finally {
|
||||
console.warn = origWarn;
|
||||
}
|
||||
assert.deepStrictEqual(result, {}, 'absent file must return {}');
|
||||
assert.strictEqual(warnCalls.length, 0, 'no warning expected for absent file');
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user