@boyingliu01/xp-gate 0.31.1 → 0.31.2

package/lib/__tests__/issue-589-check-all-gate3.test.js

@@ -0,0 +1,190 @@
+/**
+ * @test REQ-608
+ * @intent `xp-gate check . --all` is documented as a full-tree check, but Gate 3
+ *         resolved its file list from `git diff`, so on a clean tree it scanned
+ *         the empty set and printed
+ *
+ *             ⏭️  SKIPPED - Complexity (no source files to check)
+ *
+ *         `--all` therefore checked LESS than a normal commit — and the wording
+ *         ("no source files to check") describes an empty PROJECT when the real
+ *         cause is an empty DIFF. Reading it as "this gate passed" is the
+ *         documented failure mode: the reporter worked around it by running lizard
+ *         by hand.
+ *
+ *         Gate 4 does not depend on CHANGED_FILES and works fine under the same
+ *         preamble, which is the proof that the file SOURCE is the defect and not
+ *         the preamble.
+ *
+ *         Under `--all` the set must be the repository's tracked sources; and a
+ *         gate that genuinely only makes sense per-change must say so, not look
+ *         like it found an empty project.
+ * @covers AC-608-01, AC-608-02, AC-608-03
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const gateRunner = require('../gate-runner.js');
+
+/**
+ * Create a throwaway git repo with one commit and a clean working tree, plus the
+ * given tracked files.
+ *
+ * A clean tree is the whole point: it is the state in which `--all` used to scan
+ * nothing.
+ *
+ * @param {string[]} files - repo-relative paths to create and commit
+ * @param {(dir: string) => void} [afterCommit] - optional mutation after the commit
+ * @returns {string} the repo directory
+ */
+function makeCleanRepo(files, afterCommit) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'xp-gate-589-'));
+  const git = (/** @type {string[]} */ args) =>
+    execFileSync('git', args, { cwd: dir, stdio: 'pipe' });
+  // Every fixture step is IO that can fail for environment reasons (no git, a
+  // read-only tmp, a path already taken). Failing with the operation and the path
+  // named turns "the test broke" into a diagnosable message instead of a bare
+  // exception from inside a helper.
+  try {
+    git(['init', '-q', '-b', 'main']);
+    git(['config', 'user.email', 't@t.t']);
+    git(['config', 'user.name', 't']);
+    git(['config', 'core.hooksPath', process.platform === 'win32' ? 'NUL' : '/dev/null']);
+    for (const f of files) {
+      const full = path.join(dir, f);
+      fs.mkdirSync(path.dirname(full), { recursive: true });
+      fs.writeFileSync(full, `// ${f}\nexport const x = 1;\n`);
+    }
+    git(['add', '-A']);
+    git(['commit', '-q', '-m', 'clean tree']);
+  } catch (err) {
+    throw new Error(`makeCleanRepo failed while preparing ${dir}: ${err.message}`);
+  }
+  if (afterCommit) afterCommit(dir);
+  return dir;
+}
+
+/**
+ * The `--all` file list the runner should produce, as a sorted array.
+ *
+ * @param {string} cwd
+ * @returns {string[]}
+ */
+function allModeFiles(cwd) {
+  const out = gateRunner.resolveAllModeChangedFiles(cwd);
+  return out.split('\n').filter(Boolean).sort();
+}
+
+describe('REQ-608: check --all scans the tree, not the diff', () => {
+  /** @type {string[]} */
+  const repos = [];
+
+  afterEach(() => {
+    for (const dir of repos.splice(0)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('AC-608-01: on a clean tree the file list is the tracked sources, not empty', () => {
+    const repo = makeCleanRepo(['src/a.ts', 'src/b.ts', 'lib/c.js']);
+    repos.push(repo);
+
+    const files = allModeFiles(repo);
+
+    expect(files).toContain('src/a.ts');
+    expect(files).toContain('src/b.ts');
+    expect(files).toContain('lib/c.js');
+  });
+
+  it('AC-608-01: data and documentation files are not claimed as sources', () => {
+    // The control that stops `--all` from becoming "every tracked file": the
+    // point is to scan SOURCES, not to hand a markdown file to lizard.
+    const repo = makeCleanRepo(['src/a.ts', 'docs/readme.md', 'data/rows.csv', 'notes.txt']);
+    repos.push(repo);
+
+    const files = allModeFiles(repo);
+
+    expect(files).toContain('src/a.ts');
+    expect(files).not.toContain('docs/readme.md');
+    expect(files).not.toContain('data/rows.csv');
+    expect(files).not.toContain('notes.txt');
+  });
+
+  it('AC-608-01: every supported language extension is discovered', () => {
+    const repo = makeCleanRepo([
+      'a.ts', 'b.tsx', 'c.js', 'd.py', 'e.go', 'f.java', 'g.kt', 'h.rs', 'i.sh',
+    ]);
+    repos.push(repo);
+
+    const files = allModeFiles(repo);
+
+    for (const f of ['a.ts', 'b.tsx', 'c.js', 'd.py', 'e.go', 'f.java', 'g.kt', 'h.rs', 'i.sh']) {
+      expect(files, `${f} must be a source file`).toContain(f);
+    }
+  });
+
+  it('AC-608-02: an empty file list explains that the DIFF is empty, not the project', () => {
+    // The exact wording defect: "no source files to check" describes an empty
+    // project. The honest message names the real cause and the action that fixes
+    // it.
+    const msg = gateRunner.describeEmptyChangedFiles('diff', 0);
+
+    expect(msg).toContain('no changed files');
+    expect(msg).toContain('--all');
+    // It must NOT claim the project has no sources.
+    expect(msg.toLowerCase()).not.toContain('no source files');
+  });
+
+  it('AC-608-02: under --all an empty list says the tree has no sources, not the diff', () => {
+    const msg = gateRunner.describeEmptyChangedFiles('all', 0);
+
+    expect(msg).toContain('tracked');
+    // `--all` already scanned everything, so pointing at `--all` again is useless.
+    expect(msg).not.toContain('run with `--all`');
+  });
+
+  it('AC-608-03: the resolved mode is reported so the scan scope is visible', () => {
+    // #589 point 1's second half: the user must be able to see which scope was
+    // used. A silent switch between diff and tree is the same defect one level up.
+    const fileCount = 3;
+    const allScope = gateRunner.describeChangedFilesScope('all', fileCount);
+    expect(allScope).toContain(String(fileCount));
+    expect(allScope.toLowerCase()).toContain('all');
+
+    const diffScope = gateRunner.describeChangedFilesScope('diff', 1);
+    expect(diffScope).toContain('1');
+    expect(diffScope).not.toContain('all');
+  });
+
+  it('AC-608-03: checkAllGates actually passes the all scope through to every gate', () => {
+    // The wire, not just the resolver. Every piece above can be correct while the
+    // scope never reaches the gates — which is exactly how the first attempt at
+    // this fix failed (an edit to check.js was reverted by a snapshot restore, and
+    // the resolver tests stayed green because none of them exercised the call).
+    const { checkAllGates } = require('../check.js');
+    const seen = [];
+    const saved = new Map();
+    for (const id of Object.keys(gateRunner.GATE_REGISTRY)) {
+      const gate = gateRunner.GATE_REGISTRY[id];
+      if (!gate.run) continue;
+      saved.set(id, gate.run);
+      gate.run = (_target, opts) => {
+        seen.push({ id, scope: opts && opts.scope });
+        return 0;
+      };
+    }
+    const log = console.log;
+    console.log = () => {};
+    return checkAllGates(undefined).then(() => {
+      console.log = log;
+      for (const [id, fn] of saved) gateRunner.GATE_REGISTRY[id].run = fn;
+
+      expect(seen.length).toBeGreaterThan(0);
+      const missing = seen.filter((s) => s.scope !== 'all').map((s) => s.id);
+      expect(missing, `these gates did not receive scope=all: ${missing.join(', ')}`).toEqual([]);
+    });
+  });
+});

package/lib/__tests__/issue-590-archlint-vacuous-pass.test.js

@@ -0,0 +1,138 @@
+/**
+ * @test REQ-616
+ * @intent Gate 6 reported a **vacuous pass** on a Java project:
+ *
+ *           architecture_grade: { density: "0.00", level: "Excellent", score: "10.0" }
+ *           files_analyzed: 1
+ *           total_smells: 0
+ *
+ *         The project had 140 `.java` files. archlint's detectors are built on an
+ *         import graph over a set of JS/TS extensions; `.java` is not among them, so it
+ *         analysed 1 file (probably a root `pom.xml`), found no smells in it, and the
+ *         grade arithmetic turned "no smells" into "10.0 / Excellent".
+ *
+ *         Every architecture problem Gate 6 exists to catch — cycles, god modules, dead
+ *         code, shotgun surgery — is undetectable on Java, and the report said the
+ *         architecture was excellent.
+ *
+ *         This is the same shape as #589 (Gate 3 permanently SKIP) and #594 (NaN
+ *         coverage as PASS): **"did not look" and "looked and found nothing" must be
+ *         distinguishable**, and the tool's own confidence must not be copied through
+ *         when the tool never looked.
+ *
+ *         `architecture.yaml` is also never consumed — that part is out of scope here (it
+ *         would be a new feature) and is documented as a gap instead of being silently
+ *         repaired.
+ * @covers AC-616-01, AC-616-02, AC-616-03
+ */
+
+const { __internals: arch } = require('../arch.js');
+
+// The reporter's project: 140 .java files, of which archlint analysed exactly one.
+const PROJECT_FILE_COUNT = 140;
+
+// A scan that genuinely covered its project.
+const COVERED_FILE_COUNT = 42;
+
+// A scan that covered its project and found one high-severity cycle.
+const CYCLE_FILE_COUNT = 30;
+
+describe('REQ-616: a scan that analysed nothing must not report 10.0/Excellent', () => {
+  /**
+   * A scan payload shaped like archlint's: a grade on a tree it barely looked at.
+   * `files_analyzed: 1` against a project with 140 `.java` files and no JS/TS.
+   */
+  function vacuousScanPayload() {
+    return JSON.stringify({
+      smells: [],
+      summary: {
+        files_analyzed: 1,
+        total_smells: 0,
+        architecture_grade: { density: '0.00', level: 'Excellent', score: '10.0' },
+      },
+    });
+  }
+
+  it('AC-616-01: a grade is withheld when the scan covered almost none of the project', () => {
+    // The context carries the project's real source-file count: without it there is
+    // nothing to compare against, and the case below pins that silence.
+    const verdict = arch.verdictFromScanJson(vacuousScanPayload(), { projectFileCount: PROJECT_FILE_COUNT });
+    // The parse itself succeeds -- the JSON is valid. What must not survive is the
+    // claim that the architecture is excellent.
+    expect(verdict.parseError).toBeNull();
+    expect(verdict.coverageGap, 'the coverage gap was not detected').toBeTruthy();
+    expect(verdict.summary, 'the false grade was copied through').toBeNull();
+  });
+
+  it('AC-616-01: with no project size known, the grade is left alone rather than guessed at', () => {
+    // The cheap wrong fix is to withhold every grade whose files_analyzed looks small.
+    // That would silently change what the tool reports for every caller that has not
+    // supplied a count -- and a gate that stops reporting results is worse than one
+    // that over-reports.
+    const verdict = arch.verdictFromScanJson(vacuousScanPayload());
+    expect(verdict.coverageGap).toBeFalsy();
+    expect(verdict.summary).toBeTruthy();
+  });
+
+  it('AC-616-01: a grade IS reported when the scan covered the project', () => {
+    // The control. Withholding every grade would make Gate 6 unable to report a real
+    // result, which is a worse failure than the bug: a gate that never has an opinion
+    // is a gate people delete.
+    const covered = JSON.stringify({
+      smells: [],
+      summary: {
+        files_analyzed: COVERED_FILE_COUNT,
+        total_smells: 0,
+        architecture_grade: { density: '0.00', level: 'Excellent', score: '10.0' },
+      },
+    });
+    const verdict = arch.verdictFromScanJson(covered, { projectFileCount: COVERED_FILE_COUNT });
+    expect(verdict.coverageGap).toBeFalsy();
+    expect(verdict.summary).toBeTruthy();
+    expect(verdict.summary.architecture_grade.score).toBe('10.0');
+  });
+
+  it('AC-616-02: the gap says which language was not analysed, not just that something is wrong', () => {
+    // #590's request 2: list the unsupported languages so the score change is
+    // traceable. "Something is off" is what the operator can already see.
+    const verdict = arch.verdictFromScanJson(vacuousScanPayload(), {
+      projectFileCount: PROJECT_FILE_COUNT,
+      dominantLanguage: 'java',
+    });
+    expect(verdict.coverageGap).toBeTruthy();
+    expect(String(verdict.coverageGap)).toContain('java');
+  });
+
+  it('AC-616-02: the withheld grade is explained, and the explanation names the numbers', () => {
+    const verdict = arch.verdictFromScanJson(vacuousScanPayload(), {
+      projectFileCount: PROJECT_FILE_COUNT,
+      dominantLanguage: 'java',
+    });
+    const text = String(verdict.coverageGap);
+    // The operator needs to see 1 versus 140 to believe it, not just "low coverage".
+    expect(text).toMatch(/1/);
+    expect(text).toContain(String(PROJECT_FILE_COUNT));
+  });
+
+  it('AC-616-03: a genuine grade on a JS/TS project is untouched', () => {
+    // archlint works on the languages it has detectors for; nothing here may change
+    // what it reports there. Verified by the shape the existing suite already covers.
+    const ts = JSON.stringify({
+      smells: [{ type: 'cycle', severity: 'high', files: ['a.ts', 'b.ts'] }],
+      summary: {
+        files_analyzed: CYCLE_FILE_COUNT,
+        total_smells: 1,
+        architecture_grade: { density: '0.03', level: 'Good', score: '7.5' },
+      },
+    });
+    const verdict = arch.verdictFromScanJson(ts, { projectFileCount: CYCLE_FILE_COUNT, dominantLanguage: 'typescript' });
+    expect(verdict.coverageGap).toBeFalsy();
+    expect(verdict.blocking).toBe(1);
+    expect(verdict.summary.architecture_grade.level).toBe('Good');
+  });
+
+  it('AC-616-03: an unparseable report still fails closed rather than becoming a grade question', () => {
+    const verdict = arch.verdictFromScanJson('not json at all');
+    expect(verdict.parseError).toBeTruthy();
+  });
+});

package/lib/__tests__/shared-paths-lazy-home.test.js

@@ -0,0 +1,67 @@
+/**
+ * @test REQ-2 xp-gate doctor
+ * @intent Prove that the path constants follow process.env.HOME even when
+ *         another module loaded shared-paths.js first (the doctor.test.js bug:
+ *         detect-deps.js is loaded in beforeAll, before any HOME is set, which
+ *         pinned CONFIG_FILE to the REAL home for the rest of the suite).
+ * @covers AC-05, AC-08, AC-10
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('shared-paths resolves the home directory lazily', () => {
+  let originalHome;
+  let tmpA;
+  let tmpB;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'sp-a-'));
+    tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'sp-b-'));
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    for (const d of [tmpA, tmpB]) {
+      if (d && fs.existsSync(d)) fs.rmSync(d, { recursive: true, force: true });
+    }
+    vi.resetModules();
+  });
+
+  function freshSharedPaths() {
+    const p = require.resolve('../shared-paths');
+    delete require.cache[p];
+    return require('../shared-paths');
+  }
+
+  it('CONFIG_FILE follows a HOME change made after the module was first loaded', () => {
+    process.env.HOME = tmpA;
+    const first = freshSharedPaths();
+    expect(first.CONFIG_FILE).toBe(path.join(tmpA, '.config', 'xp-gate', 'xp-gate.json'));
+
+    // A second "test" changes HOME — the same module object must now reflect it.
+    process.env.HOME = tmpB;
+    expect(first.CONFIG_FILE).toBe(
+      path.join(tmpB, '.config', 'xp-gate', 'xp-gate.json'),
+      'CONFIG_FILE still points at the HOME value captured at require() time'
+    );
+  });
+
+  it('HOME_DIR follows a HOME change made after the module was first loaded', () => {
+    process.env.HOME = tmpA;
+    const sp = freshSharedPaths();
+    expect(sp.HOME_DIR).toBe(tmpA);
+    process.env.HOME = tmpB;
+    expect(sp.HOME_DIR).toBe(tmpB, 'HOME_DIR is frozen at require() time');
+  });
+
+  it('a fresh require after a HOME change also reflects it (regression guard)', () => {
+    process.env.HOME = tmpA;
+    freshSharedPaths();
+    process.env.HOME = tmpB;
+    const sp = freshSharedPaths();
+    expect(sp.CONFIG_FILE).toBe(path.join(tmpB, '.config', 'xp-gate', 'xp-gate.json'));
+  });
+});