@thegetty/quire-cli 1.0.0-rc.44 → 1.0.0-rc.46

package/src/commands/info.test.js

@@ -1,512 +0,0 @@
-import test from 'ava'
-import sinon from 'sinon'
-import esmock from 'esmock'
-
-test.beforeEach((t) => {
-  // Create sinon sandbox for mocking
-  t.context.sandbox = sinon.createSandbox()
-
-  // Create mock logger
-  t.context.mockLogger = {
-    info: t.context.sandbox.stub(),
-    error: t.context.sandbox.stub(),
-    debug: t.context.sandbox.stub(),
-    log: t.context.sandbox.stub(),
-    warn: t.context.sandbox.stub()
-  }
-
-  // Mock config
-  t.context.mockConfig = {
-    get: t.context.sandbox.stub().returns('./.quire-version')
-  }
-
-  // Mock testcwd helper
-  t.context.mockTestcwd = t.context.sandbox.stub()
-
-  // Mock packageConfig binPath
-  t.context.mockBinPath = t.context.sandbox.stub().returns('/usr/local/bin/quire')
-
-  // Mock fs module
-  t.context.mockFs = {
-    readFileSync: t.context.sandbox.stub(),
-    writeFileSync: t.context.sandbox.stub(),
-    existsSync: t.context.sandbox.stub().returns(true)
-  }
-
-  // Default version file content
-  t.context.versionFileContent = JSON.stringify({
-    cli: '1.0.0-rc.33',
-    starter: 'https://github.com/thegetty/quire-starter-default'
-  })
-
-  // Default package.json content
-  t.context.packageJsonContent = JSON.stringify({
-    name: 'test-project',
-    version: '1.0.0'
-  })
-
-  // Setup default readFileSync behavior - stub returns different content based on file path
-  t.context.mockFs.readFileSync.callsFake((filePath, options) => {
-    if (filePath === './.quire-version') {
-      return t.context.versionFileContent
-    }
-    if (filePath === './package.json') {
-      return t.context.packageJsonContent
-    }
-    // For any other file, return empty string
-    return ''
-  })
-})
-
-test.afterEach.always((t) => {
-  // Restore all mocks
-  t.context.sandbox.restore()
-})
-
-test('info command should validate Quire project in preAction', async (t) => {
-  const { sandbox, mockLogger, mockTestcwd, mockConfig, mockBinPath, mockFs } = t.context
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  // Mock Commander.js command object
-  const mockCommand = {
-    name: () => 'info',
-    opts: () => ({})
-  }
-
-  // Call preAction
-  command.preAction(mockCommand)
-
-  t.true(mockTestcwd.called, 'testcwd should be called in preAction')
-  t.true(mockTestcwd.calledWith(mockCommand), 'testcwd should be called with command')
-})
-
-test('info command should display project version information', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({}, {})
-
-  // Verify logger.info was called with project information
-  t.true(mockLogger.info.called, 'logger.info should be called')
-
-  // Check for project header
-  const calls = mockLogger.info.getCalls()
-  const hasProjectInfo = calls.some((call) =>
-    call.args[0] && call.args[0].includes('Project:')
-  )
-  t.true(hasProjectInfo, 'should display project header')
-
-  // Check for quire-cli version in output
-  const hasCliVersion = calls.some((call) =>
-    call.args[0] && call.args[0].includes('quire-cli') && call.args[0].includes('1.0.0-rc.33')
-  )
-  t.true(hasCliVersion, 'should display quire-cli version')
-
-  // Check for quire-11ty version in output
-  const has11tyVersion = calls.some((call) =>
-    call.args[0] && call.args[0].includes('quire-11ty')
-  )
-  t.true(has11tyVersion, 'should display quire-11ty version')
-
-  // Check for doctor tip
-  const hasDoctorTip = calls.some((call) =>
-    call.args[0] && call.args[0].includes('quire doctor')
-  )
-  t.true(hasDoctorTip, 'should display doctor tip')
-})
-
-test('info command should display starter version when available', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({}, {})
-
-  // Verify logger.info was called
-  t.true(mockLogger.info.called, 'logger.info should be called')
-
-  // Check for starter version in output (from version file)
-  const calls = mockLogger.info.getCalls()
-  const hasStarterVersion = calls.some((call) =>
-    call.args[0] && call.args[0].includes('starter')
-  )
-  t.true(hasStarterVersion, 'should display starter version when available')
-})
-
-test('info command --debug shows installation paths', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({ debug: true }, {})
-
-  const calls = mockLogger.info.getCalls()
-  const output = calls.map((call) => call.args[0]).join('\n')
-
-  // Check for quire-cli path
-  t.true(output.includes('/usr/local/bin/quire'), 'should display quire-cli path')
-})
-
-test('info command --debug handles missing quire-cli in PATH', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockFs } = t.context
-
-  // binPath returns null when executable is not found
-  const mockBinPathNotFound = sandbox.stub().returns(null)
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPathNotFound
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({ debug: true }, {})
-
-  const calls = mockLogger.info.getCalls()
-  const output = calls.map((call) => call.args[0]).join('\n')
-
-  t.true(output.includes('not found in PATH'), 'should show not found message for quire-cli')
-})
-
-test('info command should handle missing version file', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  // Setup mockFs to throw error for missing version file (simulating file not found)
-  mockFs.readFileSync.callsFake((filePath, options) => {
-    if (filePath === './.quire-version') {
-      throw new Error('ENOENT: no such file')
-    }
-    if (filePath === './package.json') {
-      return t.context.packageJsonContent
-    }
-    return ''
-  })
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({}, {})
-
-  // Verify warning was logged about old version
-  t.true(mockLogger.warn.called, 'logger.warn should be called for missing version file')
-  t.true(
-    mockLogger.warn.calledWith(sinon.match(/prior to version 1.0.0.rc-8/)),
-    'should warn about old project version'
-  )
-
-  // Verify version file was created
-  t.true(mockFs.writeFileSync.called, 'writeFileSync should be called to create version file')
-})
-
-test('info command should handle malformed version file', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  // Setup mockFs to return malformed JSON (simulating corrupted file)
-  mockFs.readFileSync.callsFake((filePath, options) => {
-    if (filePath === './.quire-version') {
-      return 'invalid json{'
-    }
-    if (filePath === './package.json') {
-      return t.context.packageJsonContent
-    }
-    return ''
-  })
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({}, {})
-
-  // Verify warning was logged
-  t.true(mockLogger.warn.called, 'logger.warn should be called for malformed version file')
-
-  // Verify version file was overwritten with valid JSON
-  t.true(mockFs.writeFileSync.called, 'writeFileSync should be called to fix malformed version file')
-
-  // Check that the content written is valid JSON
-  const writeCall = mockFs.writeFileSync.getCall(0)
-  if (writeCall) {
-    const writtenContent = writeCall.args[1]
-    t.notThrows(() => JSON.parse(writtenContent), 'written content should be valid JSON')
-  }
-})
-
-test('info command should read quire-11ty version from package.json', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  // Override package.json to have specific version
-  mockFs.readFileSync.callsFake((filePath, options) => {
-    if (filePath === './.quire-version') {
-      return t.context.versionFileContent
-    }
-    if (filePath === './package.json') {
-      return JSON.stringify({
-        name: 'test-project',
-        version: '2.5.3'
-      })
-    }
-    return ''
-  })
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({}, {})
-
-  // Verify logger.info was called
-  t.true(mockLogger.info.called, 'logger.info should be called')
-
-  // Check for quire-11ty version from package.json
-  const calls = mockLogger.info.getCalls()
-  const hasEleventyVersion = calls.some((call) =>
-    call.args[0] && call.args[0].includes('quire-11ty') && call.args[0].includes('2.5.3')
-  )
-  t.true(hasEleventyVersion, 'should display quire-11ty version from package.json')
-})
-
-test('info command should log debug information', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-
-  const mockDebug = sandbox.stub()
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = mockDebug
-
-  await command.action({}, {})
-
-  // Verify debug was called
-  t.true(mockDebug.called, 'debug should be called')
-  t.true(mockDebug.calledWith('called with options %O', {}))
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// JSON output tests
-// ─────────────────────────────────────────────────────────────────────────────
-
-test.serial('info --json should output valid JSON with project versions', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-  const consoleLogStub = sandbox.stub(console, 'log')
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({ json: true }, {})
-
-  // Should output via console.log, not logger.info
-  t.true(consoleLogStub.calledOnce, 'console.log should be called once')
-  t.false(mockLogger.info.called, 'logger.info should not be called in JSON mode')
-
-  // Parse and validate the JSON structure
-  const output = JSON.parse(consoleLogStub.firstCall.args[0])
-
-  t.truthy(output.project, 'JSON should have project section')
-
-  // Project section
-  t.is(output.project.cli, '1.0.0-rc.33')
-  t.is(output.project.quire11ty, '1.0.0')
-  t.is(output.project.starter, 'https://github.com/thegetty/quire-starter-default')
-  t.is(typeof output.project.directory, 'string')
-})
-
-test.serial('info --json should set starter to null when not available', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
-  const consoleLogStub = sandbox.stub(console, 'log')
-
-  // Version file without starter
-  t.context.mockFs.readFileSync.callsFake((filePath, options) => {
-    if (filePath === './.quire-version') {
-      return JSON.stringify({ cli: '1.0.0-rc.33' })
-    }
-    if (filePath === './package.json') {
-      return t.context.packageJsonContent
-    }
-    return ''
-  })
-
-  const { default: InfoCommand } = await esmock('./info.js', {
-    '#helpers/test-cwd.js': {
-      default: mockTestcwd
-    },
-    '#src/packageConfig.js': {
-      binPath: mockBinPath
-    },
-    'node:fs': mockFs
-  }, {
-    '#lib/logger/index.js': {
-      default: () => mockLogger
-    }
-  })
-
-  const command = new InfoCommand()
-  command.config = mockConfig
-  command.logger = mockLogger
-  command.debug = sandbox.stub()
-
-  await command.action({ json: true }, {})
-
-  const output = JSON.parse(consoleLogStub.firstCall.args[0])
-
-  t.is(output.project.starter, null, 'starter should be null when not in version file')
-})

package/src/commands/pdf.spec.js

@@ -1,114 +0,0 @@
-import { Command, Option } from 'commander'
-import program from '#src/main.js'
-import test from 'ava'
-
-/**
- * Command Contract/Interface Tests
- *
- * Verifies the command's public API and Commander.js integration.
- * @see docs/testing-commands.md
- */
-
-test.before((t) => {
-  // Get the registered command (from program.commands) once and share across all tests
-  t.context.command = program.commands.find((cmd) => cmd.name() === 'pdf')
-})
-
-test('command is registered in CLI program', (t) => {
-  const { command } = t.context
-
-  t.truthy(command, 'command "pdf" should be registered in program')
-  t.true(command instanceof Command, 'registered command should be Commander.js Command instance')
-})
-
-test('registered command has correct metadata', (t) => {
-  const { command } = t.context
-
-  t.is(command.name(), 'pdf')
-  t.truthy(command.description())
-  t.is(typeof command._actionHandler, 'function', 'command should have action handler')
-})
-
-test('registered command has no arguments', (t) => {
-  const { command } = t.context
-  const registeredArguments = command.registeredArguments
-
-  t.is(registeredArguments.length, 0, 'pdf command should have no arguments')
-})
-
-test('registered command has correct options', (t) => {
-  const { command } = t.context
-
-  // Get all options
-  const engineOption = command.options.find((opt) => opt.long === '--engine')
-  const libOption = command.options.find((opt) => opt.long === '--lib')
-  const buildOption = command.options.find((opt) => opt.long === '--build')
-  const openOption = command.options.find((opt) => opt.long === '--open')
-  const quietOption = command.options.find((opt) => opt.long === '--quiet')
-  const verboseOption = command.options.find((opt) => opt.long === '--verbose')
-  const debugOption = command.options.find((opt) => opt.long === '--debug')
-
-  // Verify all options exist
-  t.truthy(engineOption, '--engine option should exist')
-  t.truthy(libOption, '--lib option should exist (deprecated alias)')
-  t.truthy(buildOption, '--build option should exist')
-  t.truthy(openOption, '--open option should exist')
-  t.truthy(quietOption, '--quiet option should exist')
-  t.truthy(verboseOption, '--verbose option should exist')
-  t.truthy(debugOption, '--debug option should exist')
-
-  // Verify they are Option instances
-  t.true(engineOption instanceof Option, '--engine should be Option instance')
-  t.true(libOption instanceof Option, '--lib should be Option instance')
-  t.true(buildOption instanceof Option, '--build should be Option instance')
-  t.true(openOption instanceof Option, '--open should be Option instance')
-  t.true(quietOption instanceof Option, '--quiet should be Option instance')
-  t.true(verboseOption instanceof Option, '--verbose should be Option instance')
-  t.true(debugOption instanceof Option, '--debug should be Option instance')
-
-  // Verify --engine option properties
-  t.is(engineOption.long, '--engine')
-  t.truthy(engineOption.description)
-  t.true(engineOption.required, '--engine should require a value')
-
-  // Verify --lib is hidden (deprecated alias)
-  t.is(libOption.long, '--lib')
-  t.true(libOption.hidden, '--lib should be hidden (deprecated)')
-
-  t.is(buildOption.long, '--build')
-  t.truthy(buildOption.description)
-  t.false(buildOption.required, '--build should not require a value')
-
-  t.is(openOption.long, '--open')
-  t.truthy(openOption.description)
-  t.false(openOption.required, '--open should not require a value')
-
-  t.is(quietOption.long, '--quiet')
-  t.is(quietOption.short, '-q', '--quiet should have -q short flag')
-  t.truthy(quietOption.description)
-  t.false(quietOption.required, '--quiet should not require a value')
-
-  t.is(verboseOption.long, '--verbose')
-  t.is(verboseOption.short, '-v', '--verbose should have -v short flag')
-  t.truthy(verboseOption.description)
-  t.false(verboseOption.required, '--verbose should not require a value')
-
-  t.is(debugOption.long, '--debug')
-  t.truthy(debugOption.description)
-  t.false(debugOption.required, '--debug should not require a value')
-})
-
-test('command options are accessible via public API', (t) => {
-  const { command } = t.context
-
-  // Test that options can be accessed the way Commander.js does
-  const optionNames = command.options.map((opt) => opt.long)
-
-  t.true(optionNames.includes('--engine'))
-  t.true(optionNames.includes('--lib'))  // deprecated alias still exists
-  t.true(optionNames.includes('--build'))
-  t.true(optionNames.includes('--open'))
-  t.true(optionNames.includes('--quiet'))
-  t.true(optionNames.includes('--verbose'))
-  t.true(optionNames.includes('--debug'))
-})