fcis 0.1.0

package/tests/integration.test.ts

@@ -0,0 +1,706 @@
+/**
+ * Integration Tests
+ *
+ * Tests for the full analysis pipeline using ts-morph's in-memory file system.
+ * These tests verify that extraction, detection, classification, and scoring
+ * work correctly together on real TypeScript ASTs.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { Project } from 'ts-morph'
+
+import {
+  extractFunctions,
+  extractImports,
+  isTypeOnlyFile,
+} from '../src/extraction/extract-functions.js'
+import {
+  detectMarkers,
+  createDetectionContext,
+} from '../src/detection/detect-markers.js'
+import {
+  classifyFunction,
+  shouldExcludeFunction,
+  createClassifiedFunction,
+} from '../src/classification/classifier.js'
+import { computeQualityScore } from '../src/classification/quality-scorer.js'
+import { deriveStatus } from '../src/classification/derive-status.js'
+import {
+  scoreFile,
+  scoreProject,
+  scoreDirectory,
+} from '../src/scoring/scorer.js'
+import type { ClassifiedFunction } from '../src/types.js'
+
+/**
+ * Helper to create an in-memory ts-morph project with test files
+ */
+function createTestProject(files: Record<string, string>): Project {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+      target: 99, // ESNext
+      module: 99, // ESNext
+      strict: true,
+    },
+  })
+
+  for (const [path, content] of Object.entries(files)) {
+    project.createSourceFile(path, content)
+  }
+
+  return project
+}
+
+/**
+ * Helper to run the full analysis pipeline on a source file
+ */
+function analyzeSourceFile(
+  project: Project,
+  filePath: string,
+): ClassifiedFunction[] {
+  const sourceFile = project.getSourceFile(filePath)
+  if (!sourceFile) {
+    throw new Error(`File not found: ${filePath}`)
+  }
+
+  const functions = extractFunctions(sourceFile)
+  const imports = extractImports(sourceFile)
+  const context = createDetectionContext(imports)
+
+  const classifiedFunctions: ClassifiedFunction[] = []
+
+  for (const fn of functions) {
+    if (shouldExcludeFunction(fn)) {
+      continue
+    }
+
+    const markers = detectMarkers(fn, context)
+    const classification = classifyFunction(fn, markers)
+
+    let qualityScore: number | null = null
+    if (classification === 'impure') {
+      qualityScore = computeQualityScore(fn, markers, context)
+    }
+
+    const status = deriveStatus(classification, qualityScore)
+
+    classifiedFunctions.push(
+      createClassifiedFunction(fn, markers, qualityScore, status),
+    )
+  }
+
+  return classifiedFunctions
+}
+
+describe('Integration: Full Pipeline', () => {
+  describe('pure function detection', () => {
+    it('should classify a pure function with no I/O', () => {
+      const project = createTestProject({
+        '/src/math.ts': `
+          export function add(a: number, b: number): number {
+            const result = a + b
+            const doubled = result * 2
+            const final = doubled - result
+            return final
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/math.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('pure')
+      expect(functions[0]?.status).toBe('ok')
+      expect(functions[0]?.qualityScore).toBeNull()
+      expect(functions[0]?.markers).toHaveLength(0)
+    })
+
+    it('should classify async function without await as pure', () => {
+      const project = createTestProject({
+        '/src/async-pure.ts': `
+          export async function computeAsync(data: number[]): Promise<number> {
+            const sum = data.reduce((a, b) => a + b, 0)
+            const avg = sum / data.length
+            return avg
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/async-pure.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('pure')
+      expect(functions[0]?.isAsync).toBe(true)
+    })
+
+    it('should classify predicate functions as pure', () => {
+      const project = createTestProject({
+        '/src/predicates.ts': `
+          export function isValid(value: unknown): boolean {
+            if (value === null || value === undefined) {
+              return false
+            }
+            const isString = typeof value === 'string'
+            const hasLength = isString && value.length > 0
+            return hasLength
+          }
+
+          export function hasPermission(user: { roles: string[] }, required: string): boolean {
+            const roles = user.roles
+            const hasRole = roles.includes(required)
+            const isAdmin = roles.includes('admin')
+            return hasRole || isAdmin
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/predicates.ts')
+
+      expect(functions).toHaveLength(2)
+      expect(functions.every(f => f.classification === 'pure')).toBe(true)
+    })
+  })
+
+  describe('impure function detection', () => {
+    it('should classify function with database call as impure', () => {
+      const project = createTestProject({
+        '/src/users.ts': `
+          export async function getUser(id: string) {
+            const whereClause = { id }
+            const user = await db.user.findFirst({ where: whereClause })
+            const result = user ? user : null
+            return result
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/users.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('impure')
+      expect(functions[0]?.markers.some(m => m.type === 'database-call')).toBe(
+        true,
+      )
+      expect(
+        functions[0]?.markers.some(m => m.type === 'await-expression'),
+      ).toBe(true)
+    })
+
+    it('should classify function with fetch call as impure', () => {
+      const project = createTestProject({
+        '/src/api.ts': `
+          export async function fetchData(url: string) {
+            const response = await fetch(url)
+            const data = await response.json()
+            return data
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/api.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('impure')
+      expect(functions[0]?.markers.some(m => m.type === 'network-fetch')).toBe(
+        true,
+      )
+    })
+
+    it('should classify function with console.log as impure', () => {
+      const project = createTestProject({
+        '/src/logger.ts': `
+          export function logMessage(message: string): void {
+            const timestamp = new Date().toISOString()
+            const formatted = \`[\${timestamp}] \${message}\`
+            const output = formatted.trim()
+            console.log(output)
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/logger.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('impure')
+      expect(functions[0]?.markers.some(m => m.type === 'console-log')).toBe(
+        true,
+      )
+    })
+
+    it('should classify function with process.env access as impure', () => {
+      const project = createTestProject({
+        '/src/config.ts': `
+          export function getConfig() {
+            const apiUrl = process.env.API_URL
+            const debug = process.env.DEBUG === 'true'
+            return { apiUrl, debug }
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/config.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('impure')
+      expect(functions[0]?.markers.some(m => m.type === 'env-access')).toBe(
+        true,
+      )
+    })
+  })
+
+  describe('quality scoring', () => {
+    it('should give high quality score to well-structured impure function', () => {
+      const project = createTestProject({
+        '/src/service.ts': `
+          import { planAcceptInvite } from './domain.pure'
+
+          export async function handleAcceptInvite(inviteId: string) {
+            // GATHER
+            const invite = await db.invitation.findFirst({ where: { id: inviteId } })
+            const org = await db.organization.findFirst({ where: { id: invite.orgId } })
+
+            // DECIDE (pure)
+            const plan = planAcceptInvite(invite, org)
+
+            // EXECUTE
+            if (plan.shouldAccept) {
+              await db.member.create({ data: plan.memberData })
+              await db.invitation.update({ where: { id: inviteId }, data: { accepted: true } })
+            }
+
+            return plan.result
+          }
+        `,
+        '/src/domain.pure.ts': `
+          export function planAcceptInvite(invite: any, org: any) {
+            return { shouldAccept: true, memberData: {}, result: 'accepted' }
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/service.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('impure')
+      // Should have decent quality due to calling pure function
+      expect(functions[0]?.qualityScore).toBeGreaterThanOrEqual(50)
+    })
+
+    it('should give low quality score to tangled impure function', () => {
+      const project = createTestProject({
+        '/src/tangled.ts': `
+          export async function processOrder(orderId: string) {
+            const order = await db.order.findFirst({ where: { id: orderId } })
+            console.log('Processing order', order)
+
+            if (order.status === 'pending') {
+              const user = await db.user.findFirst({ where: { id: order.userId } })
+              console.log('Found user', user)
+
+              const items = await db.orderItem.findMany({ where: { orderId } })
+
+              for (const item of items) {
+                const product = await db.product.findFirst({ where: { id: item.productId } })
+                console.log('Processing item', item, product)
+
+                if (product.stock < item.quantity) {
+                  await fetch('/api/restock', { method: 'POST', body: JSON.stringify({ productId: product.id }) })
+                }
+
+                await db.product.update({ where: { id: product.id }, data: { stock: product.stock - item.quantity } })
+              }
+
+              await db.order.update({ where: { id: orderId }, data: { status: 'processed' } })
+              console.log('Order processed')
+            }
+
+            return order
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/tangled.ts')
+
+      expect(functions).toHaveLength(1)
+      expect(functions[0]?.classification).toBe('impure')
+      expect(functions[0]?.qualityScore).toBeLessThan(50)
+      expect(functions[0]?.status).toBe('refactor')
+    })
+  })
+
+  describe('file scoring', () => {
+    it('should score a file with mixed functions', () => {
+      const project = createTestProject({
+        '/src/mixed.ts': `
+          // Pure function
+          export function calculateTotal(items: { price: number }[]): number {
+            const prices = items.map(item => item.price)
+            const sum = prices.reduce((acc, price) => acc + price, 0)
+            const rounded = Math.round(sum * 100) / 100
+            return rounded
+          }
+
+          // Pure function
+          export function formatCurrency(amount: number): string {
+            const fixed = amount.toFixed(2)
+            const formatted = \`$\${fixed}\`
+            const trimmed = formatted.trim()
+            return trimmed
+          }
+
+          // Impure function
+          export async function saveOrder(order: any) {
+            const total = calculateTotal(order.items)
+            const formatted = formatCurrency(total)
+            const data = { ...order, total }
+            console.log('Saving order with total:', formatted)
+            await db.order.create({ data })
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/mixed.ts')
+      const fileScore = scoreFile('/src/mixed.ts', functions)
+
+      expect(fileScore.pureCount).toBe(2)
+      expect(fileScore.impureCount).toBe(1)
+      expect(fileScore.purity).toBeCloseTo(66.67, 1)
+    })
+
+    it('should handle type-only files', () => {
+      const project = createTestProject({
+        '/src/types.ts': `
+          export interface User {
+            id: string
+            name: string
+            email: string
+          }
+
+          export type UserRole = 'admin' | 'user' | 'guest'
+
+          export enum Status {
+            Active = 'active',
+            Inactive = 'inactive',
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/types.ts')!
+      const isTypeOnly = isTypeOnlyFile(sourceFile)
+
+      expect(isTypeOnly).toBe(true)
+    })
+  })
+
+  describe('extraction edge cases', () => {
+    it('should extract arrow functions from variable declarations', () => {
+      const project = createTestProject({
+        '/src/arrows.ts': `
+          export const add = (a: number, b: number): number => {
+            const sum = a + b
+            const doubled = sum * 2
+            const result = doubled / 2
+            return result
+          }
+
+          export const multiply = (a: number, b: number): number => {
+            const result = a * b
+            const squared = result * result
+            const final = Math.sqrt(squared)
+            return final
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/arrows.ts')
+
+      expect(functions).toHaveLength(2)
+      expect(functions.every(f => f.kind === 'arrow')).toBe(true)
+    })
+
+    it('should use variable name for arrow functions', () => {
+      const project = createTestProject({
+        '/src/handlers.ts': `
+          export const handleSubmit = async (data: FormData) => {
+            const validated = validateData(data)
+            const transformed = transformData(validated)
+            const result = processData(transformed)
+            return result
+          }
+
+          export const validateInput = (input: string): boolean => {
+            const trimmed = input.trim()
+            const normalized = trimmed.toLowerCase()
+            const isValid = normalized.length > 0
+            return isValid
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/handlers.ts')
+
+      expect(functions).toHaveLength(2)
+      expect(functions.map(f => f.name).sort()).toEqual([
+        'handleSubmit',
+        'validateInput',
+      ])
+    })
+
+    it('should extract inline arrow functions passed as arguments', () => {
+      const project = createTestProject({
+        '/src/router.ts': `
+          import { createRouter } from './trpc'
+
+          export const userRouter = createRouter({
+            getUser: query(async ({ ctx, input }) => {
+              const userId = input.id
+              const user = await ctx.db.user.findUnique({ where: { id: userId } })
+              const formatted = formatUser(user)
+              return formatted
+            }),
+
+            updateUser: mutation(async ({ ctx, input }) => {
+              const validated = validateInput(input)
+              const updated = await ctx.db.user.update({
+                where: { id: input.id },
+                data: validated,
+              })
+              return updated
+            }),
+          })
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/router.ts')
+
+      // Should find the two inline handlers (query and mutation)
+      expect(functions.length).toBeGreaterThanOrEqual(2)
+
+      // Check that we found handlers named after their method
+      const names = functions.map(f => f.name)
+      expect(names).toContain('query')
+      expect(names).toContain('mutation')
+    })
+
+    it('should extract class methods', () => {
+      const project = createTestProject({
+        '/src/class.ts': `
+          export class Calculator {
+            add(a: number, b: number): number {
+              const sum = a + b
+              const doubled = sum * 2
+              const result = doubled / 2
+              return result
+            }
+
+            async fetchAndAdd(url: string, b: number): Promise<number> {
+              const response = await fetch(url)
+              const data = await response.json()
+              const a = data.value
+              const result = a + b
+              return result
+            }
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/class.ts')
+
+      expect(functions).toHaveLength(2)
+      expect(
+        functions.some(f => f.kind === 'method' && f.classification === 'pure'),
+      ).toBe(true)
+      expect(
+        functions.some(
+          f => f.kind === 'method' && f.classification === 'impure',
+        ),
+      ).toBe(true)
+    })
+
+    it('should extract getters and setters', () => {
+      const project = createTestProject({
+        '/src/accessors.ts': `
+          export class Config {
+            private _value: string = ''
+
+            get value(): string {
+              console.log('Getting value')
+              return this._value
+            }
+
+            set value(newValue: string) {
+              this._value = newValue
+            }
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/accessors.ts')!
+      const functions = extractFunctions(sourceFile)
+
+      expect(functions.some(f => f.kind === 'getter')).toBe(true)
+      expect(functions.some(f => f.kind === 'setter')).toBe(true)
+    })
+  })
+
+  describe('full project scoring', () => {
+    it('should score a multi-file project', () => {
+      const project = createTestProject({
+        '/src/services/users.ts': `
+          export async function getUser(id: string) {
+            const whereClause = { id }
+            const user = await db.user.findFirst({ where: whereClause })
+            const result = user ? user : null
+            return result
+          }
+
+          export async function createUser(data: any) {
+            const userData = { ...data }
+            const created = await db.user.create({ data: userData })
+            const result = created
+            return result
+          }
+        `,
+        '/src/utils/math.ts': `
+          export function add(a: number, b: number): number {
+            const sum = a + b
+            const result = sum
+            const final = result
+            return final
+          }
+
+          export function multiply(a: number, b: number): number {
+            const product = a * b
+            const result = product
+            const final = result
+            return final
+          }
+
+          export function divide(a: number, b: number): number {
+            if (b === 0) throw new Error('Division by zero')
+            const quotient = a / b
+            const result = quotient
+            return result
+          }
+        `,
+        '/src/utils/format.ts': `
+          export function formatDate(date: Date): string {
+            const iso = date.toISOString()
+            const parts = iso.split('T')
+            const datePart = parts[0]
+            return datePart
+          }
+
+          export function formatCurrency(amount: number): string {
+            const fixed = amount.toFixed(2)
+            const formatted = \`$\${fixed}\`
+            const result = formatted
+            return result
+          }
+        `,
+      })
+
+      // Analyze each file
+      const servicesFunctions = analyzeSourceFile(
+        project,
+        '/src/services/users.ts',
+      )
+      const mathFunctions = analyzeSourceFile(project, '/src/utils/math.ts')
+      const formatFunctions = analyzeSourceFile(project, '/src/utils/format.ts')
+
+      // Score each file
+      const servicesScore = scoreFile(
+        '/src/services/users.ts',
+        servicesFunctions,
+      )
+      const mathScore = scoreFile('/src/utils/math.ts', mathFunctions)
+      const formatScore = scoreFile('/src/utils/format.ts', formatFunctions)
+
+      // Score directories
+      const servicesDir = scoreDirectory('/src/services', [servicesScore])
+      const utilsDir = scoreDirectory('/src/utils', [mathScore, formatScore])
+
+      // Score project
+      const projectScore = scoreProject([servicesDir, utilsDir], {
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      // Verify metrics
+      expect(projectScore.pureCount).toBe(5) // 3 math + 2 format
+      expect(projectScore.impureCount).toBe(2) // 2 services
+      expect(projectScore.purity).toBeCloseTo(71.43, 1) // 5/7
+
+      // Utils should have higher purity than services
+      expect(utilsDir.purity).toBe(100)
+      expect(servicesDir.purity).toBe(0)
+    })
+  })
+
+  describe('marker detection accuracy', () => {
+    it('should detect multiple marker types in one function', () => {
+      const project = createTestProject({
+        '/src/complex.ts': `
+          export async function complexOperation() {
+            console.log('Starting operation')
+
+            const config = process.env.CONFIG
+            const user = await db.user.findFirst({ where: { active: true } })
+            const external = await fetch('/api/data')
+
+            console.log('Operation complete')
+            return { config, user, external }
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/complex.ts')
+
+      expect(functions).toHaveLength(1)
+      const markers = functions[0]!.markers
+
+      const markerTypes = new Set(markers.map(m => m.type))
+      expect(markerTypes.has('console-log')).toBe(true)
+      expect(markerTypes.has('env-access')).toBe(true)
+      expect(markerTypes.has('database-call')).toBe(true)
+      expect(markerTypes.has('network-fetch')).toBe(true)
+      expect(markerTypes.has('await-expression')).toBe(true)
+    })
+
+    it('should detect queue and event operations', () => {
+      const project = createTestProject({
+        '/src/events.ts': `
+          export async function processJob(job: any) {
+            const data = job.data
+            const result = computeResult(data)
+            const notification = { type: 'notification', data: result }
+
+            await queue.enqueue(notification)
+            emitter.emit('job-complete', { jobId: job.id, result })
+
+            return result
+          }
+
+          function computeResult(data: any) {
+            const processed = true
+            const result = { processed, data }
+            const final = result
+            return final
+          }
+        `,
+      })
+
+      const functions = analyzeSourceFile(project, '/src/events.ts')
+
+      const processJob = functions.find(f => f.name === 'processJob')
+      expect(processJob?.classification).toBe('impure')
+      expect(processJob?.markers.some(m => m.type === 'queue-enqueue')).toBe(
+        true,
+      )
+      expect(processJob?.markers.some(m => m.type === 'event-emit')).toBe(true)
+
+      const computeResult = functions.find(f => f.name === 'computeResult')
+      expect(computeResult?.classification).toBe('pure')
+    })
+  })
+})