npq 3.10.1 → 3.10.2

package/__tests__/cli.test.js

@@ -1,110 +0,0 @@
-// __tests__/cli.test.js
-
-// Mock dependencies. These are hoisted by Jest.
-jest.mock('../lib/cli', () => ({
-  CliParser: {
-    parseArgsFull: jest.fn(),
-    exit: jest.fn()
-  }
-}))
-jest.mock('../lib/helpers/cliSupportHandler', () => ({
-  isEnvSupport: jest.fn().mockReturnValue(true),
-  isInteractiveTerminal: jest.fn(),
-  noSupportError: jest.fn()
-}))
-
-// Create a shared mock for the spinner instance that we can inspect in tests.
-const mockSpinnerInstance = {
-  start: jest.fn(),
-  stop: jest.fn()
-}
-jest.mock('../lib/helpers/cliSpinner', () => ({
-  // The Spinner property is a mock constructor that returns our shared mock instance.
-  Spinner: jest.fn().mockImplementation(() => mockSpinnerInstance)
-}))
-
-jest.mock('../lib/helpers/sourcePackages', () => ({
-  getProjectPackages: jest.fn().mockResolvedValue(['express'])
-}))
-jest.mock('../lib/marshall', () =>
-  jest.fn(() => ({
-    process: jest.fn().mockResolvedValue({})
-  }))
-)
-jest.mock('../lib/helpers/reportResults', () => ({
-  reportResults: jest.fn().mockReturnValue({ countErrors: 0, countWarnings: 0 })
-}))
-jest.mock('../lib/packageManager', () => ({
-  process: jest.fn()
-}))
-jest.mock('../lib/helpers/cliPrompt.js', () => ({
-  prompt: jest.fn().mockResolvedValue({ install: true }),
-  autoContinue: jest.fn().mockResolvedValue({ install: true })
-}))
-
-describe('npq CLI script', () => {
-  beforeEach(() => {
-    // Reset modules to ensure mocks are fresh for each test.
-    jest.resetModules()
-    // Clear mock history on the shared instance and the constructor.
-    const { Spinner } = require('../lib/helpers/cliSpinner')
-    mockSpinnerInstance.start.mockClear()
-    mockSpinnerInstance.stop.mockClear()
-    Spinner.mockClear()
-  })
-
-  test('should initialize and start spinner in interactive mode without --plain flag', async () => {
-    // Arrange
-    const { CliParser } = require('../lib/cli')
-    const { isInteractiveTerminal } = require('../lib/helpers/cliSupportHandler')
-    const { Spinner } = require('../lib/helpers/cliSpinner')
-
-    CliParser.parseArgsFull.mockReturnValue({ packages: ['express'], plain: false, dryRun: true })
-    isInteractiveTerminal.mockReturnValue(true)
-
-    // Act: Dynamically require the script to run it.
-    require('../bin/npq.js')
-    // Wait for async operations in the script to settle.
-    await new Promise(process.nextTick)
-
-    // Assert
-    expect(Spinner).toHaveBeenCalledTimes(1)
-    expect(mockSpinnerInstance.start).toHaveBeenCalledTimes(1)
-  })
-
-  test('should not initialize spinner when --plain flag is used', async () => {
-    // Arrange
-    const { CliParser } = require('../lib/cli')
-    const { isInteractiveTerminal } = require('../lib/helpers/cliSupportHandler')
-    const { Spinner } = require('../lib/helpers/cliSpinner')
-
-    CliParser.parseArgsFull.mockReturnValue({ packages: ['express'], plain: true, dryRun: true })
-    isInteractiveTerminal.mockReturnValue(true)
-
-    // Act
-    require('../bin/npq.js')
-    await new Promise(process.nextTick)
-
-    // Assert
-    expect(Spinner).not.toHaveBeenCalled()
-    expect(mockSpinnerInstance.start).not.toHaveBeenCalled()
-  })
-
-  test('should not initialize spinner in non-interactive mode', async () => {
-    // Arrange
-    const { CliParser } = require('../lib/cli')
-    const { isInteractiveTerminal } = require('../lib/helpers/cliSupportHandler')
-    const { Spinner } = require('../lib/helpers/cliSpinner')
-
-    CliParser.parseArgsFull.mockReturnValue({ packages: ['express'], plain: false, dryRun: true })
-    isInteractiveTerminal.mockReturnValue(false)
-
-    // Act
-    require('../bin/npq.js')
-    await new Promise(process.nextTick)
-
-    // Assert
-    expect(Spinner).not.toHaveBeenCalled()
-    expect(mockSpinnerInstance.start).not.toHaveBeenCalled()
-  })
-})

package/__tests__/cliPrompt.test.js

@@ -1,409 +0,0 @@
-const { prompt } = require('../lib/helpers/cliPrompt')
-const readline = require('node:readline/promises')
-
-// Mock readline module
-jest.mock('node:readline/promises', () => ({
-  createInterface: jest.fn()
-}))
-
-describe('cliPrompt', () => {
-  let mockRl
-
-  beforeEach(() => {
-    mockRl = {
-      question: jest.fn(),
-      close: jest.fn()
-    }
-    readline.createInterface.mockReturnValue(mockRl)
-
-    // Mock console.log to avoid output during tests
-    jest.spyOn(console, 'log').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks()
-    if (console.log.mockRestore) {
-      console.log.mockRestore()
-    }
-  })
-
-  describe('parameter validation', () => {
-    test('should throw error when message is missing', async () => {
-      await expect(prompt({ name: 'test' })).rejects.toThrow('Message is required for prompt')
-    })
-
-    test('should throw error when name is missing', async () => {
-      await expect(prompt({ message: 'Test message?' })).rejects.toThrow(
-        'Name is required for prompt'
-      )
-    })
-
-    test('should throw error when both name and message are missing', async () => {
-      await expect(prompt({})).rejects.toThrow('Message is required for prompt')
-    })
-  })
-
-  describe('successful prompts', () => {
-    test('should return true for "y" input', async () => {
-      mockRl.question.mockResolvedValue('y')
-
-      const result = await prompt({
-        name: 'install',
-        message: 'Do you want to install?'
-      })
-
-      expect(result).toEqual({ install: true })
-      expect(mockRl.question).toHaveBeenCalledWith('Do you want to install? (y/N) ')
-      expect(mockRl.close).toHaveBeenCalled()
-    })
-
-    test('should return true for "yes" input', async () => {
-      mockRl.question.mockResolvedValue('yes')
-
-      const result = await prompt({
-        name: 'confirm',
-        message: 'Are you sure?'
-      })
-
-      expect(result).toEqual({ confirm: true })
-    })
-
-    test('should return false for "n" input', async () => {
-      mockRl.question.mockResolvedValue('n')
-
-      const result = await prompt({
-        name: 'proceed',
-        message: 'Continue?'
-      })
-
-      expect(result).toEqual({ proceed: false })
-    })
-
-    test('should return false for "no" input', async () => {
-      mockRl.question.mockResolvedValue('no')
-
-      const result = await prompt({
-        name: 'delete',
-        message: 'Delete files?'
-      })
-
-      expect(result).toEqual({ delete: false })
-    })
-
-    test('should handle case-insensitive input', async () => {
-      mockRl.question.mockResolvedValue('YES')
-
-      const result = await prompt({
-        name: 'test',
-        message: 'Test?'
-      })
-
-      expect(result).toEqual({ test: true })
-    })
-
-    test('should trim whitespace from input', async () => {
-      mockRl.question.mockResolvedValue('  y  ')
-
-      const result = await prompt({
-        name: 'test',
-        message: 'Test?'
-      })
-
-      expect(result).toEqual({ test: true })
-    })
-  })
-
-  describe('default value handling', () => {
-    test('should use default false when user presses Enter', async () => {
-      mockRl.question.mockResolvedValue('')
-
-      const result = await prompt({
-        name: 'install',
-        message: 'Install package?'
-      })
-
-      expect(result).toEqual({ install: false })
-      expect(mockRl.question).toHaveBeenCalledWith('Install package? (y/N) ')
-    })
-
-    test('should use default true when specified and user presses Enter', async () => {
-      mockRl.question.mockResolvedValue('')
-
-      const result = await prompt({
-        name: 'continue',
-        message: 'Continue process?',
-        default: true
-      })
-
-      expect(result).toEqual({ continue: true })
-      expect(mockRl.question).toHaveBeenCalledWith('Continue process? (Y/n) ')
-    })
-
-    test('should show correct prompt indicators for default values', async () => {
-      mockRl.question.mockResolvedValue('y')
-
-      await prompt({
-        name: 'test',
-        message: 'Test with default false?',
-        default: false
-      })
-
-      expect(mockRl.question).toHaveBeenCalledWith('Test with default false? (y/N) ')
-    })
-  })
-
-  describe('invalid input handling', () => {
-    test('should log error message when invalid input is provided', () => {
-      // Test the logic path for invalid input without actual recursion
-      const invalidInputs = ['maybe', '1', 'true', 'false', 'ok', 'sure', 'xyz']
-
-      invalidInputs.forEach((input) => {
-        const normalized = input.trim().toLowerCase()
-        const isValidInput = ['y', 'yes', 'n', 'no'].includes(normalized)
-        expect(isValidInput).toBe(false)
-      })
-    })
-
-    test('should recognize valid inputs correctly', () => {
-      const validInputs = ['y', 'yes', 'n', 'no', 'Y', 'YES', 'N', 'NO', '  y  ', '  no  ']
-
-      validInputs.forEach((input) => {
-        const normalized = input.trim().toLowerCase()
-        const isValidInput = ['y', 'yes', 'n', 'no'].includes(normalized)
-        expect(isValidInput).toBe(true)
-      })
-    })
-
-    test('should handle invalid input and retry successfully', async () => {
-      // Create a mock that returns invalid input first, then valid input
-      let callCount = 0
-      mockRl.question.mockImplementation(() => {
-        callCount++
-        if (callCount === 1) {
-          return Promise.resolve('invalid')
-        }
-        return Promise.resolve('y')
-      })
-
-      // Mock the second readline interface creation for the retry
-      let interfaceCallCount = 0
-      const mockRl2 = {
-        question: jest.fn().mockResolvedValue('y'),
-        close: jest.fn()
-      }
-
-      readline.createInterface.mockImplementation(() => {
-        interfaceCallCount++
-        if (interfaceCallCount === 1) {
-          return mockRl
-        }
-        return mockRl2
-      })
-
-      const result = await prompt({
-        name: 'test',
-        message: 'Test?'
-      })
-
-      expect(console.log).toHaveBeenCalledWith('Please answer with y/yes or n/no.')
-      expect(result).toEqual({ test: true })
-      expect(mockRl.close).toHaveBeenCalled()
-      expect(mockRl2.close).toHaveBeenCalled()
-    })
-  })
-
-  describe('readline interface management', () => {
-    test('should create readline interface with correct options', async () => {
-      mockRl.question.mockResolvedValue('y')
-
-      await prompt({
-        name: 'test',
-        message: 'Test?'
-      })
-
-      expect(readline.createInterface).toHaveBeenCalledWith({
-        input: process.stdin,
-        output: process.stdout
-      })
-    })
-
-    test('should close readline interface even if error occurs', async () => {
-      mockRl.question.mockRejectedValue(new Error('Test error'))
-
-      await expect(
-        prompt({
-          name: 'test',
-          message: 'Test?'
-        })
-      ).rejects.toThrow('Test error')
-
-      expect(mockRl.close).toHaveBeenCalled()
-    })
-  })
-
-  describe('return value format', () => {
-    test('should return object with specified property name', async () => {
-      mockRl.question.mockResolvedValue('y')
-
-      const result = await prompt({
-        name: 'customProperty',
-        message: 'Test?'
-      })
-
-      expect(result).toHaveProperty('customProperty')
-      expect(result.customProperty).toBe(true)
-      expect(Object.keys(result)).toHaveLength(1)
-    })
-
-    test('should handle different property names correctly', async () => {
-      mockRl.question.mockResolvedValue('n')
-
-      const result = await prompt({
-        name: 'shouldProceed',
-        message: 'Proceed?'
-      })
-
-      expect(result).toEqual({ shouldProceed: false })
-    })
-  })
-
-  describe('autoContinue', () => {
-    const { autoContinue } = require('../lib/helpers/cliPrompt')
-    let mockWrite, originalWrite
-
-    beforeEach(() => {
-      // Mock process.stdout.write to capture output
-      originalWrite = process.stdout.write
-      mockWrite = jest.fn()
-      process.stdout.write = mockWrite
-
-      // Mock setTimeout to speed up tests
-      jest.useFakeTimers()
-    })
-
-    afterEach(() => {
-      // Restore original stdout.write
-      process.stdout.write = originalWrite
-      jest.useRealTimers()
-    })
-
-    test('should return object with specified property name', async () => {
-      const promise = autoContinue({
-        name: 'install',
-        message: 'Auto-installing in ',
-        timeInSeconds: 2
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      const result = await promise
-      expect(result).toEqual({ install: true })
-    })
-
-    test('should handle custom timeInSeconds', async () => {
-      const promise = autoContinue({
-        name: 'proceed',
-        message: 'Proceeding in ',
-        timeInSeconds: 3
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      const result = await promise
-      expect(result).toEqual({ proceed: true })
-    })
-
-    test('should use default timeInSeconds of 5 when not specified', async () => {
-      const promise = autoContinue({
-        name: 'default',
-        message: 'Starting in '
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      const result = await promise
-      expect(result).toEqual({ default: true })
-    }, 10000) // 10 second timeout
-
-    test('should write countdown to stdout', async () => {
-      const promise = autoContinue({
-        name: 'test',
-        message: 'Testing in ',
-        timeInSeconds: 3
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      await promise
-
-      // Should write initial message with starting number
-      expect(mockWrite).toHaveBeenCalledWith('Testing in 3')
-    })
-
-    test('should handle single digit countdown correctly', async () => {
-      const promise = autoContinue({
-        name: 'test',
-        message: 'Starting in ',
-        timeInSeconds: 2
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      await promise
-
-      // Should write initial message
-      expect(mockWrite).toHaveBeenCalledWith('Starting in 2')
-    })
-
-    test('should handle double digit to single digit countdown with padding', async () => {
-      const promise = autoContinue({
-        name: 'test',
-        message: 'Waiting ',
-        timeInSeconds: 10
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      await promise
-
-      // Should write initial message with double digit
-      expect(mockWrite).toHaveBeenCalledWith('Waiting 10')
-    }, 15000) // 15 second timeout
-
-    test('should call console.log at the end', async () => {
-      const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => {})
-
-      const promise = autoContinue({
-        name: 'test',
-        message: 'Done in ',
-        timeInSeconds: 1
-      })
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      await promise
-
-      expect(mockConsoleLog).toHaveBeenCalledWith()
-      mockConsoleLog.mockRestore()
-    })
-
-    test('should handle default parameters', async () => {
-      const promise = autoContinue()
-
-      // Fast-forward all timers
-      jest.runAllTimers()
-
-      const result = await promise
-
-      // Should handle undefined name gracefully
-      expect(result).toEqual({ undefined: true })
-    }, 10000) // 10 second timeout
-  })
-})

package/__tests__/env-var-integration.test.js

@@ -1,109 +0,0 @@
-// __tests__/env-var-integration.test.js
-
-// Test the NPQ_PKG_MGR environment variable functionality
-// This tests the key logic change: process.env.NPQ_PKG_MGR || values.packageManager || values.pkgMgr || 'npm'
-
-const packageManager = require('../lib/packageManager')
-
-const childProcess = require('child_process')
-
-jest.mock('child_process', () => {
-  return {
-    spawn: jest.fn((cmd, options) => {
-      return { pid: 12345 }
-    })
-  }
-})
-
-describe('NPQ_PKG_MGR Environment Variable Integration', () => {
-  let originalNPQ_PKG_MGR
-
-  beforeEach(() => {
-    originalNPQ_PKG_MGR = process.env.NPQ_PKG_MGR
-    delete process.env.NPQ_PKG_MGR
-    childProcess.spawn.mockClear()
-  })
-
-  afterEach(() => {
-    if (originalNPQ_PKG_MGR !== undefined) {
-      process.env.NPQ_PKG_MGR = originalNPQ_PKG_MGR
-    } else {
-      delete process.env.NPQ_PKG_MGR
-    }
-  })
-
-  test('package manager process should handle pnpm correctly', async () => {
-    process.argv = ['node', 'npq', 'install', 'fastify']
-
-    // Test that the package manager can spawn pnpm (which would be passed from CLI parsing)
-    await packageManager.process('pnpm')
-
-    expect(childProcess.spawn).toHaveBeenCalledWith('pnpm install fastify', {
-      stdio: 'inherit',
-      shell: true
-    })
-  })
-
-  test('package manager process should handle yarn correctly', async () => {
-    process.argv = ['node', 'npq', 'install', 'express', 'lodash']
-
-    await packageManager.process('yarn')
-
-    expect(childProcess.spawn).toHaveBeenCalledWith('yarn install express lodash', {
-      stdio: 'inherit',
-      shell: true
-    })
-  })
-
-  test('package manager process should handle various package managers', async () => {
-    const packageManagers = ['npm', 'yarn', 'pnpm', 'bun']
-
-    for (const pm of packageManagers) {
-      process.argv = ['node', 'npq', 'install', 'test-package']
-
-      await packageManager.process(pm)
-
-      expect(childProcess.spawn).toHaveBeenCalledWith(`${pm} install test-package`, {
-        stdio: 'inherit',
-        shell: true
-      })
-
-      childProcess.spawn.mockClear()
-    }
-  })
-
-  test('should demonstrate NPQ_PKG_MGR environment variable precedence logic', () => {
-    // This test documents the specific logic that was implemented:
-    // packageManager: process.env.NPQ_PKG_MGR || values.packageManager || values.pkgMgr || 'npm'
-
-    // Test 1: Environment variable takes precedence
-    process.env.NPQ_PKG_MGR = 'pnpm'
-    const values1 = { packageManager: 'yarn', pkgMgr: 'npm' }
-    const result1 = process.env.NPQ_PKG_MGR || values1.packageManager || values1.pkgMgr || 'npm'
-    expect(result1).toBe('pnpm')
-
-    // Test 2: Falls back to packageManager when env var not set
-    delete process.env.NPQ_PKG_MGR
-    const values2 = { packageManager: 'yarn', pkgMgr: 'npm' }
-    const result2 = process.env.NPQ_PKG_MGR || values2.packageManager || values2.pkgMgr || 'npm'
-    expect(result2).toBe('yarn')
-
-    // Test 3: Falls back to pkgMgr when env var and packageManager not set
-    delete process.env.NPQ_PKG_MGR
-    const values3 = { pkgMgr: 'pnpm' }
-    const result3 = process.env.NPQ_PKG_MGR || values3.packageManager || values3.pkgMgr || 'npm'
-    expect(result3).toBe('pnpm')
-
-    // Test 4: Falls back to npm default when nothing is set
-    delete process.env.NPQ_PKG_MGR
-    const values4 = {}
-    const result4 = process.env.NPQ_PKG_MGR || values4.packageManager || values4.pkgMgr || 'npm'
-    expect(result4).toBe('npm')
-
-    // Test 5: Empty string environment variable falls back to CLI options
-    process.env.NPQ_PKG_MGR = ''
-    const values5 = { packageManager: 'yarn' }
-    const result5 = process.env.NPQ_PKG_MGR || values5.packageManager || values5.pkgMgr || 'npm'
-    expect(result5).toBe('yarn')
-  })
-})