fcis 0.1.0

package/tests/detect-markers.test.ts

@@ -0,0 +1,639 @@
+/**
+ * Marker Detection Tests
+ *
+ * Tests for the pure core marker detection logic.
+ * These tests verify that impurity markers are correctly detected
+ * from extracted function data.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import {
+  detectMarkers,
+  createDetectionContext,
+} from '../src/detection/detect-markers.js'
+import type {
+  ExtractedFunction,
+  FileImports,
+  DetectionContext,
+} 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 minimal detection context
+ */
+function createTestContext(
+  imports: FileImports['imports'] = [],
+): DetectionContext {
+  return createDetectionContext({
+    filePath: '/test/file.ts',
+    imports,
+  })
+}
+
+describe('detectMarkers', () => {
+  describe('await-expression detection', () => {
+    it('should detect await expressions', () => {
+      const fn = createTestFunction({
+        hasAwait: true,
+        callSites: [{ expression: 'fetchData', line: 5, isAwaited: true }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'await-expression',
+          detail: expect.stringContaining('fetchData'),
+        }),
+      )
+    })
+
+    it('should not detect markers for async without await', () => {
+      const fn = createTestFunction({
+        isAsync: true,
+        hasAwait: false,
+        callSites: [{ expression: 'someFunction', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers.filter(m => m.type === 'await-expression')).toHaveLength(0)
+    })
+
+    it('should detect multiple await expressions', () => {
+      const fn = createTestFunction({
+        hasAwait: true,
+        callSites: [
+          { expression: 'fetchUser', line: 2, isAwaited: true },
+          { expression: 'fetchPosts', line: 5, isAwaited: true },
+          { expression: 'transform', line: 8, isAwaited: false },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+      const awaitMarkers = markers.filter(m => m.type === 'await-expression')
+
+      expect(awaitMarkers).toHaveLength(2)
+    })
+  })
+
+  describe('database-call detection', () => {
+    it('should detect db.entity.operation calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'db.user.findFirst', line: 3, isAwaited: true },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'database-call',
+          detail: 'db.user.findFirst',
+        }),
+      )
+    })
+
+    it('should detect prisma.entity.operation calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'prisma.post.create', line: 5, isAwaited: true },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'database-call',
+          detail: 'prisma.post.create',
+        }),
+      )
+    })
+
+    it('should detect ctx.db.entity.operation calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'ctx.db.user.findMany', line: 3, isAwaited: true },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'database-call',
+          detail: 'ctx.db.user.findMany',
+        }),
+      )
+    })
+
+    it('should detect various database operations', () => {
+      const operations = [
+        'findFirst',
+        'findMany',
+        'findUnique',
+        'create',
+        'update',
+        'delete',
+        'upsert',
+        'count',
+        'aggregate',
+        'groupBy',
+      ]
+
+      for (const op of operations) {
+        const fn = createTestFunction({
+          callSites: [
+            { expression: `db.user.${op}`, line: 1, isAwaited: false },
+          ],
+        })
+        const context = createTestContext()
+
+        const markers = detectMarkers(fn, context)
+
+        expect(markers).toContainEqual(
+          expect.objectContaining({
+            type: 'database-call',
+          }),
+        )
+      }
+    })
+
+    it('should not detect non-database calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'user.findFirst', line: 1, isAwaited: false },
+          { expression: 'array.find', line: 2, isAwaited: false },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers.filter(m => m.type === 'database-call')).toHaveLength(0)
+    })
+  })
+
+  describe('network-fetch detection', () => {
+    it('should detect fetch calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'fetch', line: 5, isAwaited: true }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'network-fetch',
+          detail: 'fetch',
+        }),
+      )
+    })
+  })
+
+  describe('network-http detection', () => {
+    it('should detect axios calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'axios.get', line: 3, isAwaited: true }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'network-http',
+          detail: 'axios.get',
+        }),
+      )
+    })
+
+    it('should NOT mark function as impure just because file imports axios', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'Object.entries', line: 2, isAwaited: false },
+        ],
+      })
+      const context = createTestContext([
+        { moduleSpecifier: 'axios', namedImports: ['axios'] },
+      ])
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers.filter(m => m.type === 'network-http')).toHaveLength(0)
+    })
+  })
+
+  describe('fs-call detection', () => {
+    it('should NOT mark function as impure just because file imports fs', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'Object.entries', line: 2, isAwaited: false },
+        ],
+      })
+      const context = createTestContext([
+        { moduleSpecifier: 'fs', namedImports: ['readFile'] },
+      ])
+
+      const markers = detectMarkers(fn, context)
+
+      expect(
+        markers.filter(m => m.type === 'fs-import' || m.type === 'fs-call'),
+      ).toHaveLength(0)
+    })
+
+    it('should detect fs.readFile calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'fs.readFile', line: 5, isAwaited: true }],
+      })
+      const context = createTestContext([
+        { moduleSpecifier: 'fs', namedImports: ['readFile'] },
+      ])
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'fs-call',
+          detail: 'fs.readFile',
+        }),
+      )
+    })
+
+    it('should detect readFile calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'readFile', line: 5, isAwaited: true }],
+      })
+      const context = createTestContext([
+        { moduleSpecifier: 'fs/promises', namedImports: ['readFile'] },
+      ])
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'fs-call',
+          detail: 'readFile',
+        }),
+      )
+    })
+  })
+
+  describe('env-access detection', () => {
+    it('should detect process.env access', () => {
+      const fn = createTestFunction({
+        propertyAccessChains: ['process.env.NODE_ENV'],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'env-access',
+          detail: 'process.env.NODE_ENV',
+        }),
+      )
+    })
+
+    it('should detect multiple env accesses', () => {
+      const fn = createTestFunction({
+        propertyAccessChains: [
+          'process.env.NODE_ENV',
+          'process.env.API_KEY',
+          'process.env.DATABASE_URL',
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+      const envMarkers = markers.filter(m => m.type === 'env-access')
+
+      expect(envMarkers).toHaveLength(3)
+    })
+  })
+
+  describe('console-log detection', () => {
+    it('should detect console.log calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'console.log', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'console-log',
+          detail: 'console.log',
+        }),
+      )
+    })
+
+    it('should detect console.error calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'console.error', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'console-log',
+          detail: 'console.error',
+        }),
+      )
+    })
+
+    it('should detect console.warn calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'console.warn', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'console-log',
+        }),
+      )
+    })
+  })
+
+  describe('logging detection', () => {
+    it('should detect logger calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'logger.info', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'logging',
+          detail: 'logger.info',
+        }),
+      )
+    })
+
+    it('should NOT mark function as impure just because file imports logger', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'Object.entries', line: 2, isAwaited: false },
+        ],
+      })
+      const context = createTestContext([
+        { moduleSpecifier: '@sai/logger', namedImports: ['log'] },
+      ])
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers.filter(m => m.type === 'logging')).toHaveLength(0)
+    })
+
+    it('should mark function as impure when it calls log()', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'log', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext([
+        { moduleSpecifier: '@sai/logger', namedImports: ['log'] },
+      ])
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({ type: 'logging' }),
+      )
+    })
+  })
+
+  describe('telemetry detection', () => {
+    it('should detect trackEvent calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'trackEvent', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'telemetry',
+          detail: 'trackEvent',
+        }),
+      )
+    })
+
+    it('should detect analytics calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'analytics.track', line: 5, isAwaited: false },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'telemetry',
+        }),
+      )
+    })
+  })
+
+  describe('queue-enqueue detection', () => {
+    it('should detect queue.enqueue calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'queue.enqueue', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'queue-enqueue',
+          detail: 'queue.enqueue',
+        }),
+      )
+    })
+
+    it('should detect jobQueue.add calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'jobQueue.add', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'queue-enqueue',
+        }),
+      )
+    })
+  })
+
+  describe('event-emit detection', () => {
+    it('should detect emit calls', () => {
+      const fn = createTestFunction({
+        callSites: [{ expression: 'emitter.emit', line: 5, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'event-emit',
+          detail: 'emitter.emit',
+        }),
+      )
+    })
+
+    it('should detect dispatch calls', () => {
+      const fn = createTestFunction({
+        callSites: [
+          { expression: 'eventBus.dispatch', line: 5, isAwaited: false },
+        ],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toContainEqual(
+        expect.objectContaining({
+          type: 'event-emit',
+        }),
+      )
+    })
+  })
+
+  describe('pure functions', () => {
+    it('should return no markers for a pure function', () => {
+      const fn = createTestFunction({
+        name: 'calculateSum',
+        callSites: [
+          { expression: 'Math.max', line: 2, isAwaited: false },
+          { expression: 'array.reduce', line: 3, isAwaited: false },
+        ],
+        propertyAccessChains: ['Math.PI'],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toHaveLength(0)
+    })
+
+    it('should return no markers for async function without I/O', () => {
+      const fn = createTestFunction({
+        name: 'asyncPureFunction',
+        isAsync: true,
+        hasAwait: false,
+        callSites: [{ expression: 'transform', line: 2, isAwaited: false }],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      expect(markers).toHaveLength(0)
+    })
+  })
+
+  describe('multiple markers', () => {
+    it('should detect multiple different marker types', () => {
+      const fn = createTestFunction({
+        hasAwait: true,
+        callSites: [
+          { expression: 'db.user.findFirst', line: 2, isAwaited: true },
+          { expression: 'fetch', line: 5, isAwaited: true },
+          { expression: 'console.log', line: 8, isAwaited: false },
+        ],
+        propertyAccessChains: ['process.env.API_URL'],
+      })
+      const context = createTestContext()
+
+      const markers = detectMarkers(fn, context)
+
+      const markerTypes = new Set(markers.map(m => m.type))
+
+      expect(markerTypes.has('await-expression')).toBe(true)
+      expect(markerTypes.has('database-call')).toBe(true)
+      expect(markerTypes.has('network-fetch')).toBe(true)
+      expect(markerTypes.has('console-log')).toBe(true)
+      expect(markerTypes.has('env-access')).toBe(true)
+    })
+  })
+})
+
+describe('createDetectionContext', () => {
+  it('should identify pure file imports', () => {
+    const imports: FileImports = {
+      filePath: '/test/file.ts',
+      imports: [
+        { moduleSpecifier: './utils.pure', namedImports: ['calculateTotal'] },
+        { moduleSpecifier: './helpers', namedImports: ['formatDate'] },
+      ],
+    }
+
+    const context = createDetectionContext(imports)
+
+    expect(context.pureFileImports.has('./utils.pure')).toBe(true)
+    expect(context.pureFileImports.has('./helpers')).toBe(false)
+  })
+
+  it('should handle imports from .pure subdirectories', () => {
+    const imports: FileImports = {
+      filePath: '/test/file.ts',
+      imports: [
+        {
+          moduleSpecifier: './domain.pure/calculations',
+          namedImports: ['compute'],
+        },
+      ],
+    }
+
+    const context = createDetectionContext(imports)
+
+    expect(context.pureFileImports.has('./domain.pure/calculations')).toBe(true)
+  })
+})