cbd180c5cd
* test(#3147): bound the lint/changeset/docs cluster onto the process seam Migrates 69 unbounded sync spawn sites across 24 files. Allowlist 73 to 49. Two shared helpers move: tests/helpers/graphify.cjs (6 importing suites) and tests/fixtures/index.cjs, whose three quoted-argument shell strings became single argv elements rather than whitespace splits. changeset-lint's throw-native git() helper routes to gitOrThrow; migrating it to bare runGit would have silently swallowed a failure that is loud today. ingest-docs goes the other way -- its catch never rethrew, it degraded failure into data every call site asserts on, so throwIfFailed would have thrown where the original returned. The design doc said otherwise and was corrected. tsconfig-noemit runs a real tsc --noEmit and takes a bespoke 180000ms per the ensure-runtime-build precedent, not the 30000ms build-hooks norm -- that norm is for a file copy, and sizing against a label rather than the work is the same error in the opposite direction. * test(#3147): add toLegacyResult and settle review findings The seam exposed a throwing adapter (throwIfFailed) but no non-throwing one, so eight files independently re-derived the same unwrap back to the legacy {status, stdout, stderr} shape. That is the third time this epic produced N copies of one mechanism -- seven throw wrappers in Wave 1, fifty-two timeout constants in Wave 2, eight result adapters here. The pattern is that whenever the seam does not expose a mechanism, every suite re-derives it. toLegacyResult now sits beside throwIfFailed, with its own tests. Two sites are deliberately NOT converted: changeset-cli's runRender and runRenderIn return {status, report, stderr} from parsed JSON and never a raw stdout, so they are a different shape family. lint-legacy-dir-name keeps its local GUARD_TIMEOUT_MS: 30000 matches the build norm numerically but bounds a lint probe, not hooks bundling, and importing it would encode a coincidence as a relationship. --------- Co-authored-by: sim <sim@local>
106 lines
3.7 KiB
JavaScript
106 lines
3.7 KiB
JavaScript
const fs = require('fs');
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const { gitOrThrow } = require('../helpers/git-fixture.cjs');
|
|
|
|
/**
|
|
* Create a temp test fixture directory with canonical planning layout.
|
|
*
|
|
* @param {object} [options]
|
|
* @param {string} [options.prefix='gsd-test-']
|
|
* @param {boolean} [options.git=false] - initialize git repo with initial commit
|
|
* @param {boolean} [options.planning=true] - create .planning/phases layout
|
|
* @param {boolean} [options.projectDoc=true] - write .planning/PROJECT.md
|
|
* @returns {string} absolute fixture directory path
|
|
*/
|
|
function createFixture(options = {}) {
|
|
const {
|
|
prefix = 'gsd-test-',
|
|
git = false,
|
|
planning = true,
|
|
projectDoc = git,
|
|
} = options;
|
|
|
|
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
|
|
|
|
if (planning) {
|
|
fs.mkdirSync(path.join(tmpDir, '.planning', 'phases'), { recursive: true });
|
|
}
|
|
|
|
if (projectDoc) {
|
|
fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(tmpDir, '.planning', 'PROJECT.md'),
|
|
'# Project\n\nTest project.\n'
|
|
);
|
|
}
|
|
|
|
if (git) {
|
|
gitOrThrow(['init'], { cwd: tmpDir });
|
|
gitOrThrow(['config', 'user.email', 'test@test.com'], { cwd: tmpDir });
|
|
gitOrThrow(['config', 'user.name', 'Test'], { cwd: tmpDir });
|
|
gitOrThrow(['config', 'commit.gpgsign', 'false'], { cwd: tmpDir });
|
|
gitOrThrow(['add', '-A'], { cwd: tmpDir });
|
|
// `--allow-empty`: a fixture with `git: true, planning: false,
|
|
// projectDoc: false` (e.g. a "greenfield" starting world) stages nothing,
|
|
// so a plain `git commit` would fail with "nothing to commit" and the
|
|
// caller would never get a usable repo (there'd be no HEAD at all).
|
|
gitOrThrow(['commit', '--allow-empty', '-m', 'initial commit'], { cwd: tmpDir });
|
|
}
|
|
|
|
return tmpDir;
|
|
}
|
|
|
|
/**
|
|
* Seed a canonical phase directory with files.
|
|
* @param {string} tmpDir
|
|
* @param {string} phaseSlug e.g. "03-api"
|
|
* @param {Record<string,string>} files map of filename->content
|
|
* @returns {string} phase directory path
|
|
*/
|
|
function seedPhase(tmpDir, phaseSlug, files = {}) {
|
|
const phaseDir = path.join(tmpDir, '.planning', 'phases', phaseSlug);
|
|
fs.mkdirSync(phaseDir, { recursive: true });
|
|
for (const [name, content] of Object.entries(files)) {
|
|
fs.writeFileSync(path.join(phaseDir, name), content);
|
|
}
|
|
return phaseDir;
|
|
}
|
|
|
|
/**
|
|
* Seed a canonical workstream tree and optionally set active pointer.
|
|
* @param {string} tmpDir
|
|
* @param {{name:string, state?:string, roadmap?:string, active?:boolean}} options
|
|
* @returns {string} workstream directory path
|
|
*/
|
|
function seedWorkstream(tmpDir, options) {
|
|
const { name, state = '', roadmap = '', active = false } = options || {};
|
|
if (!name || /[^a-zA-Z0-9._-]/.test(name) || name.includes('..')) {
|
|
throw new Error(`seedWorkstream: invalid name "${name}"`);
|
|
}
|
|
const wsDir = path.join(tmpDir, '.planning', 'workstreams', name);
|
|
fs.mkdirSync(path.join(wsDir, 'phases'), { recursive: true });
|
|
if (state) fs.writeFileSync(path.join(wsDir, 'STATE.md'), state);
|
|
if (roadmap) fs.writeFileSync(path.join(wsDir, 'ROADMAP.md'), roadmap);
|
|
if (active) {
|
|
fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true });
|
|
fs.writeFileSync(path.join(tmpDir, '.planning', 'active-workstream'), `${name}\n`);
|
|
}
|
|
return wsDir;
|
|
}
|
|
|
|
/**
|
|
* Write STATE.md in canonical location.
|
|
* @param {string} tmpDir
|
|
* @param {string} content
|
|
* @returns {string} file path
|
|
*/
|
|
function writeState(tmpDir, content) {
|
|
const statePath = path.join(tmpDir, '.planning', 'STATE.md');
|
|
fs.mkdirSync(path.dirname(statePath), { recursive: true });
|
|
fs.writeFileSync(statePath, content);
|
|
return statePath;
|
|
}
|
|
|
|
module.exports = { createFixture, seedPhase, seedWorkstream, writeState };
|