pnpm-catalog-updates 1.0.3 → 1.1.0

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

@@ -0,0 +1,312 @@
+/**
+ * Graph Command Tests
+ */
+
+import type { WorkspaceService } from '@pcu/core'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { GraphFormat, GraphType } from '../graphCommand.js'
+
+// Use vi.hoisted for mock values
+const mocks = vi.hoisted(() => ({
+  cliOutputPrint: vi.fn(),
+  getCatalogs: vi.fn(),
+  getPackages: vi.fn(),
+}))
+
+// Mock @pcu/utils
+vi.mock('@pcu/utils', () => ({
+  CommandExitError: class CommandExitError extends Error {
+    exitCode: number
+    constructor(message: string, exitCode = 0) {
+      super(message)
+      this.exitCode = exitCode
+    }
+    static success() {
+      return new CommandExitError('success', 0)
+    }
+  },
+}))
+
+// Mock cliOutput
+vi.mock('../../utils/cliOutput.js', () => ({
+  cliOutput: {
+    print: mocks.cliOutputPrint,
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+  },
+}))
+
+// Mock validators
+vi.mock('../../validators/index.js', () => ({
+  errorsOnly: (fn: (opts: unknown) => { errors: string[] }) => (opts: unknown) => fn(opts).errors,
+  validateGraphOptions: (opts: { format?: string; type?: string }) => {
+    const errors: string[] = []
+    if (opts.format && !['text', 'mermaid', 'dot', 'json'].includes(opts.format)) {
+      errors.push(`Invalid format: ${opts.format}`)
+    }
+    if (opts.type && !['catalog', 'package', 'full'].includes(opts.type)) {
+      errors.push(`Invalid type: ${opts.type}`)
+    }
+    return { errors, warnings: [] }
+  },
+}))
+
+// Import after mock setup
+const { GraphCommand } = await import('../graphCommand.js')
+
+describe('GraphCommand', () => {
+  let command: InstanceType<typeof GraphCommand>
+  let mockWorkspaceService: {
+    getCatalogs: ReturnType<typeof vi.fn>
+    getPackages: ReturnType<typeof vi.fn>
+  }
+
+  const mockCatalogs = [
+    {
+      name: 'default',
+      packageCount: 3,
+      mode: 'default',
+      packages: ['react', 'lodash', 'typescript'],
+    },
+    {
+      name: 'dev',
+      packageCount: 2,
+      mode: 'dev',
+      packages: ['vitest', 'eslint'],
+    },
+  ]
+
+  const mockPackages = [
+    {
+      name: 'app',
+      path: 'packages/app',
+      dependencies: [
+        { name: 'react', type: 'dependencies', isCatalogReference: true },
+        { name: 'lodash', type: 'dependencies', isCatalogReference: true },
+      ],
+      catalogReferences: [{ catalogName: 'default', dependencyType: 'dependencies' }],
+    },
+    {
+      name: 'utils',
+      path: 'packages/utils',
+      dependencies: [{ name: 'typescript', type: 'devDependencies', isCatalogReference: true }],
+      catalogReferences: [{ catalogName: 'dev', dependencyType: 'devDependencies' }],
+    },
+  ]
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    mockWorkspaceService = {
+      getCatalogs: mocks.getCatalogs,
+      getPackages: mocks.getPackages,
+    }
+
+    mocks.getCatalogs.mockResolvedValue(mockCatalogs)
+    mocks.getPackages.mockResolvedValue(mockPackages)
+
+    command = new GraphCommand(mockWorkspaceService as unknown as WorkspaceService)
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  describe('execute', () => {
+    it('should output text format by default', async () => {
+      await expect(command.execute({})).rejects.toThrow('success')
+
+      expect(mocks.cliOutputPrint).toHaveBeenCalled()
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toContain('Catalog Dependency Graph')
+      expect(output).toContain('Catalogs:')
+    })
+
+    it('should output mermaid format when specified', async () => {
+      await expect(command.execute({ format: 'mermaid' })).rejects.toThrow('success')
+
+      expect(mocks.cliOutputPrint).toHaveBeenCalled()
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toContain('```mermaid')
+      expect(output).toContain('graph TD')
+      expect(output).toContain('```')
+    })
+
+    it('should output dot format when specified', async () => {
+      await expect(command.execute({ format: 'dot' })).rejects.toThrow('success')
+
+      expect(mocks.cliOutputPrint).toHaveBeenCalled()
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toContain('digraph CatalogDependencies')
+      expect(output).toContain('rankdir=TB')
+    })
+
+    it('should output json format when specified', async () => {
+      await expect(command.execute({ format: 'json' })).rejects.toThrow('success')
+
+      expect(mocks.cliOutputPrint).toHaveBeenCalled()
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      const parsed = JSON.parse(output)
+      expect(parsed).toHaveProperty('nodes')
+      expect(parsed).toHaveProperty('edges')
+    })
+
+    it('should build catalog graph type by default', async () => {
+      await expect(command.execute({ format: 'json' })).rejects.toThrow('success')
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      const parsed = JSON.parse(output)
+
+      const catalogNodes = parsed.nodes.filter((n: { type: string }) => n.type === 'catalog')
+      expect(catalogNodes.length).toBe(2)
+      expect(catalogNodes.map((n: { name: string }) => n.name)).toContain('default')
+      expect(catalogNodes.map((n: { name: string }) => n.name)).toContain('dev')
+    })
+
+    it('should build package graph type when specified', async () => {
+      await expect(command.execute({ format: 'json', type: 'package' })).rejects.toThrow('success')
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      const parsed = JSON.parse(output)
+
+      const packageNodes = parsed.nodes.filter((n: { type: string }) => n.type === 'package')
+      expect(packageNodes.length).toBe(2)
+      expect(packageNodes.map((n: { name: string }) => n.name)).toContain('app')
+      expect(packageNodes.map((n: { name: string }) => n.name)).toContain('utils')
+    })
+
+    it('should build full graph type when specified', async () => {
+      await expect(command.execute({ format: 'json', type: 'full' })).rejects.toThrow('success')
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      const parsed = JSON.parse(output)
+
+      const catalogNodes = parsed.nodes.filter((n: { type: string }) => n.type === 'catalog')
+      const packageNodes = parsed.nodes.filter((n: { type: string }) => n.type === 'package')
+      expect(catalogNodes.length).toBeGreaterThan(0)
+      expect(packageNodes.length).toBeGreaterThan(0)
+    })
+
+    it('should filter by catalog when specified', async () => {
+      await expect(command.execute({ format: 'json', catalog: 'default' })).rejects.toThrow(
+        'success'
+      )
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      const parsed = JSON.parse(output)
+
+      const catalogNodes = parsed.nodes.filter((n: { type: string }) => n.type === 'catalog')
+      expect(catalogNodes.length).toBe(1)
+      expect(catalogNodes[0].name).toBe('default')
+    })
+
+    it('should fetch catalogs and packages in parallel', async () => {
+      await expect(command.execute({})).rejects.toThrow('success')
+
+      expect(mocks.getCatalogs).toHaveBeenCalled()
+      expect(mocks.getPackages).toHaveBeenCalled()
+    })
+
+    it('should handle empty catalogs', async () => {
+      mocks.getCatalogs.mockResolvedValue([])
+      mocks.getPackages.mockResolvedValue([])
+
+      await expect(command.execute({ format: 'json' })).rejects.toThrow('success')
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      const parsed = JSON.parse(output)
+      expect(parsed.nodes).toEqual([])
+      expect(parsed.edges).toEqual([])
+    })
+
+    it('should respect color option in text format', async () => {
+      await expect(command.execute({ format: 'text', color: false })).rejects.toThrow('success')
+
+      expect(mocks.cliOutputPrint).toHaveBeenCalled()
+      // With color=false, output should not contain ANSI escape codes
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).not.toMatch(/\x1b\[/)
+    })
+  })
+
+  describe('graph formatting', () => {
+    it('should generate valid mermaid syntax with node classes', async () => {
+      await expect(command.execute({ format: 'mermaid' })).rejects.toThrow('success')
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toContain('classDef catalog')
+      expect(output).toContain('classDef package')
+      expect(output).toContain('classDef dependency')
+    })
+
+    it('should generate valid DOT syntax with node styles', async () => {
+      await expect(command.execute({ format: 'dot' })).rejects.toThrow('success')
+
+      const output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toContain('shape=box')
+      expect(output).toContain('fillcolor=')
+    })
+
+    it('should include edge relationships in all formats', async () => {
+      // Test mermaid edges
+      await expect(command.execute({ format: 'mermaid', type: 'full' })).rejects.toThrow('success')
+      let output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toMatch(/--->/i) // contains arrow
+
+      // Test dot edges
+      mocks.cliOutputPrint.mockClear()
+      await expect(command.execute({ format: 'dot', type: 'full' })).rejects.toThrow('success')
+      output = mocks.cliOutputPrint.mock.calls[0][0]
+      expect(output).toContain('->')
+    })
+  })
+
+  describe('validateOptions', () => {
+    it('should return empty array for valid options', () => {
+      const errors = GraphCommand.validateOptions({
+        format: 'json',
+        type: 'catalog',
+      })
+      expect(errors).toEqual([])
+    })
+
+    it('should return error for invalid format', () => {
+      const errors = GraphCommand.validateOptions({
+        format: 'invalid' as GraphFormat,
+      })
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0]).toContain('format')
+    })
+
+    it('should return error for invalid type', () => {
+      const errors = GraphCommand.validateOptions({
+        type: 'invalid' as GraphType,
+      })
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0]).toContain('type')
+    })
+  })
+
+  describe('getHelpText', () => {
+    it('should return help text with all options', () => {
+      const helpText = GraphCommand.getHelpText()
+
+      expect(helpText).toContain('Visualize catalog dependency relationships')
+      expect(helpText).toContain('--format')
+      expect(helpText).toContain('--type')
+      expect(helpText).toContain('--catalog')
+      expect(helpText).toContain('text')
+      expect(helpText).toContain('mermaid')
+      expect(helpText).toContain('dot')
+      expect(helpText).toContain('json')
+    })
+
+    it('should include examples', () => {
+      const helpText = GraphCommand.getHelpText()
+
+      expect(helpText).toContain('Examples:')
+      expect(helpText).toContain('pcu graph')
+    })
+  })
+})

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

@@ -0,0 +1,317 @@
+/**
+ * Init Command Tests
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Mock node:fs
+const fsMocks = vi.hoisted(() => ({
+  existsSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}))
+
+vi.mock('node:fs', () => ({
+  existsSync: fsMocks.existsSync,
+  mkdirSync: fsMocks.mkdirSync,
+  writeFileSync: fsMocks.writeFileSync,
+}))
+
+// Mock @pcu/utils
+vi.mock('@pcu/utils', () => ({
+  CommandExitError: class CommandExitError extends Error {
+    code: number
+    constructor(message: string, code = 1) {
+      super(message)
+      this.code = code
+    }
+    static success() {
+      const err = new CommandExitError('Success', 0)
+      return err
+    }
+    static failure(message: string) {
+      return new CommandExitError(message, 1)
+    }
+  },
+  logger: {
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+  },
+  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
+  },
+}))
+
+// Mock theme module
+vi.mock('../../themes/colorTheme.js', () => ({
+  ThemeManager: {
+    setTheme: vi.fn(),
+  },
+  StyledText: {
+    iconInfo: (text: string) => `[info] ${text}`,
+    iconSuccess: (text: string) => `[success] ${text}`,
+    iconWarning: (text: string) => `[warning] ${text}`,
+    iconError: (text: string) => `[error] ${text}`,
+    muted: (text: string) => `[muted] ${text}`,
+    warning: (text: string) => `[warning] ${text}`,
+  },
+}))
+
+// Mock cliOutput
+vi.mock('../../utils/cliOutput.js', () => ({
+  cliOutput: {
+    print: vi.fn(),
+    error: vi.fn(),
+  },
+}))
+
+// Mock command helpers
+vi.mock('../../utils/commandHelpers.js', () => ({
+  handleCommandError: vi.fn(),
+}))
+
+// Mock validators
+vi.mock('../../validators/index.js', () => ({
+  errorsOnly: () => () => [],
+  validateInitOptions: vi.fn(() => ({ valid: true, errors: [] })),
+}))
+
+// Import after mock setup
+const { InitCommand } = await import('../initCommand.js')
+const { CommandExitError } = await import('@pcu/utils')
+
+describe('InitCommand', () => {
+  let command: InstanceType<typeof InitCommand>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    command = new InitCommand()
+
+    // Default: files don't exist
+    fsMocks.existsSync.mockReturnValue(false)
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  describe('execute', () => {
+    it('should create configuration file in current directory by default', async () => {
+      // Mock workspace files exist
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('package.json')) return true
+        if (path.includes('pnpm-workspace.yaml')) return true
+        if (path.includes('.pcurc.json')) return false
+        return false
+      })
+
+      await expect(command.execute({})).rejects.toThrow()
+
+      // Should write config file
+      expect(fsMocks.writeFileSync).toHaveBeenCalled()
+      const writeCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes('.pcurc.json')
+      )
+      expect(writeCall).toBeDefined()
+    })
+
+    it('should create workspace structure when missing', async () => {
+      // No files exist
+      fsMocks.existsSync.mockReturnValue(false)
+
+      await expect(command.execute({ verbose: true })).rejects.toThrow()
+
+      // Should create package.json
+      const packageJsonCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes('package.json')
+      )
+      expect(packageJsonCall).toBeDefined()
+
+      // Should create pnpm-workspace.yaml
+      const workspaceYamlCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes('pnpm-workspace.yaml')
+      )
+      expect(workspaceYamlCall).toBeDefined()
+
+      // Should create packages directory
+      expect(fsMocks.mkdirSync).toHaveBeenCalled()
+    })
+
+    it('should skip workspace creation when createWorkspace is false', async () => {
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('.pcurc.json')) return false
+        return false
+      })
+
+      await expect(command.execute({ createWorkspace: false })).rejects.toThrow()
+
+      // Should not create package.json or workspace yaml
+      const packageJsonCalls = fsMocks.writeFileSync.mock.calls.filter((call) =>
+        String(call[0]).includes('package.json')
+      )
+      expect(packageJsonCalls.length).toBe(0)
+    })
+
+    it('should fail if config file exists without force flag', async () => {
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('package.json')) return true
+        if (path.includes('pnpm-workspace.yaml')) return true
+        if (path.includes('.pcurc.json')) return true
+        return false
+      })
+
+      await expect(command.execute({})).rejects.toThrow()
+
+      // Should not overwrite existing config
+      const configWriteCalls = fsMocks.writeFileSync.mock.calls.filter((call) =>
+        String(call[0]).includes('.pcurc.json')
+      )
+      expect(configWriteCalls.length).toBe(0)
+    })
+
+    it('should overwrite config file when force flag is set', async () => {
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('package.json')) return true
+        if (path.includes('pnpm-workspace.yaml')) return true
+        if (path.includes('.pcurc.json')) return true
+        return false
+      })
+
+      await expect(command.execute({ force: true })).rejects.toThrow()
+
+      // Should overwrite config
+      const configWriteCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes('.pcurc.json')
+      )
+      expect(configWriteCall).toBeDefined()
+    })
+
+    it('should generate full configuration when full flag is set', async () => {
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('package.json')) return true
+        if (path.includes('pnpm-workspace.yaml')) return true
+        if (path.includes('.pcurc.json')) return false
+        return false
+      })
+
+      await expect(command.execute({ full: true })).rejects.toThrow()
+
+      // Should write config with full options
+      const configWriteCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes('.pcurc.json')
+      )
+      expect(configWriteCall).toBeDefined()
+
+      const configContent = JSON.parse(configWriteCall![1] as string)
+      // Full config should have packageRules, security, advanced, monorepo
+      expect(configContent.packageRules).toBeDefined()
+      expect(configContent.security).toBeDefined()
+      expect(configContent.advanced).toBeDefined()
+      expect(configContent.monorepo).toBeDefined()
+    })
+
+    it('should generate minimal configuration by default', async () => {
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('package.json')) return true
+        if (path.includes('pnpm-workspace.yaml')) return true
+        if (path.includes('.pcurc.json')) return false
+        return false
+      })
+
+      await expect(command.execute({})).rejects.toThrow()
+
+      const configWriteCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes('.pcurc.json')
+      )
+      expect(configWriteCall).toBeDefined()
+
+      const configContent = JSON.parse(configWriteCall![1] as string)
+      // Minimal config should have defaults but no packageRules
+      expect(configContent.defaults).toBeDefined()
+      expect(configContent.defaults.target).toBe('latest')
+      expect(configContent.defaults.createBackup).toBe(true)
+      expect(configContent.packageRules).toBeUndefined()
+    })
+
+    it('should use custom workspace path when provided', async () => {
+      const customPath = '/custom/workspace/path'
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes(customPath)) {
+          if (path.includes('package.json')) return true
+          if (path.includes('pnpm-workspace.yaml')) return true
+          if (path.includes('.pcurc.json')) return false
+        }
+        return false
+      })
+
+      await expect(command.execute({ workspace: customPath })).rejects.toThrow()
+
+      // Config should be written to custom path
+      const configWriteCall = fsMocks.writeFileSync.mock.calls.find((call) =>
+        String(call[0]).includes(customPath)
+      )
+      expect(configWriteCall).toBeDefined()
+    })
+
+    it('should create config directory if it does not exist', async () => {
+      fsMocks.existsSync.mockImplementation((path: string) => {
+        if (path.includes('package.json')) return true
+        if (path.includes('pnpm-workspace.yaml')) return true
+        // Config directory doesn't exist
+        return false
+      })
+
+      await expect(command.execute({})).rejects.toThrow()
+
+      // Should create directory
+      expect(fsMocks.mkdirSync).toHaveBeenCalled()
+    })
+  })
+
+  describe('validateOptions', () => {
+    it('should return empty array for valid options', () => {
+      const errors = InitCommand.validateOptions({})
+      expect(errors).toEqual([])
+    })
+  })
+
+  describe('getHelpText', () => {
+    it('should return help text with all options', () => {
+      const helpText = InitCommand.getHelpText()
+
+      expect(helpText).toContain('Initialize PCU configuration')
+      expect(helpText).toContain('--workspace')
+      expect(helpText).toContain('--force')
+      expect(helpText).toContain('--full')
+      expect(helpText).toContain('--create-workspace')
+      expect(helpText).toContain('--verbose')
+      expect(helpText).toContain('--no-color')
+    })
+
+    it('should include usage examples', () => {
+      const helpText = InitCommand.getHelpText()
+
+      expect(helpText).toContain('pcu init')
+      expect(helpText).toContain('pcu init --full')
+      expect(helpText).toContain('pcu init --force')
+    })
+
+    it('should describe created files', () => {
+      const helpText = InitCommand.getHelpText()
+
+      expect(helpText).toContain('.pcurc.json')
+      expect(helpText).toContain('package.json')
+      expect(helpText).toContain('pnpm-workspace.yaml')
+      expect(helpText).toContain('packages/')
+    })
+  })
+})