pnpm-catalog-updates 1.0.2 → 1.1.0

package/src/cli/commands/__tests__/aiCommand.test.ts

@@ -0,0 +1,161 @@
+/**
+ * AI Command Tests
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Use vi.hoisted to ensure mocks are available during vi.mock hoisting
+const mocks = vi.hoisted(() => ({
+  analyzeUpdates: vi.fn(),
+  getDetectionSummary: vi.fn(),
+  detectAvailableProviders: vi.fn(),
+  getBestProvider: vi.fn(),
+  cacheClear: vi.fn(),
+  cacheGetStats: vi.fn(),
+}))
+
+// Mock @pcu/utils
+vi.mock('@pcu/utils', () => ({
+  t: (key: string) => key,
+}))
+
+// Mock chalk
+vi.mock('chalk', () => ({
+  default: {
+    gray: (text: string) => text,
+    red: (text: string) => text,
+    blue: (text: string) => text,
+    yellow: (text: string) => text,
+    green: (text: string) => text,
+    cyan: (text: string) => text,
+  },
+}))
+
+// Mock @pcu/core - use class syntax for proper constructor mocking
+vi.mock('@pcu/core', () => {
+  // Create a proper class mock for AIDetector
+  const AIDetectorMock = vi.fn(function (this: Record<string, unknown>) {
+    this.getDetectionSummary = mocks.getDetectionSummary
+    this.detectAvailableProviders = mocks.detectAvailableProviders
+    this.getBestProvider = mocks.getBestProvider
+  })
+
+  // Create a proper class mock for AIAnalysisService
+  const AIAnalysisServiceMock = vi.fn(function (this: Record<string, unknown>) {
+    this.analyzeUpdates = mocks.analyzeUpdates
+  })
+
+  return {
+    AIAnalysisService: AIAnalysisServiceMock,
+    AIDetector: AIDetectorMock,
+    analysisCache: {
+      clear: mocks.cacheClear,
+      getStats: mocks.cacheGetStats,
+    },
+  }
+})
+
+// Import after mock setup
+const { AiCommand } = await import('../aiCommand.js')
+
+describe('AiCommand', () => {
+  let command: InstanceType<typeof AiCommand>
+  let consoleSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    // Set up default mock return values
+    mocks.analyzeUpdates.mockResolvedValue({
+      provider: 'rule-engine',
+      confidence: 0.85,
+      summary: 'Test analysis completed successfully',
+    })
+    mocks.getDetectionSummary.mockResolvedValue('AI Provider Summary:\n  - Claude: Available')
+    mocks.detectAvailableProviders.mockResolvedValue([
+      { name: 'Claude', available: true, priority: 1, path: '/usr/bin/claude' },
+      { name: 'Gemini', available: false, priority: 2 },
+      { name: 'Codex', available: false, priority: 3 },
+    ])
+    mocks.getBestProvider.mockResolvedValue({ name: 'Claude', available: true })
+    mocks.cacheGetStats.mockReturnValue({
+      totalEntries: 10,
+      hits: 8,
+      misses: 2,
+      hitRate: 0.8,
+    })
+
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    command = new AiCommand()
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    vi.resetAllMocks()
+  })
+
+  describe('execute', () => {
+    it('should show status by default', async () => {
+      await command.execute({})
+
+      expect(consoleSpy).toHaveBeenCalled()
+      expect(mocks.getDetectionSummary).toHaveBeenCalled()
+      expect(mocks.detectAvailableProviders).toHaveBeenCalled()
+    })
+
+    it('should clear cache when --clear-cache flag is set', async () => {
+      await command.execute({ clearCache: true })
+
+      expect(mocks.cacheClear).toHaveBeenCalled()
+      const calls = consoleSpy.mock.calls.flat().join(' ')
+      expect(calls).toContain('command.ai.cacheCleared')
+    })
+
+    it('should show cache stats when --cache-stats flag is set', async () => {
+      await command.execute({ cacheStats: true })
+
+      expect(mocks.cacheGetStats).toHaveBeenCalled()
+      const calls = consoleSpy.mock.calls.flat().join(' ')
+      expect(calls).toContain('command.ai.cacheStats')
+      expect(calls).toContain('command.ai.totalEntries')
+      expect(calls).toContain('command.ai.cacheHits')
+      expect(calls).toContain('command.ai.cacheMisses')
+    })
+
+    it('should run test when --test flag is set', async () => {
+      await command.execute({ test: true })
+
+      const calls = consoleSpy.mock.calls.flat().join(' ')
+      expect(calls).toContain('command.ai.testingAnalysis')
+    })
+
+    it('should show provider details in status', async () => {
+      await command.execute({ status: true })
+
+      expect(mocks.detectAvailableProviders).toHaveBeenCalled()
+      const calls = consoleSpy.mock.calls.flat().join(' ')
+      expect(calls).toContain('Claude')
+    })
+
+    it('should show best provider when available', async () => {
+      await command.execute({})
+
+      expect(mocks.getBestProvider).toHaveBeenCalled()
+      const calls = consoleSpy.mock.calls.flat().join(' ')
+      expect(calls).toContain('command.ai.bestProvider')
+    })
+  })
+
+  describe('getHelpText', () => {
+    it('should return help text with all options', () => {
+      const helpText = AiCommand.getHelpText()
+
+      expect(helpText).toContain('Check AI provider status')
+      expect(helpText).toContain('--status')
+      expect(helpText).toContain('--test')
+      expect(helpText).toContain('--cache-stats')
+      expect(helpText).toContain('--clear-cache')
+    })
+  })
+})

package/src/cli/commands/__tests__/analyzeCommand.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Analyze Command Tests
+ */
+
+import type { CatalogUpdateService, WorkspaceService } from '@pcu/core'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Use vi.hoisted to ensure mocks are available during vi.mock hoisting
+const mocks = vi.hoisted(() => ({
+  analyzeUpdates: vi.fn(),
+  getLatestVersion: vi.fn(),
+  loadConfig: vi.fn(),
+  // Create a chainable chalk mock that supports all color combinations
+  createChalkMock: () => {
+    const createColorFn = (text: string) => text
+    const colorFn = Object.assign(createColorFn, {
+      bold: Object.assign((text: string) => text, {
+        cyan: (text: string) => text,
+        white: (text: string) => text,
+      }),
+      dim: Object.assign((text: string) => text, {
+        white: (text: string) => text,
+      }),
+      red: Object.assign((text: string) => text, {
+        bold: (text: string) => text,
+      }),
+      green: (text: string) => text,
+      yellow: (text: string) => text,
+      blue: (text: string) => text,
+      gray: (text: string) => text,
+      cyan: (text: string) => text,
+      white: (text: string) => text,
+    })
+    return colorFn
+  },
+}))
+
+// Mock @pcu/utils
+vi.mock('@pcu/utils', () => ({
+  logger: {
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+  },
+  Logger: {
+    setGlobalLevel: vi.fn(),
+  },
+  ConfigLoader: {
+    loadConfig: mocks.loadConfig,
+  },
+  t: (key: string, params?: Record<string, unknown>) => {
+    if (params) {
+      let result = key
+      for (const [k, v] of Object.entries(params)) {
+        result = result.replace(`{{${k}}}`, String(v))
+      }
+      return result
+    }
+    return key
+  },
+  // Include async utilities
+  timeout: vi.fn().mockImplementation((promise: Promise<unknown>) => promise),
+  delay: vi.fn().mockResolvedValue(undefined),
+  retry: vi.fn().mockImplementation((fn: () => Promise<unknown>) => fn()),
+}))
+
+// Mock chalk with chainable functions
+vi.mock('chalk', () => ({
+  default: mocks.createChalkMock(),
+}))
+
+// Mock @pcu/core - use class syntax for proper constructor mocking
+vi.mock('@pcu/core', async (importOriginal) => {
+  const actual = await importOriginal()
+
+  // Create a proper class mock for AIAnalysisService
+  const AIAnalysisServiceMock = vi.fn(function (this: Record<string, unknown>) {
+    this.analyzeUpdates = mocks.analyzeUpdates
+  })
+
+  // Create a proper class mock for NpmRegistryService
+  const NpmRegistryServiceMock = vi.fn(function (this: Record<string, unknown>) {
+    this.getLatestVersion = mocks.getLatestVersion
+  })
+
+  return {
+    ...(actual as object),
+    AIAnalysisService: AIAnalysisServiceMock,
+    NpmRegistryService: NpmRegistryServiceMock,
+  }
+})
+
+// Import after mock setup
+const { AnalyzeCommand } = await import('../analyzeCommand.js')
+
+describe('AnalyzeCommand', () => {
+  let command: InstanceType<typeof AnalyzeCommand>
+  let mockCatalogUpdateService: CatalogUpdateService
+  let mockWorkspaceService: WorkspaceService
+  let consoleSpy: ReturnType<typeof vi.spyOn>
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    // Set up default mock return values for hoisted mocks
+    mocks.analyzeUpdates.mockResolvedValue({
+      provider: 'rule-engine',
+      confidence: 0.85,
+      summary: 'Test analysis summary',
+      recommendations: ['Recommendation 1'],
+      risks: [],
+    })
+    mocks.getLatestVersion.mockResolvedValue({ toString: () => '4.17.21' })
+    mocks.loadConfig.mockResolvedValue({
+      defaults: { format: 'table' },
+    })
+
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    // Create mock catalog update service
+    mockCatalogUpdateService = {
+      findCatalogForPackage: vi.fn().mockResolvedValue('default'),
+      analyzeImpact: vi.fn().mockResolvedValue({
+        catalogName: 'default',
+        packageName: 'lodash',
+        currentVersion: '4.17.20',
+        proposedVersion: '4.17.21',
+        updateType: 'patch',
+        affectedPackages: ['package-a', 'package-b'],
+        breakingChanges: [],
+        recommendations: ['Safe to update'],
+        riskLevel: 'low',
+        securityImpact: {
+          resolvedVulnerabilities: [],
+          newVulnerabilities: [],
+        },
+      }),
+      checkOutdatedDependencies: vi.fn(),
+      planUpdates: vi.fn(),
+      executeUpdates: vi.fn(),
+    } as unknown as CatalogUpdateService
+
+    // Create mock workspace service
+    mockWorkspaceService = {
+      getWorkspaceInfo: vi.fn().mockResolvedValue({
+        path: '/test/workspace',
+        name: 'test-workspace',
+        isValid: true,
+        hasPackages: true,
+        hasCatalogs: true,
+        packageCount: 5,
+        catalogCount: 2,
+        catalogNames: ['default', 'react17'],
+      }),
+      discoverWorkspace: vi.fn(),
+      validateWorkspace: vi.fn(),
+      getWorkspaceStats: vi.fn(),
+      getCatalogs: vi.fn(),
+      getPackages: vi.fn(),
+      usesCatalogs: vi.fn(),
+      getPackagesUsingCatalog: vi.fn(),
+      findWorkspaces: vi.fn(),
+      checkHealth: vi.fn(),
+    } as unknown as WorkspaceService
+
+    command = new AnalyzeCommand(mockCatalogUpdateService, mockWorkspaceService)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
+    consoleWarnSpy.mockRestore()
+    vi.resetAllMocks()
+  })
+
+  describe('execute', () => {
+    it('should auto-detect catalog when not specified', async () => {
+      await command.execute('lodash', undefined, {})
+
+      expect(mockCatalogUpdateService.findCatalogForPackage).toHaveBeenCalledWith(
+        'lodash',
+        undefined
+      )
+    })
+
+    it('should use specified catalog', async () => {
+      await command.execute('lodash', undefined, { catalog: 'default' })
+
+      expect(mockCatalogUpdateService.findCatalogForPackage).not.toHaveBeenCalled()
+      expect(mockCatalogUpdateService.analyzeImpact).toHaveBeenCalledWith(
+        'default',
+        'lodash',
+        expect.any(String),
+        undefined
+      )
+    })
+
+    it('should throw error when package not found in any catalog', async () => {
+      mockCatalogUpdateService.findCatalogForPackage = vi.fn().mockResolvedValue(null)
+
+      await expect(command.execute('unknown-package', undefined, {})).rejects.toThrow(
+        'command.analyze.notFoundInCatalog'
+      )
+    })
+
+    it('should use specified version when provided', async () => {
+      await command.execute('lodash', '4.18.0', { catalog: 'default' })
+
+      expect(mockCatalogUpdateService.analyzeImpact).toHaveBeenCalledWith(
+        'default',
+        'lodash',
+        '4.18.0',
+        undefined
+      )
+    })
+
+    it('should fetch latest version when not specified', async () => {
+      await command.execute('lodash', undefined, { catalog: 'default' })
+
+      // The version should be fetched from NpmRegistryService
+      expect(mockCatalogUpdateService.analyzeImpact).toHaveBeenCalled()
+    })
+
+    it('should run AI analysis by default', async () => {
+      await command.execute('lodash', '4.17.21', { catalog: 'default' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+    })
+
+    it('should skip AI analysis when --no-ai is set', async () => {
+      await command.execute('lodash', '4.17.21', { catalog: 'default', ai: false })
+
+      expect(mockCatalogUpdateService.analyzeImpact).toHaveBeenCalled()
+    })
+
+    it('should use specified workspace path', async () => {
+      await command.execute('lodash', '4.17.21', {
+        catalog: 'default',
+        workspace: '/custom/workspace',
+      })
+
+      expect(mockWorkspaceService.getWorkspaceInfo).toHaveBeenCalledWith('/custom/workspace')
+    })
+  })
+
+  describe('validateArgs', () => {
+    it('should return error for empty package name', () => {
+      const errors = AnalyzeCommand.validateArgs('')
+
+      expect(errors).toContain('validation.packageNameRequired')
+    })
+
+    it('should return error for whitespace-only package name', () => {
+      const errors = AnalyzeCommand.validateArgs('   ')
+
+      expect(errors).toContain('validation.packageNameRequired')
+    })
+
+    it('should return no errors for valid package name', () => {
+      const errors = AnalyzeCommand.validateArgs('lodash')
+
+      expect(errors).toHaveLength(0)
+    })
+  })
+
+  describe('getHelpText', () => {
+    it('should return help text with all options', () => {
+      const helpText = AnalyzeCommand.getHelpText()
+
+      expect(helpText).toContain('Analyze the impact')
+      expect(helpText).toContain('--catalog')
+      expect(helpText).toContain('--format')
+      expect(helpText).toContain('--no-ai')
+      expect(helpText).toContain('--provider')
+      expect(helpText).toContain('--analysis-type')
+    })
+  })
+})