fcis 0.1.0

package/tests/classifier.test.ts

@@ -0,0 +1,480 @@
+/**
+ * Classifier Tests
+ *
+ * Tests for the pure core classification logic.
+ * These tests verify that functions are correctly classified as pure or impure
+ * based on their markers.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import {
+  classifyFunction,
+  shouldExcludeFunction,
+  createClassifiedFunction,
+  partitionByClassification,
+  getClassificationSummary,
+} from '../src/classification/classifier.js'
+import type { ExtractedFunction, ImpurityMarker, Status } from '../src/types.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: false,
+    isExported: false,
+    bodyLineCount: 10,
+    statementCount: 5,
+    hasConditionals: false,
+    parentContext: null,
+    callSites: [],
+    hasAwait: false,
+    propertyAccessChains: [],
+    kind: 'function',
+    ...overrides,
+  }
+}
+
+describe('classifyFunction', () => {
+  describe('pure classification', () => {
+    it('should classify function with no markers as pure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = []
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('pure')
+    })
+
+    it('should classify async function without await or I/O as pure', () => {
+      const fn = createTestFunction({
+        isAsync: true,
+        hasAwait: false,
+      })
+      const markers: ImpurityMarker[] = []
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('pure')
+    })
+  })
+
+  describe('impure classification', () => {
+    it('should classify function with await-expression marker as impure', () => {
+      const fn = createTestFunction({
+        isAsync: true,
+        hasAwait: true,
+      })
+      const markers: ImpurityMarker[] = [
+        { type: 'await-expression', detail: 'await fetchData()' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with database-call marker as impure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = [
+        { type: 'database-call', detail: 'db.user.findFirst' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with network-fetch marker as impure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = [
+        { type: 'network-fetch', detail: 'fetch' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with fs-call marker as impure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = [
+        { type: 'fs-call', detail: 'fs.readFile' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with env-access marker as impure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = [
+        { type: 'env-access', detail: 'process.env.NODE_ENV' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with console-log marker as impure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = [
+        { type: 'console-log', detail: 'console.log' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with multiple markers as impure', () => {
+      const fn = createTestFunction()
+      const markers: ImpurityMarker[] = [
+        { type: 'database-call', detail: 'db.user.findFirst' },
+        { type: 'console-log', detail: 'console.log' },
+        { type: 'env-access', detail: 'process.env.DEBUG' },
+      ]
+
+      const classification = classifyFunction(fn, markers)
+
+      expect(classification).toBe('impure')
+    })
+
+    it('should classify function with any I/O marker as impure', () => {
+      const allMarkerTypes: ImpurityMarker['type'][] = [
+        'await-expression',
+        'database-call',
+        'network-fetch',
+        'network-http',
+        'fs-import',
+        'fs-call',
+        'env-access',
+        'console-log',
+        'logging',
+        'telemetry',
+        'queue-enqueue',
+        'event-emit',
+      ]
+
+      for (const markerType of allMarkerTypes) {
+        const fn = createTestFunction()
+        const markers: ImpurityMarker[] = [{ type: markerType, detail: 'test' }]
+
+        const classification = classifyFunction(fn, markers)
+
+        expect(classification).toBe('impure')
+      }
+    })
+  })
+})
+
+describe('shouldExcludeFunction', () => {
+  it('should exclude trivial functions with < 3 statements and no conditionals', () => {
+    const fn = createTestFunction({
+      statementCount: 2,
+      hasConditionals: false,
+    })
+
+    expect(shouldExcludeFunction(fn)).toBe(true)
+  })
+
+  it('should exclude single-statement functions', () => {
+    const fn = createTestFunction({
+      statementCount: 1,
+      hasConditionals: false,
+    })
+
+    expect(shouldExcludeFunction(fn)).toBe(true)
+  })
+
+  it('should not exclude functions with >= 3 statements', () => {
+    const fn = createTestFunction({
+      statementCount: 3,
+      hasConditionals: false,
+    })
+
+    expect(shouldExcludeFunction(fn)).toBe(false)
+  })
+
+  it('should not exclude functions with conditionals even if < 3 statements', () => {
+    const fn = createTestFunction({
+      statementCount: 2,
+      hasConditionals: true,
+    })
+
+    expect(shouldExcludeFunction(fn)).toBe(false)
+  })
+
+  it('should not exclude complex functions', () => {
+    const fn = createTestFunction({
+      statementCount: 10,
+      hasConditionals: true,
+    })
+
+    expect(shouldExcludeFunction(fn)).toBe(false)
+  })
+})
+
+describe('createClassifiedFunction', () => {
+  it('should create classified function with all properties', () => {
+    const fn = createTestFunction({ name: 'myFunction' })
+    const markers: ImpurityMarker[] = [
+      { type: 'database-call', detail: 'db.user.findFirst' },
+    ]
+    const qualityScore = 75
+    const status: Status = 'ok'
+
+    const classified = createClassifiedFunction(
+      fn,
+      markers,
+      qualityScore,
+      status,
+    )
+
+    expect(classified.name).toBe('myFunction')
+    expect(classified.classification).toBe('impure')
+    expect(classified.markers).toEqual(markers)
+    expect(classified.qualityScore).toBe(75)
+    expect(classified.status).toBe('ok')
+  })
+
+  it('should classify as pure when no markers', () => {
+    const fn = createTestFunction({ name: 'pureFunction' })
+    const markers: ImpurityMarker[] = []
+    const qualityScore = null
+    const status: Status = 'ok'
+
+    const classified = createClassifiedFunction(
+      fn,
+      markers,
+      qualityScore,
+      status,
+    )
+
+    expect(classified.classification).toBe('pure')
+    expect(classified.qualityScore).toBeNull()
+  })
+
+  it('should preserve all original function properties', () => {
+    const fn = createTestFunction({
+      name: 'testFn',
+      filePath: '/src/test.ts',
+      startLine: 10,
+      endLine: 25,
+      isAsync: true,
+      isExported: true,
+      bodyLineCount: 15,
+      statementCount: 8,
+      hasConditionals: true,
+      parentContext: 'TestClass',
+      kind: 'method',
+    })
+    const markers: ImpurityMarker[] = []
+
+    const classified = createClassifiedFunction(fn, markers, null, 'ok')
+
+    expect(classified.name).toBe('testFn')
+    expect(classified.filePath).toBe('/src/test.ts')
+    expect(classified.startLine).toBe(10)
+    expect(classified.endLine).toBe(25)
+    expect(classified.isAsync).toBe(true)
+    expect(classified.isExported).toBe(true)
+    expect(classified.bodyLineCount).toBe(15)
+    expect(classified.statementCount).toBe(8)
+    expect(classified.hasConditionals).toBe(true)
+    expect(classified.parentContext).toBe('TestClass')
+    expect(classified.kind).toBe('method')
+  })
+})
+
+describe('partitionByClassification', () => {
+  it('should partition functions into pure and impure arrays', () => {
+    const pureFn1 = createClassifiedFunction(
+      createTestFunction({ name: 'pure1' }),
+      [],
+      null,
+      'ok',
+    )
+    const pureFn2 = createClassifiedFunction(
+      createTestFunction({ name: 'pure2' }),
+      [],
+      null,
+      'ok',
+    )
+    const impureFn = createClassifiedFunction(
+      createTestFunction({ name: 'impure1' }),
+      [{ type: 'database-call', detail: 'db.user.findFirst' }],
+      70,
+      'ok',
+    )
+
+    const result = partitionByClassification([pureFn1, impureFn, pureFn2])
+
+    expect(result.pure).toHaveLength(2)
+    expect(result.impure).toHaveLength(1)
+    expect(result.pure.map(f => f.name)).toContain('pure1')
+    expect(result.pure.map(f => f.name)).toContain('pure2')
+    expect(result.impure.map(f => f.name)).toContain('impure1')
+  })
+
+  it('should handle all pure functions', () => {
+    const pureFn1 = createClassifiedFunction(
+      createTestFunction({ name: 'pure1' }),
+      [],
+      null,
+      'ok',
+    )
+    const pureFn2 = createClassifiedFunction(
+      createTestFunction({ name: 'pure2' }),
+      [],
+      null,
+      'ok',
+    )
+
+    const result = partitionByClassification([pureFn1, pureFn2])
+
+    expect(result.pure).toHaveLength(2)
+    expect(result.impure).toHaveLength(0)
+  })
+
+  it('should handle all impure functions', () => {
+    const impureFn1 = createClassifiedFunction(
+      createTestFunction({ name: 'impure1' }),
+      [{ type: 'database-call', detail: 'db.user.findFirst' }],
+      70,
+      'ok',
+    )
+    const impureFn2 = createClassifiedFunction(
+      createTestFunction({ name: 'impure2' }),
+      [{ type: 'network-fetch', detail: 'fetch' }],
+      50,
+      'review',
+    )
+
+    const result = partitionByClassification([impureFn1, impureFn2])
+
+    expect(result.pure).toHaveLength(0)
+    expect(result.impure).toHaveLength(2)
+  })
+
+  it('should handle empty array', () => {
+    const result = partitionByClassification([])
+
+    expect(result.pure).toHaveLength(0)
+    expect(result.impure).toHaveLength(0)
+  })
+})
+
+describe('getClassificationSummary', () => {
+  it('should return correct summary for mixed functions', () => {
+    const pureFn = createClassifiedFunction(
+      createTestFunction({ name: 'pure' }),
+      [],
+      null,
+      'ok',
+    )
+    const impureFn1 = createClassifiedFunction(
+      createTestFunction({ name: 'impure1' }),
+      [{ type: 'database-call', detail: 'db.user.findFirst' }],
+      70,
+      'ok',
+    )
+    const impureFn2 = createClassifiedFunction(
+      createTestFunction({ name: 'impure2' }),
+      [{ type: 'network-fetch', detail: 'fetch' }],
+      50,
+      'review',
+    )
+
+    const summary = getClassificationSummary([pureFn, impureFn1, impureFn2])
+
+    expect(summary.total).toBe(3)
+    expect(summary.pureCount).toBe(1)
+    expect(summary.impureCount).toBe(2)
+    expect(summary.purityPercentage).toBeCloseTo(33.33, 1)
+  })
+
+  it('should return 100% purity for all pure functions', () => {
+    const pureFn1 = createClassifiedFunction(
+      createTestFunction({ name: 'pure1' }),
+      [],
+      null,
+      'ok',
+    )
+    const pureFn2 = createClassifiedFunction(
+      createTestFunction({ name: 'pure2' }),
+      [],
+      null,
+      'ok',
+    )
+
+    const summary = getClassificationSummary([pureFn1, pureFn2])
+
+    expect(summary.total).toBe(2)
+    expect(summary.pureCount).toBe(2)
+    expect(summary.impureCount).toBe(0)
+    expect(summary.purityPercentage).toBe(100)
+  })
+
+  it('should return 0% purity for all impure functions', () => {
+    const impureFn1 = createClassifiedFunction(
+      createTestFunction({ name: 'impure1' }),
+      [{ type: 'database-call', detail: 'db.user.findFirst' }],
+      70,
+      'ok',
+    )
+    const impureFn2 = createClassifiedFunction(
+      createTestFunction({ name: 'impure2' }),
+      [{ type: 'network-fetch', detail: 'fetch' }],
+      50,
+      'review',
+    )
+
+    const summary = getClassificationSummary([impureFn1, impureFn2])
+
+    expect(summary.total).toBe(2)
+    expect(summary.pureCount).toBe(0)
+    expect(summary.impureCount).toBe(2)
+    expect(summary.purityPercentage).toBe(0)
+  })
+
+  it('should return 100% purity for empty array', () => {
+    const summary = getClassificationSummary([])
+
+    expect(summary.total).toBe(0)
+    expect(summary.pureCount).toBe(0)
+    expect(summary.impureCount).toBe(0)
+    expect(summary.purityPercentage).toBe(100)
+  })
+
+  it('should calculate correct percentages for 50/50 split', () => {
+    const pureFn = createClassifiedFunction(
+      createTestFunction({ name: 'pure' }),
+      [],
+      null,
+      'ok',
+    )
+    const impureFn = createClassifiedFunction(
+      createTestFunction({ name: 'impure' }),
+      [{ type: 'database-call', detail: 'db.user.findFirst' }],
+      70,
+      'ok',
+    )
+
+    const summary = getClassificationSummary([pureFn, impureFn])
+
+    expect(summary.total).toBe(2)
+    expect(summary.pureCount).toBe(1)
+    expect(summary.impureCount).toBe(1)
+    expect(summary.purityPercentage).toBe(50)
+  })
+})