fcis 0.1.0

package/tests/derive-status.test.ts

@@ -0,0 +1,464 @@
+/**
+ * Status Derivation Tests
+ *
+ * Tests for the pure core status derivation logic.
+ * These tests verify that status is correctly derived from
+ * classification and quality score.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import {
+  deriveStatus,
+  getStatusDescription,
+  getStatusEmoji,
+  getStatusColor,
+  needsAttention,
+  isOk,
+  sortByStatusPriority,
+  validateThresholds,
+} from '../src/classification/derive-status.js'
+import type {
+  ClassifiedFunction,
+  ExtractedFunction,
+  QualityThresholds,
+} from '../src/types.js'
+import { DEFAULT_QUALITY_THRESHOLDS } 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,
+  }
+}
+
+/**
+ * Helper to create a classified function
+ */
+function createClassifiedFunction(
+  overrides: Partial<ClassifiedFunction>,
+): ClassifiedFunction {
+  return {
+    ...createTestFunction(),
+    markers: [],
+    classification: 'pure',
+    qualityScore: null,
+    status: 'ok',
+    ...overrides,
+  }
+}
+
+describe('deriveStatus', () => {
+  describe('pure functions', () => {
+    it('should return "ok" for pure functions', () => {
+      const status = deriveStatus('pure', null)
+      expect(status).toBe('ok')
+    })
+
+    it('should return "ok" for pure functions regardless of thresholds', () => {
+      const customThresholds: QualityThresholds = {
+        okThreshold: 90,
+        reviewThreshold: 80,
+      }
+
+      const status = deriveStatus('pure', null, customThresholds)
+      expect(status).toBe('ok')
+    })
+  })
+
+  describe('impure functions with default thresholds', () => {
+    it('should return "ok" for quality score >= 70', () => {
+      expect(deriveStatus('impure', 70)).toBe('ok')
+      expect(deriveStatus('impure', 75)).toBe('ok')
+      expect(deriveStatus('impure', 100)).toBe('ok')
+    })
+
+    it('should return "review" for quality score 40-69', () => {
+      expect(deriveStatus('impure', 40)).toBe('review')
+      expect(deriveStatus('impure', 50)).toBe('review')
+      expect(deriveStatus('impure', 69)).toBe('review')
+    })
+
+    it('should return "refactor" for quality score < 40', () => {
+      expect(deriveStatus('impure', 0)).toBe('refactor')
+      expect(deriveStatus('impure', 20)).toBe('refactor')
+      expect(deriveStatus('impure', 39)).toBe('refactor')
+    })
+
+    it('should handle boundary cases correctly', () => {
+      expect(deriveStatus('impure', 70)).toBe('ok')
+      expect(deriveStatus('impure', 69)).toBe('review')
+      expect(deriveStatus('impure', 40)).toBe('review')
+      expect(deriveStatus('impure', 39)).toBe('refactor')
+    })
+  })
+
+  describe('impure functions with custom thresholds', () => {
+    it('should respect custom okThreshold', () => {
+      const customThresholds: QualityThresholds = {
+        okThreshold: 80,
+        reviewThreshold: 50,
+      }
+
+      expect(deriveStatus('impure', 80, customThresholds)).toBe('ok')
+      expect(deriveStatus('impure', 79, customThresholds)).toBe('review')
+    })
+
+    it('should respect custom reviewThreshold', () => {
+      const customThresholds: QualityThresholds = {
+        okThreshold: 80,
+        reviewThreshold: 50,
+      }
+
+      expect(deriveStatus('impure', 50, customThresholds)).toBe('review')
+      expect(deriveStatus('impure', 49, customThresholds)).toBe('refactor')
+    })
+
+    it('should handle stricter thresholds', () => {
+      const strictThresholds: QualityThresholds = {
+        okThreshold: 90,
+        reviewThreshold: 70,
+      }
+
+      expect(deriveStatus('impure', 90, strictThresholds)).toBe('ok')
+      expect(deriveStatus('impure', 89, strictThresholds)).toBe('review')
+      expect(deriveStatus('impure', 70, strictThresholds)).toBe('review')
+      expect(deriveStatus('impure', 69, strictThresholds)).toBe('refactor')
+    })
+
+    it('should handle more lenient thresholds', () => {
+      const lenientThresholds: QualityThresholds = {
+        okThreshold: 50,
+        reviewThreshold: 20,
+      }
+
+      expect(deriveStatus('impure', 50, lenientThresholds)).toBe('ok')
+      expect(deriveStatus('impure', 49, lenientThresholds)).toBe('review')
+      expect(deriveStatus('impure', 20, lenientThresholds)).toBe('review')
+      expect(deriveStatus('impure', 19, lenientThresholds)).toBe('refactor')
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should return "review" for impure function with null quality score', () => {
+      // This is a defensive case that shouldn't normally happen
+      const status = deriveStatus('impure', null)
+      expect(status).toBe('review')
+    })
+
+    it('should handle quality score of exactly 0', () => {
+      const status = deriveStatus('impure', 0)
+      expect(status).toBe('refactor')
+    })
+
+    it('should handle quality score of exactly 100', () => {
+      const status = deriveStatus('impure', 100)
+      expect(status).toBe('ok')
+    })
+  })
+})
+
+describe('getStatusDescription', () => {
+  it('should return appropriate description for "ok"', () => {
+    const description = getStatusDescription('ok')
+    expect(description).toContain('No action')
+  })
+
+  it('should return appropriate description for "review"', () => {
+    const description = getStatusDescription('review')
+    expect(description.toLowerCase()).toContain('improving')
+  })
+
+  it('should return appropriate description for "refactor"', () => {
+    const description = getStatusDescription('refactor')
+    expect(description.toLowerCase()).toContain('cleanup')
+  })
+})
+
+describe('getStatusEmoji', () => {
+  it('should return check mark for "ok"', () => {
+    const emoji = getStatusEmoji('ok')
+    expect(emoji).toBe('✓')
+  })
+
+  it('should return half-filled circle for "review"', () => {
+    const emoji = getStatusEmoji('review')
+    expect(emoji).toBe('◐')
+  })
+
+  it('should return X mark for "refactor"', () => {
+    const emoji = getStatusEmoji('refactor')
+    expect(emoji).toBe('✗')
+  })
+})
+
+describe('getStatusColor', () => {
+  it('should return green for "ok"', () => {
+    const color = getStatusColor('ok')
+    expect(color).toBe('green')
+  })
+
+  it('should return yellow for "review"', () => {
+    const color = getStatusColor('review')
+    expect(color).toBe('yellow')
+  })
+
+  it('should return red for "refactor"', () => {
+    const color = getStatusColor('refactor')
+    expect(color).toBe('red')
+  })
+})
+
+describe('needsAttention', () => {
+  it('should return false for functions with status "ok"', () => {
+    const fn = createClassifiedFunction({ status: 'ok' })
+    expect(needsAttention(fn)).toBe(false)
+  })
+
+  it('should return true for functions with status "review"', () => {
+    const fn = createClassifiedFunction({ status: 'review' })
+    expect(needsAttention(fn)).toBe(true)
+  })
+
+  it('should return true for functions with status "refactor"', () => {
+    const fn = createClassifiedFunction({ status: 'refactor' })
+    expect(needsAttention(fn)).toBe(true)
+  })
+})
+
+describe('isOk', () => {
+  it('should return true for functions with status "ok"', () => {
+    const fn = createClassifiedFunction({ status: 'ok' })
+    expect(isOk(fn)).toBe(true)
+  })
+
+  it('should return false for functions with status "review"', () => {
+    const fn = createClassifiedFunction({ status: 'review' })
+    expect(isOk(fn)).toBe(false)
+  })
+
+  it('should return false for functions with status "refactor"', () => {
+    const fn = createClassifiedFunction({ status: 'refactor' })
+    expect(isOk(fn)).toBe(false)
+  })
+})
+
+describe('sortByStatusPriority', () => {
+  it('should sort refactor first, then review, then ok', () => {
+    const okFn = createClassifiedFunction({ name: 'okFn', status: 'ok' })
+    const reviewFn = createClassifiedFunction({
+      name: 'reviewFn',
+      status: 'review',
+    })
+    const refactorFn = createClassifiedFunction({
+      name: 'refactorFn',
+      status: 'refactor',
+    })
+
+    const sorted = sortByStatusPriority([okFn, reviewFn, refactorFn])
+
+    expect(sorted[0]?.status).toBe('refactor')
+    expect(sorted[1]?.status).toBe('review')
+    expect(sorted[2]?.status).toBe('ok')
+  })
+
+  it('should sort by quality score within same status (lower first)', () => {
+    const impure1 = createClassifiedFunction({
+      name: 'impure1',
+      status: 'refactor',
+      classification: 'impure',
+      qualityScore: 30,
+    })
+    const impure2 = createClassifiedFunction({
+      name: 'impure2',
+      status: 'refactor',
+      classification: 'impure',
+      qualityScore: 20,
+    })
+    const impure3 = createClassifiedFunction({
+      name: 'impure3',
+      status: 'refactor',
+      classification: 'impure',
+      qualityScore: 35,
+    })
+
+    const sorted = sortByStatusPriority([impure1, impure2, impure3])
+
+    expect(sorted[0]?.qualityScore).toBe(20)
+    expect(sorted[1]?.qualityScore).toBe(30)
+    expect(sorted[2]?.qualityScore).toBe(35)
+  })
+
+  it('should sort by body line count within same status and null quality scores', () => {
+    const pure1 = createClassifiedFunction({
+      name: 'pure1',
+      status: 'ok',
+      bodyLineCount: 20,
+    })
+    const pure2 = createClassifiedFunction({
+      name: 'pure2',
+      status: 'ok',
+      bodyLineCount: 50,
+    })
+    const pure3 = createClassifiedFunction({
+      name: 'pure3',
+      status: 'ok',
+      bodyLineCount: 30,
+    })
+
+    const sorted = sortByStatusPriority([pure1, pure2, pure3])
+
+    // Larger body line count first (tertiary sort)
+    expect(sorted[0]?.bodyLineCount).toBe(50)
+    expect(sorted[1]?.bodyLineCount).toBe(30)
+    expect(sorted[2]?.bodyLineCount).toBe(20)
+  })
+
+  it('should handle empty array', () => {
+    const sorted = sortByStatusPriority([])
+    expect(sorted).toEqual([])
+  })
+
+  it('should handle single element array', () => {
+    const fn = createClassifiedFunction({ name: 'single' })
+    const sorted = sortByStatusPriority([fn])
+    expect(sorted).toHaveLength(1)
+    expect(sorted[0]?.name).toBe('single')
+  })
+
+  it('should not mutate original array', () => {
+    const okFn = createClassifiedFunction({ name: 'okFn', status: 'ok' })
+    const refactorFn = createClassifiedFunction({
+      name: 'refactorFn',
+      status: 'refactor',
+    })
+
+    const original = [okFn, refactorFn]
+    sortByStatusPriority(original)
+
+    expect(original[0]?.name).toBe('okFn')
+    expect(original[1]?.name).toBe('refactorFn')
+  })
+})
+
+describe('validateThresholds', () => {
+  it('should validate correct thresholds', () => {
+    const result = validateThresholds(DEFAULT_QUALITY_THRESHOLDS)
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('should reject okThreshold < 0', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: -1,
+      reviewThreshold: 40,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(e => e.includes('okThreshold'))).toBe(true)
+  })
+
+  it('should reject okThreshold > 100', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 101,
+      reviewThreshold: 40,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(e => e.includes('okThreshold'))).toBe(true)
+  })
+
+  it('should reject reviewThreshold < 0', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 70,
+      reviewThreshold: -1,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(e => e.includes('reviewThreshold'))).toBe(true)
+  })
+
+  it('should reject reviewThreshold > 100', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 70,
+      reviewThreshold: 101,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(e => e.includes('reviewThreshold'))).toBe(true)
+  })
+
+  it('should reject reviewThreshold >= okThreshold', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 70,
+      reviewThreshold: 70,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(e => e.includes('less than'))).toBe(true)
+  })
+
+  it('should reject reviewThreshold > okThreshold', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 50,
+      reviewThreshold: 70,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(e => e.includes('less than'))).toBe(true)
+  })
+
+  it('should collect multiple errors', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 150,
+      reviewThreshold: 200,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(false)
+    expect(result.errors.length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('should accept valid edge case thresholds', () => {
+    const thresholds: QualityThresholds = {
+      okThreshold: 100,
+      reviewThreshold: 0,
+    }
+
+    const result = validateThresholds(thresholds)
+
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+})