@thegetty/quire-cli 1.0.0-rc.34 → 1.0.0-rc.36

package/src/commands/use.test.js

@@ -0,0 +1,280 @@
+import test from 'ava'
+import { Volume, createFsFromVolume } from 'memfs'
+import sinon from 'sinon'
+import esmock from 'esmock'
+
+test.beforeEach((t) => {
+  // Create sinon sandbox for mocking
+  t.context.sandbox = sinon.createSandbox()
+
+  // Create in-memory file system
+  t.context.vol = new Volume()
+  t.context.fs = createFsFromVolume(t.context.vol)
+
+  // Setup mock Quire project directory structure
+  t.context.vol.fromJSON({
+    '/project/.quire': '',
+    '/project/content/_data/config.yaml': 'title: Test Project',
+    '/project/package.json': JSON.stringify({ name: 'test-project' })
+  })
+
+  t.context.projectRoot = '/project'
+
+  // 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 testcwd helper (returns true for Quire projects)
+  t.context.mockTestcwd = t.context.sandbox.stub()
+})
+
+test.afterEach.always((t) => {
+  // Restore all mocks
+  t.context.sandbox.restore()
+
+  // Clear in-memory file system
+  t.context.vol.reset()
+})
+
+test('use command should validate Quire project in preAction', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  // Mock Commander.js command object
+  const mockCommand = {
+    name: () => 'use',
+    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('use command should accept version argument', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  const mockLatest = sandbox.stub().resolves('1.0.0-rc.33')
+  const mockSetVersion = sandbox.stub()
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/installer/index.js': {
+      latest: mockLatest
+    },
+    '#lib/project/index.js': {
+      setVersion: mockSetVersion
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  // Call action with version argument
+  await command.action('1.0.0-rc.33', {})
+
+  t.true(mockLatest.calledWith('1.0.0-rc.33'), 'latest should be called with version')
+  t.true(mockSetVersion.calledWith('1.0.0-rc.33'), 'setVersion should be called with resolved version')
+})
+
+test('use command should log debug information when debug flag is set', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  const mockDebug = sandbox.stub()
+  const mockLatest = sandbox.stub().resolves('1.0.0-rc.33')
+  const mockSetVersion = sandbox.stub()
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/installer/index.js': {
+      latest: mockLatest
+    },
+    '#lib/project/index.js': {
+      setVersion: mockSetVersion
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = mockDebug
+
+  // Call action with debug flag
+  await command.action('1.0.0-rc.33', { debug: true })
+
+  // Verify debug was called
+  t.true(mockDebug.called, 'debug should be called with debug flag')
+  t.true(mockDebug.calledWith('called with options %O', { debug: true }))
+})
+
+test('use command should handle semver version strings', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  // Mock the installer's latest function to return the version
+  const mockLatest = sandbox.stub().callsFake(async (version) => version)
+  const mockSetVersion = sandbox.stub()
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/installer/index.js': {
+      latest: mockLatest
+    },
+    '#lib/project/index.js': {
+      setVersion: mockSetVersion
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  // Test various semver formats
+  const validVersions = [
+    '1.0.0',
+    '1.0.0-rc.1',
+    '1.0.0-beta.2',
+    '2.1.3',
+    '0.0.1'
+  ]
+
+  for (const version of validVersions) {
+    await command.action(version, {})
+    t.pass(`should accept valid semver: ${version}`)
+  }
+
+  t.is(mockLatest.callCount, validVersions.length, 'latest should be called for each version')
+  t.is(mockSetVersion.callCount, validVersions.length, 'setVersion should be called for each version')
+})
+
+test('use command should work with options object', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  // Mock the installer's latest function to return the version
+  const mockLatest = sandbox.stub().callsFake(async (version) => version)
+  const mockSetVersion = sandbox.stub()
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/installer/index.js': {
+      latest: mockLatest
+    },
+    '#lib/project/index.js': {
+      setVersion: mockSetVersion
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  // Test with various options
+  await command.action('1.0.0', { debug: false })
+  await command.action('1.0.0', { debug: true })
+  await command.action('1.0.0', {})
+
+  t.is(mockLatest.callCount, 3, 'latest should be called for each action')
+  t.is(mockSetVersion.callCount, 3, 'setVersion should be called for each action')
+  t.pass('command should handle various option combinations')
+})
+
+test('use command preAction should be called before action', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  // Mock Commander.js command object
+  const mockCommand = {
+    name: () => 'use',
+    opts: () => ({})
+  }
+
+  // Verify preAction exists and can be called
+  t.is(typeof command.preAction, 'function', 'preAction should be a function')
+
+  // Call preAction (would be called by Commander.js before action)
+  command.preAction(mockCommand)
+
+  // Verify testcwd was called
+  t.true(mockTestcwd.called, 'testcwd should validate project directory')
+})
+
+test('use command should have correct command definition', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd } = t.context
+
+  const { default: UseCommand } = await esmock('./use.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    }
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new UseCommand()
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  t.is(command.name, 'use', 'command name should be "use"')
+  t.truthy(command.description, 'command should have description')
+  t.truthy(command.summary, 'command should have summary')
+  t.truthy(command.version, 'command should have version')
+  t.true(Array.isArray(command.args), 'command should have args array')
+  t.is(command.args.length, 1, 'command should have 1 argument')
+})

package/src/commands/validate.js

@@ -1,47 +1,52 @@
 import Command from '#src/Command.js'
+import { withOutputModes } from '#lib/commander/index.js'
 import { YAMLException } from 'js-yaml'
 import YamlValidationError from '../errors/validation/yaml-validation-error.js'
 import fs from 'fs-extra'
 import path from 'node:path'
-import { projectRoot  } from '#lib/11ty/index.js'
+import paths from '#lib/project/index.js'
 import testcwd from '../helpers/test-cwd.js'
 import yamlValidation from '../validators/validate-yaml.js'
-
+import { ValidationError } from '#src/errors/index.js'
 
 /**
  * Quire CLI `validate` Command
- *  
+ *
  * @class     ValidateCommand
  * @extends   {Command}
  */
 export default class ValidateCommand extends Command {
-  static definition = {
+  static definition = withOutputModes({
     name: 'validate',
     description: 'Validate configuration files',
-    summary: 'run validation',
+    summary: 'check YAML files for errors',
+    docsLink: 'quire-commands/#get-help',
+    helpText: `
+Examples:
+  quire validate               Check YAML syntax in content/_data/
+  quire validate --verbose     Validate with detailed file listing
+
+Validates YAML files in content/_data/ directory.
+`,
     version: '1.0.0',
-    options: [
-      [ '--debug', 'run validate with debug output to console' ],
-    ],
-  }
+    options: [],
+  })
 
   constructor() {
     super(ValidateCommand.definition)
   }
 
   action(options, command){
-    if(options.debug) {
-      console.debug('[CLI] Command \'%s\' called with options %o', this.name(), options)
-    }
-    
-    const dataPath = path.join(projectRoot, 'content', '_data')
+    this.debug('called with options %O', options)
+
+    const dataPath = path.join(paths.getProjectRoot(), 'content', '_data')
     const files = fs.readdirSync(dataPath)
       .filter(file => file.endsWith('.yaml') || file.endsWith('.yml'))
       .map(file => path.join(dataPath, file)
       )
 
     let errorList = []
-    console.log('Validating YAML files..')
+    this.logger.info('Validating YAML files..')
 
     for (const file of files) {
       try {
@@ -52,13 +57,20 @@ export default class ValidateCommand extends Command {
     }
 
     if(errorList.length > 0) {
-      errorList.forEach(err => { console.error(`${err.reason}`) })
+      errorList.forEach(err => { this.logger.error(`${err.reason}`) })
+      throw new ValidationError(
+        `Validation failed with ${errorList.length} error(s)`,
+        {
+          code: 'VALIDATION_FAILED',
+          suggestion: 'Fix the errors listed above and run validation again'
+        }
+      )
     } else {
-      console.log('Validation complete.')
+      this.logger.info('Validation complete.')
     }
   }
 
-  preAction(options, command) {
-    testcwd(command)
+  preAction(thisCommand, actionCommand) {
+    testcwd(thisCommand)
   }
 }

package/src/commands/validate.spec.js

@@ -0,0 +1,82 @@
+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() === 'validate')
+})
+
+test('command is registered in CLI program', (t) => {
+  const { command } = t.context
+
+  t.truthy(command, 'command "validate" 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(), 'validate')
+  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, 'validate command should have no arguments')
+})
+
+test('registered command has correct options', (t) => {
+  const { command } = t.context
+
+  // Get all options
+  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(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(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 option properties
+  t.is(quietOption.long, '--quiet')
+  t.is(quietOption.short, '-q')
+  t.truthy(quietOption.description)
+  t.false(quietOption.required, '--quiet should not require a value')
+
+  t.is(verboseOption.long, '--verbose')
+  t.is(verboseOption.short, '-v')
+  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('--quiet'))
+  t.true(optionNames.includes('--verbose'))
+  t.true(optionNames.includes('--debug'))
+})

package/src/commands/validate.test.js

@@ -0,0 +1,234 @@
+import test from 'ava'
+import { Volume, createFsFromVolume } from 'memfs'
+import sinon from 'sinon'
+import esmock from 'esmock'
+import { ValidationError } from '#src/errors/index.js'
+
+test.beforeEach((t) => {
+  // Create sinon sandbox for mocking
+  t.context.sandbox = sinon.createSandbox()
+
+  // Create in-memory file system
+  t.context.vol = new Volume()
+  t.context.fs = createFsFromVolume(t.context.vol)
+
+  // Setup mock directory structure
+  t.context.vol.fromJSON({
+    '/project/content/_data/config.yaml': 'title: Quire Test Project\nidentifier:\n  isbn: "978-0-12345-678-9"',
+    '/project/content/_data/publication.yaml': 'title: Test Publication',
+    '/project/package.json': JSON.stringify({ name: 'test-project' })
+  })
+
+  t.context.projectRoot = '/project'
+
+  // Stub console methods to suppress output during tests
+  // Create mock logger (no global console stubbing needed!)
+  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()
+  }
+  // mockLogger already created above
+  // mockLogger already created above
+})
+
+test.afterEach.always((t) => {
+  // Restore all mocks
+  t.context.sandbox.restore()
+
+  // Clear in-memory file system
+  t.context.vol.reset()
+})
+
+test('validate command should find and validate YAML files', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock yamlValidation function
+  const mockYamlValidation = sandbox.stub()
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const ValidateCommand = await esmock('./validate.js', {
+    '../validators/validate-yaml.js': {
+      default: mockYamlValidation
+    },
+    '#lib/project/index.js': {
+      default: { getProjectRoot: () => '/project' }
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new ValidateCommand()
+  command.name = sandbox.stub().returns('validate')
+
+  // Run action
+  command.action({}, command)
+
+  // Should validate both YAML files
+  t.true(mockYamlValidation.callCount >= 2, 'should validate multiple YAML files')
+})
+
+test('validate command should handle validation errors', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock yamlValidation function to throw error
+  const validationError = new Error('Invalid YAML')
+  validationError.reason = 'Invalid YAML: missing required field'
+  const mockYamlValidation = sandbox.stub().throws(validationError)
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const ValidateCommand = await esmock('./validate.js', {
+    '../validators/validate-yaml.js': {
+      default: mockYamlValidation
+    },
+    '#lib/project/index.js': {
+      default: { getProjectRoot: () => '/project' }
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new ValidateCommand()
+  command.name = sandbox.stub().returns('validate')
+  command.logger = mockLogger
+
+  // Run action - should throw ValidationError when there are validation errors
+  const error = t.throws(() => command.action({}, command), { instanceOf: ValidationError })
+
+  t.is(error.code, 'VALIDATION_FAILED', 'error should have correct code')
+  t.is(error.exitCode, 4, 'error should have validation exit code')
+  t.true(mockYamlValidation.called, 'validation should be attempted')
+  t.true(mockLogger.error.called, 'errors should be logged')
+})
+
+test('validate command should call testcwd in preAction', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock yamlValidation function
+  const mockYamlValidation = sandbox.stub()
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const ValidateCommand = await esmock('./validate.js', {
+    '../validators/validate-yaml.js': {
+      default: mockYamlValidation
+    },
+    '#lib/project/index.js': {
+      default: { getProjectRoot: () => '/project' }
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new ValidateCommand()
+  command.name = sandbox.stub().returns('validate')
+
+  // Run preAction
+  command.preAction({}, command)
+
+  t.true(mockTestcwd.called, 'testcwd should be called in preAction')
+})
+
+test('validate command should filter YAML files correctly', async (t) => {
+  const { sandbox, fs, vol, mockLogger } = t.context
+
+  // Add non-YAML files
+  vol.fromJSON({
+    '/project/content/_data/data.json': '{"key": "value"}',
+    '/project/content/_data/README.md': '# README',
+    '/project/content/_data/script.js': 'console.log("test")'
+  })
+
+  // Mock yamlValidation function
+  const mockYamlValidation = sandbox.stub()
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const ValidateCommand = await esmock('./validate.js', {
+    '../validators/validate-yaml.js': {
+      default: mockYamlValidation
+    },
+    '#lib/project/index.js': {
+      default: { getProjectRoot: () => '/project' }
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new ValidateCommand()
+  command.name = sandbox.stub().returns('validate')
+
+  // Run action
+  command.action({}, command)
+
+  // Should only validate YAML files (config.yaml and publication.yaml from beforeEach)
+  t.is(mockYamlValidation.callCount, 2, 'should only validate YAML files')
+})
+
+test('validate command should pass debug option through', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock yamlValidation function
+  const mockYamlValidation = sandbox.stub()
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const ValidateCommand = await esmock('./validate.js', {
+    '../validators/validate-yaml.js': {
+      default: mockYamlValidation
+    },
+    '#lib/project/index.js': {
+      default: { getProjectRoot: () => '/project' }
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new ValidateCommand()
+  command.name = sandbox.stub().returns('validate')
+
+  // Run action with debug option
+  command.action({ debug: true }, command)
+
+  t.true(mockYamlValidation.called, 'validation should run')
+  // Debug output should be logged (verified through console.debug stub)
+})