@lifeaitools/rdc-skills 0.34.0 → 0.35.0

package/tests/lib/solid-scoring.test.mjs

@@ -0,0 +1,291 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { srp, ocp, lsp, isp, dip, scoreUnit } from '../../scripts/lib/solid-scoring.mjs';
+import { makeMember, makeUnit } from './fixtures.mjs';
+
+// ── empty / trivial input ───────────────────────────────────────────────
+
+test('srp: zero members returns unmeasured, not a fake clean 100', () => {
+  const r = srp(makeUnit({ members: [] }));
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'none');
+});
+
+test('ocp: zero members returns unmeasured', () => {
+  const r = ocp(makeUnit({ members: [] }));
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'none');
+});
+
+test('isp: zero members returns unmeasured', () => {
+  const r = isp(makeUnit({ members: [] }));
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'none');
+});
+
+test('lsp: no base class scores 100 at low-medium confidence (nothing to violate)', () => {
+  const r = lsp(makeUnit({ hasBaseClass: false }));
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'low-medium');
+  assert.match(r.detail, /no base class/);
+});
+
+test('dip: zero total dependencies scores 100 (nothing to be concrete about)', () => {
+  const r = dip(makeUnit({ totalDependencies: 0 }));
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'high');
+});
+
+test('srp: exactly one member scores 100 at high confidence', () => {
+  const r = srp(makeUnit({ members: [makeMember()] }));
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'high');
+});
+
+// ── SRP — connected components ──────────────────────────────────────────
+
+test('srp: two members with no shared field and no cross-calls are 2 components — score 70', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', fieldAccess: ['x'] }),
+      makeMember({ name: 'b', fieldAccess: ['y'] }),
+    ],
+  });
+  const r = srp(unit);
+  assert.match(r.detail, /2 connected component/);
+  assert.equal(r.score, 70);
+});
+
+test('srp: two members sharing a field collapse to 1 component — score 100 (clean)', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', fieldAccess: ['shared'] }),
+      makeMember({ name: 'b', fieldAccess: ['shared'] }),
+    ],
+  });
+  const r = srp(unit);
+  assert.match(r.detail, /1 connected component/);
+  assert.equal(r.score, 100);
+});
+
+test('srp: two members where one calls the other also collapse to 1 component', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', calls: ['b'] }),
+      makeMember({ name: 'b' }),
+    ],
+  });
+  const r = srp(unit);
+  assert.equal(r.score, 100);
+});
+
+test('srp: three fully isolated members are 3 components — score 40', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', fieldAccess: ['x'] }),
+      makeMember({ name: 'b', fieldAccess: ['y'] }),
+      makeMember({ name: 'c', fieldAccess: ['z'] }),
+    ],
+  });
+  assert.equal(srp(unit).score, 40);
+});
+
+test('srp: four or more fully isolated members floor at score 10', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', fieldAccess: ['w'] }),
+      makeMember({ name: 'b', fieldAccess: ['x'] }),
+      makeMember({ name: 'c', fieldAccess: ['y'] }),
+      makeMember({ name: 'd', fieldAccess: ['z'] }),
+    ],
+  });
+  assert.equal(srp(unit).score, 10);
+});
+
+// ── OCP — branch-hit density ────────────────────────────────────────────
+
+test('ocp: known violation — high branch-hit density scores near/at 0', () => {
+  const unit = makeUnit({ members: [makeMember({ branchHits: 8 })] });
+  const r = ocp(unit);
+  assert.equal(r.score, 0);
+  assert.equal(r.confidence, 'low');
+});
+
+test('ocp: known-clean — zero branch hits scores 100', () => {
+  const unit = makeUnit({ members: [makeMember({ branchHits: 0 })] });
+  assert.equal(ocp(unit).score, 100);
+});
+
+test('ocp: density formula boundary — density=4 clips exactly to score 0', () => {
+  const unit = makeUnit({ members: [makeMember({ branchHits: 4 })] });
+  assert.equal(ocp(unit).score, 0);
+});
+
+test('ocp: density formula just below the clip — density=3 scores 25', () => {
+  const unit = makeUnit({ members: [makeMember({ branchHits: 3 })] });
+  assert.equal(ocp(unit).score, 25);
+});
+
+// ── LSP — override drift ────────────────────────────────────────────────
+
+test('lsp: hasBaseClass true but no overridden members scores 100', () => {
+  const unit = makeUnit({ hasBaseClass: true, members: [makeMember({ override: null })] });
+  const r = lsp(unit);
+  assert.equal(r.score, 100);
+  assert.match(r.detail, /no overridden methods/);
+});
+
+test('lsp: known violation — full drift (param mismatch, no super call, return-type mismatch) scores 0', () => {
+  const unit = makeUnit({
+    hasBaseClass: true,
+    members: [makeMember({
+      paramCount: 3,
+      override: { baseParamCount: 2, callsSuper: false, returnType: 'string', baseReturnType: 'number' },
+    })],
+  });
+  assert.equal(lsp(unit).score, 0);
+});
+
+test('lsp: known-clean — override matches base exactly scores 100', () => {
+  const unit = makeUnit({
+    hasBaseClass: true,
+    members: [makeMember({
+      paramCount: 2,
+      override: { baseParamCount: 2, callsSuper: true, returnType: 'number', baseReturnType: 'number' },
+    })],
+  });
+  assert.equal(lsp(unit).score, 100);
+});
+
+test('lsp: boundary — exactly one of three drift signals scores 67', () => {
+  const unit = makeUnit({
+    hasBaseClass: true,
+    members: [makeMember({
+      paramCount: 2, // matches base -> no drift here
+      override: { baseParamCount: 2, callsSuper: false, returnType: 'number', baseReturnType: 'number' },
+    })],
+  });
+  assert.equal(lsp(unit).score, 67);
+});
+
+test('lsp: boundary — exactly two of three drift signals scores 33', () => {
+  const unit = makeUnit({
+    hasBaseClass: true,
+    members: [makeMember({
+      paramCount: 3, // mismatch -> drift
+      override: { baseParamCount: 2, callsSuper: false, returnType: 'number', baseReturnType: 'number' },
+    })],
+  });
+  assert.equal(lsp(unit).score, 33);
+});
+
+// ── ISP — public member count + avg params ──────────────────────────────
+
+test('isp: known-clean — no public members scores 100 at medium-high confidence', () => {
+  const unit = makeUnit({ members: [makeMember({ isPublic: false })] });
+  const r = isp(unit);
+  assert.equal(r.score, 100);
+  assert.equal(r.confidence, 'medium-high');
+});
+
+test('isp: known violation — many public members with high avg params scores low', () => {
+  const members = Array.from({ length: 21 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 5 }));
+  const r = isp(makeUnit({ members }));
+  assert.equal(r.score, 28); // countScore 15 (len>20), paramScore 40 (avg5>4) -> round((15+40)/2)
+});
+
+test('isp: boundary — publicMembers.length=5 (<=5) scores countScore 100', () => {
+  const members = Array.from({ length: 5 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 0 }));
+  assert.equal(isp(makeUnit({ members })).score, 100);
+});
+
+test('isp: boundary — publicMembers.length=6 (>5) drops countScore to 75', () => {
+  const members = Array.from({ length: 6 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 0 }));
+  assert.equal(isp(makeUnit({ members })).score, 88); // round((75+100)/2)
+});
+
+test('isp: boundary — publicMembers.length=10 (<=10) still countScore 75', () => {
+  const members = Array.from({ length: 10 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 0 }));
+  assert.equal(isp(makeUnit({ members })).score, 88);
+});
+
+test('isp: boundary — publicMembers.length=11 (>10) drops countScore to 45', () => {
+  const members = Array.from({ length: 11 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 0 }));
+  assert.equal(isp(makeUnit({ members })).score, 73); // round((45+100)/2)
+});
+
+test('isp: boundary — publicMembers.length=20 (<=20) still countScore 45', () => {
+  const members = Array.from({ length: 20 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 0 }));
+  assert.equal(isp(makeUnit({ members })).score, 73);
+});
+
+test('isp: boundary — publicMembers.length=21 (>20) drops countScore to 15', () => {
+  const members = Array.from({ length: 21 }, (_, i) => makeMember({ name: `m${i}`, paramCount: 0 }));
+  assert.equal(isp(makeUnit({ members })).score, 58); // round((15+100)/2)
+});
+
+test('isp: boundary — avgParams=2 (<=2) scores paramScore 100', () => {
+  const unit = makeUnit({ members: [makeMember({ paramCount: 2 })] });
+  assert.equal(isp(unit).score, 100); // countScore 100, paramScore 100
+});
+
+test('isp: boundary — avgParams=3 (>2) drops paramScore to 75', () => {
+  const unit = makeUnit({ members: [makeMember({ paramCount: 3 })] });
+  assert.equal(isp(unit).score, 88); // round((100+75)/2)
+});
+
+test('isp: boundary — avgParams=4 (<=4) still paramScore 75', () => {
+  const unit = makeUnit({ members: [makeMember({ paramCount: 4 })] });
+  assert.equal(isp(unit).score, 88);
+});
+
+test('isp: boundary — avgParams=5 (>4) drops paramScore to 40', () => {
+  const unit = makeUnit({ members: [makeMember({ paramCount: 5 })] });
+  assert.equal(isp(unit).score, 70); // round((100+40)/2)
+});
+
+// ── DIP — concrete-instantiation ratio ──────────────────────────────────
+
+test('dip: known violation — every dependency is a concrete instantiation scores 0', () => {
+  const unit = makeUnit({ concreteInstantiations: 5, totalDependencies: 5 });
+  assert.equal(dip(unit).score, 0);
+});
+
+test('dip: known-clean — zero concrete instantiations of nonzero deps scores 100', () => {
+  const unit = makeUnit({ concreteInstantiations: 0, totalDependencies: 5 });
+  assert.equal(dip(unit).score, 100);
+});
+
+test('dip: boundary — half the dependencies concrete scores exactly 50', () => {
+  const unit = makeUnit({ concreteInstantiations: 1, totalDependencies: 2 });
+  assert.equal(dip(unit).score, 50);
+});
+
+// ── scoreUnit — weighted aggregate + unmeasured exclusion ──────────────
+
+test('scoreUnit: unmeasured criteria (confidence "none") are excluded and renormalized, not zeroed', () => {
+  const unit = makeUnit({ members: [] }); // srp/ocp/isp all 'none' on empty unit
+  const r = scoreUnit(unit, { srp: 1, ocp: 1, lsp: 1, isp: 1, dip: 1 });
+  assert.deepEqual(new Set(r.unmeasured), new Set(['srp', 'ocp', 'isp']));
+  assert.equal(r.total, 100); // only lsp(100) + dip(100) measured
+});
+
+test('scoreUnit: total is null, not 0, when every weighted criterion is unmeasured', () => {
+  const unit = makeUnit({ members: [] });
+  const r = scoreUnit(unit, { srp: 1, ocp: 1, isp: 1 }); // omit lsp/dip, the only always-measured ones
+  assert.equal(r.total, null);
+  assert.deepEqual(new Set(r.unmeasured), new Set(['srp', 'ocp', 'isp']));
+});
+
+test('scoreUnit: a populated unit produces a real weighted average across all five criteria', () => {
+  const unit = makeUnit({
+    hasBaseClass: false,
+    concreteInstantiations: 0,
+    totalDependencies: 1,
+    members: [makeMember({ branchHits: 0, paramCount: 1 })],
+  });
+  const r = scoreUnit(unit, { srp: 1, ocp: 1, lsp: 1, isp: 1, dip: 1 });
+  assert.deepEqual(r.unmeasured, []);
+  assert.equal(r.total, 100); // single member, everything clean
+});

package/tests/lib/test-smell-scoring.test.mjs

@@ -0,0 +1,281 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  findTestBlocks, findSetupBlocks, checkInsufficientTests, checkIgnoredTests,
+  checkExhaustiveTesting, checkLongTests, checkSlowTests, checkFragileTests,
+  checkDuplicatedSetupAcrossFiles, checkIndependentSharedState,
+  countExportedUnits, guessSourceFilePath, scoreTestFile,
+} from '../../scripts/lib/test-smell-scoring.mjs';
+import { makeMember, makeUnit } from './fixtures.mjs';
+
+// ── empty / trivial input ───────────────────────────────────────────────
+
+test('scoreTestFile: empty text produces zero test blocks and zero findings, never throws', () => {
+  const r = scoreTestFile('');
+  assert.equal(r.testBlockCount, 0);
+  assert.deepEqual(r.findings, []);
+});
+
+test('scoreTestFile: a single-line file with no test() calls produces zero findings', () => {
+  const r = scoreTestFile('const x = 1;');
+  assert.equal(r.testBlockCount, 0);
+  assert.deepEqual(r.findings, []);
+});
+
+test('findTestBlocks: a minimal single passing test is found with correct title/kind', () => {
+  const blocks = findTestBlocks(`test('does a thing', () => { assert.ok(true); });`);
+  assert.equal(blocks.length, 1);
+  assert.equal(blocks[0].kind, 'test');
+  assert.equal(blocks[0].title, 'does a thing');
+  assert.equal(blocks[0].skipped, false);
+});
+
+// ── T1 — Insufficient Tests ────────────────────────────────────────────
+
+test('T1: fewer test() blocks than exported units fires', () => {
+  const blocks = findTestBlocks(`test('a', () => {});`);
+  const r = checkInsufficientTests(blocks, 3);
+  assert.ok(r);
+  assert.equal(r.ruleId, 'T1');
+});
+
+test('T1: exportedUnitCount null is unmeasured, returns null (not a finding, not silence-as-clean)', () => {
+  const blocks = findTestBlocks(`test('a', () => {});`);
+  assert.equal(checkInsufficientTests(blocks, null), null);
+});
+
+test('T1: exportedUnitCount 0 (nothing exported) does not fire', () => {
+  const blocks = findTestBlocks(`test('a', () => {});`);
+  assert.equal(checkInsufficientTests(blocks, 0), null);
+});
+
+test('T1: boundary — test count equal to exported count does not fire', () => {
+  const blocks = findTestBlocks(`test('a', () => {}); test('b', () => {});`);
+  assert.equal(checkInsufficientTests(blocks, 2), null);
+});
+
+test('T1: boundary — one fewer test than exported count fires', () => {
+  const blocks = findTestBlocks(`test('a', () => {}); test('b', () => {});`);
+  assert.ok(checkInsufficientTests(blocks, 3));
+});
+
+test('countExportedUnits: sums isPublic members across units, null for empty/absent', () => {
+  assert.equal(countExportedUnits([]), null);
+  assert.equal(countExportedUnits(null), null);
+  const units = [makeUnit({ members: [makeMember({ isPublic: true }), makeMember({ isPublic: false })] })];
+  assert.equal(countExportedUnits(units), 1);
+});
+
+test('guessSourceFilePath: maps a .test.mjs path back to its source path', () => {
+  assert.equal(guessSourceFilePath('foo.test.mjs'), 'foo.mjs');
+  // the test-dir swap only fires when the segment is bracketed by separators
+  // on both sides (`/test/`), not merely a leading path segment
+  assert.equal(guessSourceFilePath('project/test/x.test.ts'), 'project/src/x.ts');
+});
+
+// ── T2 — Ignored Tests ─────────────────────────────────────────────────
+
+test('T2: it.skip fires', () => {
+  const text = `it.skip('broken', () => {});`;
+  const blocks = findTestBlocks(text);
+  const findings = checkIgnoredTests(text, blocks);
+  assert.equal(findings.length, 1);
+  assert.equal(findings[0].ruleId, 'T2');
+});
+
+test('T2: test.skip fires', () => {
+  const text = `test.skip('broken', () => {});`;
+  const blocks = findTestBlocks(text);
+  assert.equal(checkIgnoredTests(text, blocks).length, 1);
+});
+
+test('T2: xdescribe fires (whole-suite disable)', () => {
+  const text = `xdescribe('a suite', () => {});`;
+  assert.equal(checkIgnoredTests(text, []).length, 1);
+});
+
+test('T2: an un-skipped test does not fire', () => {
+  const text = `it('works', () => { assert.ok(true); });`;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkIgnoredTests(text, blocks), []);
+});
+
+// ── T5 — Exhaustive Testing (>10 assertion calls per block) ──────────────
+
+test('T5: 11 assertion calls in one test fires', () => {
+  const asserts = Array.from({ length: 11 }, (_, i) => `expect(${i}).toBe(${i});`).join('\n');
+  const text = `test('exhaustive', () => {\n${asserts}\n});`;
+  const blocks = findTestBlocks(text);
+  assert.equal(checkExhaustiveTesting(blocks).length, 1);
+});
+
+test('T5: boundary — exactly 10 assertion calls does not fire', () => {
+  const asserts = Array.from({ length: 10 }, (_, i) => `expect(${i}).toBe(${i});`).join('\n');
+  const text = `test('ok', () => {\n${asserts}\n});`;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkExhaustiveTesting(blocks), []);
+});
+
+test('T5: an expression-bodied test (no block, body: null) is not measured, not flagged', () => {
+  const text = `it('x', () => expect(f()).toBe(1));`;
+  const blocks = findTestBlocks(text);
+  assert.equal(blocks[0].body, null);
+  assert.deepEqual(checkExhaustiveTesting(blocks), []);
+});
+
+// ── T6 — Long Tests (>30 lines) ────────────────────────────────────────
+
+test('T6: boundary — 29 content lines produces exactly 31 total lines and fires', () => {
+  const body = Array.from({ length: 29 }, (_, i) => `line${i}();`).join('\n');
+  const text = `test('long', () => {\n${body}\n});`;
+  const blocks = findTestBlocks(text);
+  assert.equal(blocks[0].body.text.split('\n').length, 31);
+  assert.equal(checkLongTests(blocks).length, 1);
+});
+
+test('T6: boundary — exactly 30 lines does not fire', () => {
+  // extractCallbackBody's body.text spans from just after the opening '{' to
+  // just before the closing '}', i.e. `\n<content>\n` — splitting on '\n'
+  // yields 2 extra (empty) lines beyond the content lines, so 28 content
+  // lines here produces exactly 30 total lines, the documented threshold.
+  const body = Array.from({ length: 28 }, (_, i) => `line${i}();`).join('\n');
+  const text = `test('ok', () => {\n${body}\n});`;
+  const blocks = findTestBlocks(text);
+  assert.equal(blocks[0].body.text.split('\n').length, 30);
+  assert.deepEqual(checkLongTests(blocks), []);
+});
+
+// ── T7 — Slow Tests (literal timer calls) ─────────────────────────────
+
+test('T7: a literal setTimeout inside a test fires', () => {
+  const text = `test('slow', () => { setTimeout(() => {}, 100); });`;
+  const blocks = findTestBlocks(text);
+  const findings = checkSlowTests(blocks);
+  assert.equal(findings.length, 1);
+  assert.equal(findings[0].ruleId, 'T7');
+});
+
+test('T7: sleep()/delay() calls also fire', () => {
+  const text = `test('slow', () => { sleep(10); });`;
+  const blocks = findTestBlocks(text);
+  assert.equal(checkSlowTests(blocks).length, 1);
+});
+
+test('T7: a test with no timer calls does not fire', () => {
+  const text = `test('fast', () => { assert.ok(true); });`;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkSlowTests(blocks), []);
+});
+
+// ── T8 — Fragile Tests (non-deterministic references) ─────────────────
+
+test('T8: Date.now() fires', () => {
+  const text = `test('fragile', () => { const t = Date.now(); assert.ok(t); });`;
+  const blocks = findTestBlocks(text);
+  assert.equal(checkFragileTests(blocks).length, 1);
+});
+
+test('T8: Math.random() fires', () => {
+  const text = `test('fragile', () => { const r = Math.random(); assert.ok(r); });`;
+  const blocks = findTestBlocks(text);
+  assert.equal(checkFragileTests(blocks).length, 1);
+});
+
+test('T8: process.env.* fires', () => {
+  const text = `test('fragile', () => { assert.ok(process.env.FOO); });`;
+  const blocks = findTestBlocks(text);
+  assert.equal(checkFragileTests(blocks).length, 1);
+});
+
+test('T8: a deterministic test (fixed clock injected) does not fire', () => {
+  const text = `test('deterministic', () => { const t = fixedClock.now(); assert.ok(t); });`;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkFragileTests(blocks), []);
+});
+
+// ── T9 — Duplicated Setup (cross-file, structural similarity) ────────────
+
+test('T9: two near-identical beforeEach blocks in DIFFERENT files fire above the similarity threshold', () => {
+  const setupA = `beforeEach(() => { const harness = new Harness('/tmp/a'); harness.start(); harness.seed(42); });`;
+  const setupB = `beforeEach(() => { const harness = new Harness('/tmp/b'); harness.start(); harness.seed(99); });`;
+  const files = [
+    { file: 'a.test.mjs', setupBlocks: findSetupBlocks(setupA) },
+    { file: 'b.test.mjs', setupBlocks: findSetupBlocks(setupB) },
+  ];
+  const findings = checkDuplicatedSetupAcrossFiles(files);
+  assert.equal(findings.length, 1);
+  assert.equal(findings[0].ruleId, 'T9');
+});
+
+test('T9: identical setup blocks in the SAME file do not fire (T9 is cross-file only)', () => {
+  const text = `
+    beforeEach(() => { const harness = new Harness('/tmp/a'); harness.start(); harness.seed(1); });
+    beforeEach(() => { const harness = new Harness('/tmp/a'); harness.start(); harness.seed(1); });
+  `;
+  const files = [{ file: 'a.test.mjs', setupBlocks: findSetupBlocks(text) }];
+  assert.deepEqual(checkDuplicatedSetupAcrossFiles(files), []);
+});
+
+test('T9: structurally unrelated setup blocks across files do not fire', () => {
+  const files = [
+    { file: 'a.test.mjs', setupBlocks: findSetupBlocks(`beforeEach(() => { db.connect(); db.migrate(); db.seedUsers(); });`) },
+    { file: 'b.test.mjs', setupBlocks: findSetupBlocks(`beforeEach(() => { server.listen(); server.mockAuth(); server.warmCache(); });`) },
+  ];
+  assert.deepEqual(checkDuplicatedSetupAcrossFiles(files), []);
+});
+
+// ── FIRST-Independent — mutated shared top-level state ────────────────
+
+test('FIRST-Independent: a top-level let mutated inside 2+ test() blocks fires', () => {
+  const text = `
+    let counter;
+    test('a', () => { counter = 1; });
+    test('b', () => { counter = 2; });
+  `;
+  const blocks = findTestBlocks(text);
+  const findings = checkIndependentSharedState(text, blocks);
+  assert.equal(findings.length, 1);
+  assert.equal(findings[0].ruleId, 'FIRST-Independent');
+});
+
+test('FIRST-Independent: a top-level let read (never mutated) by multiple tests does not fire', () => {
+  const text = `
+    let config = { a: 1 };
+    test('a', () => { assert.ok(config.a); });
+    test('b', () => { assert.ok(config.a); });
+  `;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkIndependentSharedState(text, blocks), []);
+});
+
+test('FIRST-Independent: a let mutated inside only ONE test does not fire', () => {
+  const text = `
+    let counter;
+    test('a', () => { counter = 1; });
+  `;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkIndependentSharedState(text, blocks), []);
+});
+
+test('FIRST-Independent: a let declared and mutated entirely INSIDE a single test is local, not shared state', () => {
+  const text = `
+    test('a', () => { let counter = 1; counter = 2; });
+  `;
+  const blocks = findTestBlocks(text);
+  assert.deepEqual(checkIndependentSharedState(text, blocks), []);
+});
+
+// ── scoreTestFile — full per-file aggregate ────────────────────────────
+
+test('scoreTestFile: a file tripping several single-file smells sums findings correctly', () => {
+  const text = `
+    it.skip('broken', () => {});
+    test('fragile', () => { const t = Date.now(); assert.ok(t); });
+  `;
+  const r = scoreTestFile(text, { exportedUnitCount: null });
+  assert.equal(r.testBlockCount, 2);
+  assert.equal(r.skippedCount, 1);
+  const ruleIds = r.findings.map((f) => f.ruleId).sort();
+  assert.deepEqual(ruleIds, ['T2', 'T8']);
+});