@lifeaitools/rdc-skills 0.34.1 → 0.35.0

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

@@ -0,0 +1,251 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  detectFactoryMethod, detectBuilder, detectSingleton, detectDecorator,
+  detectAdapter, detectFacade, detectStrategy, detectObserver,
+  detectCommand, detectTemplateMethod, patternScore, PATTERN_NAMES,
+} from '../../scripts/lib/pattern-scoring.mjs';
+import { makeMember, makeUnit } from './fixtures.mjs';
+
+// ── empty / trivial input ───────────────────────────────────────────────
+
+test('patternScore: zero members fires zero findings across all 10 detectors, never throws', () => {
+  const unit = makeUnit({ members: [] });
+  const r = patternScore(unit);
+  assert.equal(r.totalFindings, 0);
+  assert.equal(Object.keys(r.patterns).length, PATTERN_NAMES.length);
+  for (const p of Object.values(r.patterns)) assert.deepEqual(p.findings, []);
+});
+
+test('patternScore: a single trivial member with no signals fires nothing', () => {
+  const r = patternScore(makeUnit({ members: [makeMember()] }));
+  assert.equal(r.totalFindings, 0);
+});
+
+test('PATTERN_NAMES lists all 10 detected patterns', () => {
+  assert.equal(PATTERN_NAMES.length, 10);
+});
+
+// ── Factory Method — two independent signals ─────────────────────────────
+
+test('Factory Method (a): switch-on-type constructing via `new` fires', () => {
+  const unit = makeUnit({ members: [makeMember({ switchStatements: [{ line: 5, hasBehaviorCall: false, hasTypeCreation: true }] })] });
+  const r = detectFactoryMethod(unit);
+  assert.equal(r.findings.length, 1);
+  assert.equal(r.findings[0].confidence, 90);
+});
+
+test('Factory Method (b): >5 total news with >3 unique targets fires', () => {
+  const unit = makeUnit({ members: [makeMember({ constructorNewCallTargets: ['A', 'B', 'C', 'D', 'A', 'B'] })] }); // 6 total, 4 unique
+  const r = detectFactoryMethod(unit);
+  assert.equal(r.findings.length, 1);
+  assert.equal(r.findings[0].confidence, 75);
+});
+
+test('Factory Method: boundary — exactly 5 news does not fire (b)', () => {
+  const unit = makeUnit({ members: [makeMember({ constructorNewCallTargets: ['A', 'B', 'C', 'D', 'A'] })] }); // 5 total, 4 unique
+  assert.deepEqual(detectFactoryMethod(unit).findings, []);
+});
+
+test('Factory Method: boundary — 6 news but only 3 unique targets does not fire (b)', () => {
+  const unit = makeUnit({ members: [makeMember({ constructorNewCallTargets: ['A', 'A', 'B', 'B', 'C', 'C'] })] }); // 6 total, 3 unique
+  assert.deepEqual(detectFactoryMethod(unit).findings, []);
+});
+
+test('Factory Method: no type-switch and few/uniform news does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ switchStatements: [], constructorNewCallTargets: ['A'] })] });
+  assert.deepEqual(detectFactoryMethod(unit).findings, []);
+});
+
+// ── Builder — telescoping constructor (>4 params) ────────────────────────
+
+test('Builder: constructor with 5 params fires', () => {
+  const unit = makeUnit({ members: [makeMember({ name: 'constructor', paramCount: 5 })] });
+  assert.equal(detectBuilder(unit).findings.length, 1);
+});
+
+test('Builder: boundary — constructor with exactly 4 params does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ name: 'constructor', paramCount: 4 })] });
+  assert.deepEqual(detectBuilder(unit).findings, []);
+});
+
+test('Builder: a non-constructor member with 5 params does not fire (constructor-only rule)', () => {
+  const unit = makeUnit({ members: [makeMember({ name: 'setup', paramCount: 5 })] });
+  assert.deepEqual(detectBuilder(unit).findings, []);
+});
+
+// ── Singleton — static instance field OR getInstance ─────────────────────
+
+test('Singleton: hasGetInstanceMethod fires', () => {
+  const unit = makeUnit({ hasGetInstanceMethod: true });
+  assert.equal(detectSingleton(unit).findings.length, 1);
+});
+
+test('Singleton: a static property named "instance" (name match) fires', () => {
+  const unit = makeUnit({ staticPropertyNames: ['_instance'] });
+  assert.equal(detectSingleton(unit).findings.length, 1);
+});
+
+test('Singleton: a getInstance call-site fires', () => {
+  const unit = makeUnit({ members: [makeMember({ calleeNames: ['getInstance'] })] });
+  assert.equal(detectSingleton(unit).findings.length, 1);
+});
+
+test('Singleton: none of the three signals present does not fire', () => {
+  const unit = makeUnit({ hasGetInstanceMethod: false, staticPropertyNames: ['config'], members: [makeMember({ calleeNames: ['build'] })] });
+  assert.deepEqual(detectSingleton(unit).findings, []);
+});
+
+// ── Decorator — conditional feature-add call ──────────────────────────────
+
+test('Decorator: conditionalFeatureCallLine present fires', () => {
+  const unit = makeUnit({ members: [makeMember({ conditionalFeatureCallLine: 12 })] });
+  assert.equal(detectDecorator(unit).findings.length, 1);
+});
+
+test('Decorator: conditionalFeatureCallLine null does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ conditionalFeatureCallLine: null })] });
+  assert.deepEqual(detectDecorator(unit).findings, []);
+});
+
+// ── Adapter — name or call names an interface conversion ─────────────────
+
+test('Adapter: member name matches convert/transform/adapt fires', () => {
+  const unit = makeUnit({ members: [makeMember({ name: 'convertToDto' })] });
+  assert.equal(detectAdapter(unit).findings.length, 1);
+});
+
+test('Adapter: a call to a convert/transform/adapt-named function fires', () => {
+  const unit = makeUnit({ members: [makeMember({ name: 'run', calleeNames: ['transformPayload'] })] });
+  assert.equal(detectAdapter(unit).findings.length, 1);
+});
+
+test('Adapter: no matching name or call does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ name: 'run', calleeNames: ['persist'] })] });
+  assert.deepEqual(detectAdapter(unit).findings, []);
+});
+
+// ── Facade — >5 deep-chain calls ──────────────────────────────────────────
+
+test('Facade: deepChainCallCount=6 fires', () => {
+  const unit = makeUnit({ members: [makeMember({ deepChainCallCount: 6 })] });
+  assert.equal(detectFacade(unit).findings.length, 1);
+});
+
+test('Facade: boundary — deepChainCallCount exactly 5 does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ deepChainCallCount: 5 })] });
+  assert.deepEqual(detectFacade(unit).findings, []);
+});
+
+// ── Strategy — switch dispatching behavior ────────────────────────────────
+
+test('Strategy: switchBehaviorCallLine present fires', () => {
+  const unit = makeUnit({ members: [makeMember({ switchBehaviorCallLine: 9 })] });
+  assert.equal(detectStrategy(unit).findings.length, 1);
+});
+
+test('Strategy: switchBehaviorCallLine null does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ switchBehaviorCallLine: null })] });
+  assert.deepEqual(detectStrategy(unit).findings, []);
+});
+
+// ── Observer — >3 notify/update/inform/broadcast calls ────────────────────
+
+test('Observer: 4 matching callee names (aggregated across unit) fires', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', calleeNames: ['notifyAll', 'update'] }),
+      makeMember({ name: 'b', calleeNames: ['inform', 'broadcast'] }),
+    ],
+  });
+  assert.equal(detectObserver(unit).findings.length, 1);
+});
+
+test('Observer: boundary — exactly 3 matching calls does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ calleeNames: ['notify', 'update', 'inform'] })] });
+  assert.deepEqual(detectObserver(unit).findings, []);
+});
+
+// ── Command — >4 occurrences of undo/redo/history/queue/execute ──────────
+
+test('Command: >4 occurrences across name/callees/declaredNames/fieldAccess fires', () => {
+  const unit = makeUnit({
+    name: 'execute', // 1
+    members: [makeMember({
+      name: 'undo', // 2
+      calleeNames: ['redo'], // 3
+      declaredNames: [{ name: 'queue', line: 1 }], // 4
+      fieldAccess: ['history'], // 5
+    })],
+  });
+  const r = detectCommand(unit);
+  assert.equal(r.findings.length, 1);
+});
+
+test('Command: boundary — exactly 4 occurrences does not fire', () => {
+  const unit = makeUnit({
+    name: 'Widget',
+    members: [makeMember({
+      name: 'undo', // 1
+      calleeNames: ['redo'], // 2
+      declaredNames: [{ name: 'queue', line: 1 }], // 3
+      fieldAccess: ['history'], // 4
+    })],
+  });
+  assert.deepEqual(detectCommand(unit).findings, []);
+});
+
+test('Command: a bare fieldAccess-only reference (this.queue, never called/declared) still counts toward the total', () => {
+  const unit = makeUnit({
+    name: 'undo', // 1
+    members: [makeMember({
+      name: 'redo', // 2
+      calleeNames: ['execute'], // 3
+      fieldAccess: ['queue', 'history'], // 4, 5
+    })],
+  });
+  assert.equal(detectCommand(unit).findings.length, 1);
+});
+
+// ── Template Method — >2 members call initialize/process/cleanup ─────────
+
+test('Template Method: 3 members each calling an initialize/process/cleanup-named function fires', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', calleeNames: ['initializeStep'] }),
+      makeMember({ name: 'b', calleeNames: ['processStep'] }),
+      makeMember({ name: 'c', calleeNames: ['cleanupStep'] }),
+    ],
+  });
+  assert.equal(detectTemplateMethod(unit).findings.length, 1);
+});
+
+test('Template Method: boundary — exactly 2 matching members does not fire', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', calleeNames: ['initializeStep'] }),
+      makeMember({ name: 'b', calleeNames: ['processStep'] }),
+    ],
+  });
+  assert.deepEqual(detectTemplateMethod(unit).findings, []);
+});
+
+// ── patternScore — full aggregate, deterministic sort ─────────────────────
+
+test('patternScore: a unit tripping multiple detectors sums totalFindings correctly and sorts findings by line', () => {
+  const unit = makeUnit({
+    hasGetInstanceMethod: true, // Singleton
+    members: [
+      makeMember({ name: 'constructor', paramCount: 5 }), // Builder
+      makeMember({ name: 'a', switchStatements: [{ line: 20, hasBehaviorCall: false, hasTypeCreation: true }] }), // Factory Method
+      makeMember({ name: 'b', switchBehaviorCallLine: 10 }), // Strategy
+    ],
+  });
+  const r = patternScore(unit);
+  assert.equal(r.patterns['Singleton'].findings.length, 1);
+  assert.equal(r.patterns['Builder'].findings.length, 1);
+  assert.equal(r.patterns['Factory Method'].findings.length, 1);
+  assert.equal(r.patterns['Strategy'].findings.length, 1);
+  assert.equal(r.totalFindings, 4);
+});

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

@@ -0,0 +1,264 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  extractMethodOpportunities, extractClassOpportunities,
+  introduceParameterObjectOpportunities, replaceMagicNumberOpportunities,
+  consolidateDuplicateCodeOpportunities, decomposeConditionalOpportunities,
+  strategyTransformOpportunities, factoryTransformOpportunities,
+  nullObjectTransformOpportunities, estimateEffort, refactoringScore,
+} from '../../scripts/lib/refactoring-scoring.mjs';
+import { makeMember, makeUnit } from './fixtures.mjs';
+
+// ── empty / trivial input ───────────────────────────────────────────────
+
+test('refactoringScore: zero members fires zero findings for all 9 rules, never throws', () => {
+  const unit = makeUnit({ members: [] });
+  const r = refactoringScore(unit);
+  assert.equal(r.totalFindings, 0);
+  assert.equal(Object.keys(r.rules).length, 9);
+});
+
+test('refactoringScore: a single trivial member with no smells fires nothing', () => {
+  assert.equal(refactoringScore(makeUnit({ members: [makeMember()] })).totalFindings, 0);
+});
+
+// ── extract-method (statementCount > 25) ──────────────────────────────────
+
+test('extract-method: 26 statements fires', () => {
+  const unit = makeUnit({ members: [makeMember({ statementCount: 26 })] });
+  assert.equal(extractMethodOpportunities(unit).findings.length, 1);
+});
+
+test('extract-method: boundary — exactly 25 statements does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ statementCount: 25 })] });
+  assert.deepEqual(extractMethodOpportunities(unit).findings, []);
+});
+
+// ── extract-class (class with >15 members) ─────────────────────────────
+
+test('extract-class: a class with 16 members fires', () => {
+  const members = Array.from({ length: 16 }, (_, i) => makeMember({ name: `m${i}` }));
+  const unit = makeUnit({ kind: 'class', members });
+  assert.equal(extractClassOpportunities(unit).findings.length, 1);
+});
+
+test('extract-class: boundary — a class with exactly 15 members does not fire', () => {
+  const members = Array.from({ length: 15 }, (_, i) => makeMember({ name: `m${i}` }));
+  const unit = makeUnit({ kind: 'class', members });
+  assert.deepEqual(extractClassOpportunities(unit).findings, []);
+});
+
+test('extract-class: a MODULE with 16 top-level functions does not fire (class-only rule)', () => {
+  const members = Array.from({ length: 16 }, (_, i) => makeMember({ name: `m${i}` }));
+  const unit = makeUnit({ kind: 'module', members });
+  assert.deepEqual(extractClassOpportunities(unit).findings, []);
+});
+
+// ── introduce-parameter-object (paramCount > 4) ──────────────────────────
+
+test('introduce-parameter-object: 5 params fires', () => {
+  const unit = makeUnit({ members: [makeMember({ paramCount: 5 })] });
+  assert.equal(introduceParameterObjectOpportunities(unit).findings.length, 1);
+});
+
+test('introduce-parameter-object: boundary — exactly 4 params does not fire (differs from clean-code F2 at >3)', () => {
+  const unit = makeUnit({ members: [makeMember({ paramCount: 4 })] });
+  assert.deepEqual(introduceParameterObjectOpportunities(unit).findings, []);
+});
+
+// ── replace-magic-number (unit-wide count > 5) ────────────────────────────
+
+test('replace-magic-number: unit-wide total of 6 magic numbers fires, one finding per occurrence', () => {
+  const unit = makeUnit({
+    members: [makeMember({ magicNumbers: Array.from({ length: 6 }, (_, i) => ({ value: i + 10, line: i + 1 })) })],
+  });
+  const r = replaceMagicNumberOpportunities(unit);
+  assert.equal(r.findings.length, 6);
+});
+
+test('replace-magic-number: boundary — unit-wide total of exactly 5 does not fire', () => {
+  const unit = makeUnit({
+    members: [makeMember({ magicNumbers: Array.from({ length: 5 }, (_, i) => ({ value: i + 10, line: i + 1 })) })],
+  });
+  assert.deepEqual(replaceMagicNumberOpportunities(unit).findings, []);
+});
+
+test('replace-magic-number: aggregates ACROSS members, not per-member', () => {
+  const unit = makeUnit({
+    members: [
+      makeMember({ name: 'a', magicNumbers: [{ value: 1, line: 1 }, { value: 2, line: 2 }, { value: 3, line: 3 }] }),
+      makeMember({ name: 'b', magicNumbers: [{ value: 4, line: 4 }, { value: 5, line: 5 }, { value: 6, line: 6 }] }),
+    ],
+  });
+  assert.equal(replaceMagicNumberOpportunities(unit).findings.length, 6);
+});
+
+// ── consolidate-duplicate-code (>3 groups, each repeated >3x) ────────────
+
+function repeatedStatementText(text, count, memberName = 'm') {
+  return Array.from({ length: count }, (_, i) => ({ text, line: i + 1 }));
+}
+
+test('consolidate-duplicate-code: 4 distinct patterns each repeated 4x fires with 4 findings', () => {
+  const unit = makeUnit({
+    members: [makeMember({
+      statementTexts: [
+        ...repeatedStatementText('const a = doSomethingLong();', 4),
+        ...repeatedStatementText('const b = doAnotherThingLong();', 4),
+        ...repeatedStatementText('const c = doThirdThingLong();', 4),
+        ...repeatedStatementText('const d = doFourthThingLong();', 4),
+      ],
+    })],
+  });
+  const r = consolidateDuplicateCodeOpportunities(unit);
+  assert.equal(r.findings.length, 4);
+});
+
+test('consolidate-duplicate-code: boundary — exactly 3 distinct qualifying patterns does not fire', () => {
+  const unit = makeUnit({
+    members: [makeMember({
+      statementTexts: [
+        ...repeatedStatementText('const a = doSomethingLong();', 4),
+        ...repeatedStatementText('const b = doAnotherThingLong();', 4),
+        ...repeatedStatementText('const c = doThirdThingLong();', 4),
+      ],
+    })],
+  });
+  assert.deepEqual(consolidateDuplicateCodeOpportunities(unit).findings, []);
+});
+
+test('consolidate-duplicate-code: boundary — a pattern repeated exactly 3x (not >3) does not count toward a group', () => {
+  const unit = makeUnit({
+    members: [makeMember({
+      statementTexts: [
+        ...repeatedStatementText('const a = doSomethingLong();', 3),
+        ...repeatedStatementText('const b = doAnotherThingLong();', 4),
+        ...repeatedStatementText('const c = doThirdThingLong();', 4),
+        ...repeatedStatementText('const d = doFourthThingLong();', 4),
+      ],
+    })],
+  });
+  // only 3 groups actually qualify (>3 repeats) despite 4 distinct texts present
+  assert.deepEqual(consolidateDuplicateCodeOpportunities(unit).findings, []);
+});
+
+// ── decompose-conditional (>2 complex conditionals per unit) ─────────────
+
+test('decompose-conditional: 3 complex conditionals (unit-wide) fires', () => {
+  const unit = makeUnit({
+    members: [makeMember({ complexConditionals: [{ line: 1, length: 60 }, { line: 2, length: 70 }, { line: 3, length: 55 }] })],
+  });
+  assert.equal(decomposeConditionalOpportunities(unit).findings.length, 3);
+});
+
+test('decompose-conditional: boundary — exactly 2 complex conditionals does not fire', () => {
+  const unit = makeUnit({
+    members: [makeMember({ complexConditionals: [{ line: 1, length: 60 }, { line: 2, length: 70 }] })],
+  });
+  assert.deepEqual(decomposeConditionalOpportunities(unit).findings, []);
+});
+
+// ── strategy-transform (switch dispatching behavior) ──────────────────────
+
+test('strategy-transform: switchStatements.hasBehaviorCall fires', () => {
+  const unit = makeUnit({ members: [makeMember({ switchStatements: [{ line: 4, hasBehaviorCall: true, hasTypeCreation: false }] })] });
+  assert.equal(strategyTransformOpportunities(unit).findings.length, 1);
+});
+
+test('strategy-transform: hasBehaviorCall false does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ switchStatements: [{ line: 4, hasBehaviorCall: false, hasTypeCreation: false }] })] });
+  assert.deepEqual(strategyTransformOpportunities(unit).findings, []);
+});
+
+// ── factory-transform (switch on type creating objects) ──────────────────
+
+test('factory-transform: switchStatements.hasTypeCreation fires', () => {
+  const unit = makeUnit({ members: [makeMember({ switchStatements: [{ line: 4, hasBehaviorCall: false, hasTypeCreation: true }] })] });
+  assert.equal(factoryTransformOpportunities(unit).findings.length, 1);
+});
+
+test('factory-transform: hasTypeCreation false does not fire', () => {
+  const unit = makeUnit({ members: [makeMember({ switchStatements: [{ line: 4, hasBehaviorCall: false, hasTypeCreation: false }] })] });
+  assert.deepEqual(factoryTransformOpportunities(unit).findings, []);
+});
+
+// ── null-object-transform (>5 null checks per unit) ───────────────────────
+
+test('null-object-transform: 6 null checks (unit-wide) fires', () => {
+  const unit = makeUnit({
+    members: [makeMember({ nullChecks: Array.from({ length: 6 }, (_, i) => ({ line: i + 1 })) })],
+  });
+  assert.equal(nullObjectTransformOpportunities(unit).findings.length, 6);
+});
+
+test('null-object-transform: boundary — exactly 5 null checks does not fire', () => {
+  const unit = makeUnit({
+    members: [makeMember({ nullChecks: Array.from({ length: 5 }, (_, i) => ({ line: i + 1 })) })],
+  });
+  assert.deepEqual(nullObjectTransformOpportunities(unit).findings, []);
+});
+
+// ── estimateEffort — unmeasured, boundary, package-crossing ──────────────
+
+test('estimateEffort: no referenceSites is reported unmeasured, never as zero effort', () => {
+  const r = estimateEffort({ unitPackage: 'packages/core', referenceSites: null });
+  assert.equal(r.effort, null);
+  assert.equal(r.confidence, 'unmeasured');
+});
+
+test('estimateEffort: referenceCount -1 is unmeasured', () => {
+  const r = estimateEffort({ unitPackage: 'packages/core', referenceSites: { referenceCount: -1, files: [], kind: null } });
+  assert.equal(r.effort, null);
+});
+
+test('estimateEffort: a reference site outside the unit package is "high" via package-boundary crossing', () => {
+  const r = estimateEffort({
+    unitPackage: 'packages/core',
+    referenceSites: { referenceCount: 2, files: ['/repo/packages/other/consumer.mjs'], kind: 'FunctionDeclaration' },
+  });
+  assert.equal(r.effort, 'high');
+  assert.equal(r.criterion, 'crosses a package boundary');
+  assert.equal(r.invariantCheckRequired, true);
+});
+
+test('estimateEffort: boundary — 16 call sites, same package, is "high" via the >15 criterion', () => {
+  const files = Array.from({ length: 16 }, (_, i) => `/repo/packages/core/consumer${i}.mjs`);
+  const r = estimateEffort({ unitPackage: 'packages/core', referenceSites: { referenceCount: 16, files, kind: 'FunctionDeclaration' } });
+  assert.equal(r.effort, 'high');
+  assert.equal(r.criterion, '>15 call sites');
+});
+
+test('estimateEffort: boundary — exactly 15 call sites, same package, is "medium"', () => {
+  const files = Array.from({ length: 15 }, (_, i) => `/repo/packages/core/consumer${i}.mjs`);
+  const r = estimateEffort({ unitPackage: 'packages/core', referenceSites: { referenceCount: 15, files, kind: 'FunctionDeclaration' } });
+  assert.equal(r.effort, 'medium');
+});
+
+test('estimateEffort: boundary — exactly 4 call sites is "medium"', () => {
+  const files = Array.from({ length: 4 }, (_, i) => `/repo/packages/core/c${i}.mjs`);
+  const r = estimateEffort({ unitPackage: 'packages/core', referenceSites: { referenceCount: 4, files, kind: 'FunctionDeclaration' } });
+  assert.equal(r.effort, 'medium');
+});
+
+test('estimateEffort: boundary — exactly 3 call sites is "low"', () => {
+  const files = Array.from({ length: 3 }, (_, i) => `/repo/packages/core/c${i}.mjs`);
+  const r = estimateEffort({ unitPackage: 'packages/core', referenceSites: { referenceCount: 3, files, kind: 'FunctionDeclaration' } });
+  assert.equal(r.effort, 'low');
+});
+
+// ── refactoringScore — full aggregate ──────────────────────────────────
+
+test('refactoringScore: a unit tripping several rules sums totalFindings correctly', () => {
+  const unit = makeUnit({
+    kind: 'class',
+    members: [
+      makeMember({ name: 'longMethod', statementCount: 30 }),
+      makeMember({ name: 'manyParams', paramCount: 6 }),
+    ],
+  });
+  const r = refactoringScore(unit);
+  assert.equal(r.rules['extract-method'].findings.length, 1);
+  assert.equal(r.rules['introduce-parameter-object'].findings.length, 1);
+  assert.equal(r.totalFindings, 2);
+});