fcis 0.1.0

package/tests/quality-scorer.test.ts

@@ -0,0 +1,650 @@
+/**
+ * Quality Scorer Tests
+ *
+ * Tests for the pure core quality scoring logic.
+ * These tests verify that quality scores are correctly computed
+ * for impure functions based on their structural patterns.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import {
+  computeQualityScore,
+  analyzeFunction,
+  QUALITY_WEIGHTS,
+} from '../src/classification/quality-scorer.js'
+import type {
+  ExtractedFunction,
+  ImpurityMarker,
+  DetectionContext,
+  FileImports,
+} from '../src/types.js'
+import { createDetectionContext } from '../src/detection/detect-markers.js'
+
+/**
+ * Helper to create a minimal extracted function for testing
+ */
+function createTestFunction(
+  overrides: Partial<ExtractedFunction> = {},
+): ExtractedFunction {
+  return {
+    name: 'testFunction',
+    filePath: '/test/file.ts',
+    startLine: 1,
+    endLine: 10,
+    isAsync: true,
+    isExported: false,
+    bodyLineCount: 10,
+    statementCount: 5,
+    hasConditionals: false,
+    parentContext: null,
+    callSites: [],
+    hasAwait: true,
+    propertyAccessChains: [],
+    kind: 'function',
+    ...overrides,
+  }
+}
+
+/**
+ * Helper to create a minimal detection context
+ */
+function createTestContext(
+  imports: FileImports['imports'] = [],
+  pureImports: string[] = [],
+): DetectionContext {
+  const fileImports: FileImports = {
+    filePath: '/test/file.ts',
+    imports,
+  }
+  const context = createDetectionContext(fileImports)
+
+  // Add pure file imports
+  for (const pureImport of pureImports) {
+    context.pureFileImports.add(pureImport)
+  }
+
+  return context
+}
+
+/**
+ * Helper to create markers
+ */
+function createMarkers(
+  types: Array<{ type: ImpurityMarker['type']; line?: number }>,
+): ImpurityMarker[] {
+  return types.map(({ type, line }) => ({
+    type,
+    detail: `test ${type}`,
+    line,
+  }))
+}
+
+describe('computeQualityScore', () => {
+  describe('baseline scoring', () => {
+    it('should return a score between 0 and 100', () => {
+      const fn = createTestFunction()
+      const markers = createMarkers([{ type: 'await-expression', line: 5 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeGreaterThanOrEqual(0)
+      expect(score).toBeLessThanOrEqual(100)
+    })
+
+    it('should start with neutral score of 50', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 20,
+        statementCount: 10,
+        callSites: [],
+      })
+      const markers = createMarkers([{ type: 'await-expression', line: 10 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Base score is 50, with various adjustments
+      // Without any positive signals, it should get penalties
+      expect(score).toBeLessThanOrEqual(50)
+    })
+  })
+
+  describe('positive signals', () => {
+    it('should give high score for calling .pure file imports', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'planAcceptInvite', line: 5, isAwaited: false },
+          { expression: 'db.user.findFirst', line: 2, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 2 },
+        { type: 'await-expression', line: 2 },
+      ])
+      const context = createTestContext(
+        [
+          {
+            moduleSpecifier: './organizations.pure',
+            namedImports: ['planAcceptInvite'],
+          },
+        ],
+        ['./organizations.pure'],
+      )
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get +30 for calling pure file
+      expect(score).toBeGreaterThanOrEqual(70)
+    })
+
+    it('should reward calling functions with pure naming conventions', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'deriveSettings', line: 3, isAwaited: false },
+          { expression: 'computeTotal', line: 4, isAwaited: false },
+          { expression: 'db.user.update', line: 6, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 6 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get +20 for pure naming conventions
+      expect(score).toBeGreaterThanOrEqual(60)
+    })
+
+    it('should reward calling predicate functions', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'isValid', line: 2, isAwaited: false },
+          { expression: 'hasPermission', line: 3, isAwaited: false },
+          { expression: 'shouldProcess', line: 4, isAwaited: false },
+          { expression: 'db.user.update', line: 6, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 6 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get +5 for predicate functions
+      expect(score).toBeGreaterThanOrEqual(50)
+    })
+
+    it('should reward shell naming conventions', () => {
+      const fn = createTestFunction({
+        name: 'handleUserUpdate',
+        callSites: [{ expression: 'db.user.update', line: 5, isAwaited: true }],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 5 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get +5 for shell naming
+      expect(score).toBeGreaterThanOrEqual(40)
+    })
+
+    it('should reward I/O concentrated at start (GATHER pattern)', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 30,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 2, isAwaited: true },
+          { expression: 'db.posts.findMany', line: 3, isAwaited: true },
+          { expression: 'transform', line: 15, isAwaited: false },
+          { expression: 'validate', line: 20, isAwaited: false },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 2 },
+        { type: 'database-call', line: 3 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get bonus for GATHER pattern
+      expect(score).toBeGreaterThanOrEqual(55)
+    })
+
+    it('should reward I/O concentrated at end (EXECUTE pattern)', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 30,
+        callSites: [
+          { expression: 'computeResult', line: 5, isAwaited: false },
+          { expression: 'validateInput', line: 10, isAwaited: false },
+          { expression: 'db.user.update', line: 25, isAwaited: true },
+          { expression: 'db.audit.create', line: 28, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 25 },
+        { type: 'database-call', line: 28 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get bonus for EXECUTE pattern
+      expect(score).toBeGreaterThanOrEqual(55)
+    })
+
+    it('should reward low complexity functions', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 10,
+        statementCount: 3,
+        hasConditionals: false,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 5, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 5 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get +10 for low complexity
+      expect(score).toBeGreaterThanOrEqual(50)
+    })
+  })
+
+  describe('negative signals (penalties)', () => {
+    it('should penalize interleaved I/O', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 30,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 3, isAwaited: true },
+          { expression: 'transform', line: 8, isAwaited: false },
+          { expression: 'db.posts.create', line: 12, isAwaited: true },
+          { expression: 'validate', line: 18, isAwaited: false },
+          { expression: 'db.audit.create', line: 25, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 3 },
+        { type: 'database-call', line: 12 },
+        { type: 'database-call', line: 25 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get -20 for interleaved I/O
+      expect(score).toBeLessThanOrEqual(50)
+    })
+
+    it('should penalize high complexity functions', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 150,
+        statementCount: 50,
+        hasConditionals: true,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 50, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 50 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get -15 for high complexity
+      expect(score).toBeLessThanOrEqual(40)
+    })
+
+    it('should penalize multiple I/O types', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'db.user.findFirst', line: 2, isAwaited: true },
+          { expression: 'fetch', line: 5, isAwaited: true },
+          { expression: 'fs.readFile', line: 8, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 2 },
+        { type: 'network-fetch', line: 5 },
+        { type: 'fs-call', line: 8 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get -10 for multiple I/O types
+      expect(score).toBeLessThanOrEqual(50)
+    })
+
+    it('should penalize no pure function calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'db.user.findFirst', line: 2, isAwaited: true },
+          { expression: 'db.user.update', line: 5, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 2 },
+        { type: 'database-call', line: 5 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get -10 for no pure function calls
+      expect(score).toBeLessThanOrEqual(50)
+    })
+
+    it('should penalize very long functions', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 150,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 50, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 50 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      // Should get -10 for very long function
+      expect(score).toBeLessThanOrEqual(40)
+    })
+  })
+
+  describe('combined scenarios', () => {
+    it('should give high score for well-structured impure function', () => {
+      // This simulates the acceptInvite pattern from organizations.ts
+      // - Calls a pure function (planAcceptInvite)
+      // - I/O at the end (EXECUTE pattern)
+      // - Shell naming convention (handleX)
+      const fn = createTestFunction({
+        name: 'handleAcceptInvite',
+        bodyLineCount: 30,
+        statementCount: 8,
+        hasConditionals: true,
+        callSites: [
+          { expression: 'planAcceptInvite', line: 5, isAwaited: false },
+          { expression: 'db.invitation.update', line: 22, isAwaited: true },
+          { expression: 'db.member.create', line: 25, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 22 },
+        { type: 'database-call', line: 25 },
+      ])
+      const context = createTestContext(
+        [
+          {
+            moduleSpecifier: './organizations.pure',
+            namedImports: ['planAcceptInvite'],
+          },
+        ],
+        ['./organizations.pure'],
+      )
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeGreaterThanOrEqual(70)
+    })
+
+    it('should give low score for tangled impure function', () => {
+      // This simulates a poorly structured function
+      // - No pure function calls
+      // - I/O interleaved throughout
+      // - High complexity
+      // - Multiple I/O types
+      const fn = createTestFunction({
+        name: 'processData',
+        bodyLineCount: 100,
+        statementCount: 40,
+        hasConditionals: true,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 5, isAwaited: true },
+          { expression: 'fetch', line: 20, isAwaited: true },
+          { expression: 'db.cache.get', line: 35, isAwaited: true },
+          { expression: 'console.log', line: 50, isAwaited: false },
+          { expression: 'db.result.create', line: 70, isAwaited: true },
+          { expression: 'fetch', line: 85, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 5 },
+        { type: 'network-fetch', line: 20 },
+        { type: 'database-call', line: 35 },
+        { type: 'console-log', line: 50 },
+        { type: 'database-call', line: 70 },
+        { type: 'network-fetch', line: 85 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeLessThan(40)
+    })
+
+    it('should give medium score for moderately structured function', () => {
+      // Some good patterns, some bad - interleaved I/O with no pure file calls
+      const fn = createTestFunction({
+        name: 'updateUser',
+        bodyLineCount: 100,
+        statementCount: 40,
+        hasConditionals: true,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 10, isAwaited: true },
+          { expression: 'someHelper', line: 30, isAwaited: false },
+          { expression: 'db.user.update', line: 50, isAwaited: true },
+          { expression: 'anotherHelper', line: 70, isAwaited: false },
+          { expression: 'db.audit.create', line: 90, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([
+        { type: 'database-call', line: 10 },
+        { type: 'database-call', line: 50 },
+        { type: 'database-call', line: 90 },
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeGreaterThanOrEqual(0)
+      expect(score).toBeLessThan(70)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle function with no call sites', () => {
+      const fn = createTestFunction({
+        callSites: [],
+        propertyAccessChains: ['process.env.NODE_ENV'],
+      })
+      const markers = createMarkers([{ type: 'env-access' }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeGreaterThanOrEqual(0)
+      expect(score).toBeLessThanOrEqual(100)
+    })
+
+    it('should handle function with single line', () => {
+      const fn = createTestFunction({
+        bodyLineCount: 1,
+        statementCount: 1,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 0, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 0 }])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeGreaterThanOrEqual(0)
+      expect(score).toBeLessThanOrEqual(100)
+    })
+
+    it('should clamp score to 0 for extremely bad functions', () => {
+      const fn = createTestFunction({
+        name: 'terribleFunction',
+        bodyLineCount: 500,
+        statementCount: 200,
+        hasConditionals: true,
+        callSites: Array.from({ length: 20 }, (_, i) => ({
+          expression:
+            i % 3 === 0
+              ? 'db.user.findFirst'
+              : i % 3 === 1
+                ? 'fetch'
+                : 'fs.readFile',
+          line: i * 25,
+          isAwaited: true,
+        })),
+      })
+      const markers = createMarkers([
+        ...Array.from({ length: 7 }, () => ({
+          type: 'database-call' as const,
+        })),
+        ...Array.from({ length: 7 }, () => ({
+          type: 'network-fetch' as const,
+        })),
+        ...Array.from({ length: 6 }, () => ({ type: 'fs-call' as const })),
+      ])
+      const context = createTestContext()
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should clamp score to 100 for extremely good functions', () => {
+      const fn = createTestFunction({
+        name: 'handlePerfectFunction',
+        bodyLineCount: 10,
+        statementCount: 3,
+        hasConditionals: false,
+        callSites: [
+          { expression: 'planOperation', line: 2, isAwaited: false },
+          { expression: 'deriveResult', line: 3, isAwaited: false },
+          { expression: 'computeValue', line: 4, isAwaited: false },
+          { expression: 'isValid', line: 5, isAwaited: false },
+          { expression: 'db.user.create', line: 8, isAwaited: true },
+        ],
+      })
+      const markers = createMarkers([{ type: 'database-call', line: 8 }])
+      const context = createTestContext(
+        [{ moduleSpecifier: './domain.pure', namedImports: ['planOperation'] }],
+        ['./domain.pure'],
+      )
+
+      const score = computeQualityScore(fn, markers, context)
+
+      expect(score).toBeLessThanOrEqual(100)
+    })
+  })
+})
+
+describe('analyzeFunction', () => {
+  it('should return analysis with all expected fields', () => {
+    const fn = createTestFunction({
+      callSites: [
+        { expression: 'db.user.findFirst', line: 5, isAwaited: true },
+      ],
+    })
+    const markers = createMarkers([{ type: 'database-call', line: 5 }])
+    const context = createTestContext()
+
+    const analysis = analyzeFunction(fn, markers, context)
+
+    expect(analysis).toHaveProperty('callsPureFile')
+    expect(analysis).toHaveProperty('callsPureNamingConvention')
+    expect(analysis).toHaveProperty('ioConcentratedAtStart')
+    expect(analysis).toHaveProperty('ioConcentratedAtEnd')
+    expect(analysis).toHaveProperty('lowComplexity')
+    expect(analysis).toHaveProperty('shellNamingConvention')
+    expect(analysis).toHaveProperty('callsPredicateFunctions')
+    expect(analysis).toHaveProperty('ioInterleaved')
+    expect(analysis).toHaveProperty('highComplexity')
+    expect(analysis).toHaveProperty('multipleIoTypes')
+    expect(analysis).toHaveProperty('noPureFunctionCalls')
+    expect(analysis).toHaveProperty('veryLongFunction')
+    expect(analysis).toHaveProperty('estimatedComplexity')
+    expect(analysis).toHaveProperty('ioMarkerCount')
+    expect(analysis).toHaveProperty('uniqueIoTypes')
+    expect(analysis).toHaveProperty('pureCallCount')
+    expect(analysis).toHaveProperty('predicateCallCount')
+  })
+
+  it('should detect pure file imports correctly', () => {
+    const fn = createTestFunction({
+      callSites: [
+        { expression: 'planAcceptInvite', line: 5, isAwaited: false },
+      ],
+    })
+    const markers: ImpurityMarker[] = []
+    const context = createTestContext(
+      [
+        {
+          moduleSpecifier: './organizations.pure',
+          namedImports: ['planAcceptInvite'],
+        },
+      ],
+      ['./organizations.pure'],
+    )
+
+    const analysis = analyzeFunction(fn, markers, context)
+
+    expect(analysis.callsPureFile).toBe(true)
+  })
+
+  it('should detect pure naming conventions', () => {
+    const fn = createTestFunction({
+      callSites: [
+        { expression: 'deriveSettings', line: 2, isAwaited: false },
+        { expression: 'computeTotal', line: 3, isAwaited: false },
+        { expression: 'transformData', line: 4, isAwaited: false },
+      ],
+    })
+    const markers: ImpurityMarker[] = []
+    const context = createTestContext()
+
+    const analysis = analyzeFunction(fn, markers, context)
+
+    expect(analysis.callsPureNamingConvention).toBe(true)
+    expect(analysis.pureCallCount).toBe(3)
+  })
+
+  it('should detect predicate function calls', () => {
+    const fn = createTestFunction({
+      callSites: [
+        { expression: 'isValid', line: 2, isAwaited: false },
+        { expression: 'hasPermission', line: 3, isAwaited: false },
+      ],
+    })
+    const markers: ImpurityMarker[] = []
+    const context = createTestContext()
+
+    const analysis = analyzeFunction(fn, markers, context)
+
+    expect(analysis.callsPredicateFunctions).toBe(true)
+    expect(analysis.predicateCallCount).toBe(2)
+  })
+})
+
+describe('QUALITY_WEIGHTS', () => {
+  it('should have positive weights for good patterns', () => {
+    expect(QUALITY_WEIGHTS.callsPureFile).toBeGreaterThan(0)
+    expect(QUALITY_WEIGHTS.callsPureNamingConvention).toBeGreaterThan(0)
+    expect(QUALITY_WEIGHTS.ioConcentratedAtStart).toBeGreaterThan(0)
+    expect(QUALITY_WEIGHTS.ioConcentratedAtEnd).toBeGreaterThan(0)
+    expect(QUALITY_WEIGHTS.lowComplexity).toBeGreaterThan(0)
+    expect(QUALITY_WEIGHTS.shellNamingConvention).toBeGreaterThan(0)
+    expect(QUALITY_WEIGHTS.callsPredicateFunctions).toBeGreaterThan(0)
+  })
+
+  it('should have negative weights for bad patterns', () => {
+    expect(QUALITY_WEIGHTS.ioInterleaved).toBeLessThan(0)
+    expect(QUALITY_WEIGHTS.highComplexity).toBeLessThan(0)
+    expect(QUALITY_WEIGHTS.multipleIoTypes).toBeLessThan(0)
+    expect(QUALITY_WEIGHTS.noPureFunctionCalls).toBeLessThan(0)
+    expect(QUALITY_WEIGHTS.veryLongFunction).toBeLessThan(0)
+  })
+})