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

package/src/commands/preview.spec.js

@@ -0,0 +1,97 @@
+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() === 'preview')
+})
+
+test('command is registered in CLI program', (t) => {
+  const { command } = t.context
+
+  t.truthy(command, 'command "preview" 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(), 'preview')
+  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, 'preview command should have no arguments')
+})
+
+test('registered command has correct options', (t) => {
+  const { command } = t.context
+
+  // Get all options
+  const portOption = command.options.find((opt) => opt.long === '--port')
+  const quietOption = command.options.find((opt) => opt.long === '--quiet')
+  const verboseOption = command.options.find((opt) => opt.long === '--verbose')
+  const eleventyOption = command.options.find((opt) => opt.long === '--11ty')
+  const debugOption = command.options.find((opt) => opt.long === '--debug')
+
+  // Verify all options exist
+  t.truthy(portOption, '--port option should exist')
+  t.truthy(quietOption, '--quiet option should exist')
+  t.truthy(verboseOption, '--verbose option should exist')
+  t.truthy(eleventyOption, '--11ty option should exist')
+  t.truthy(debugOption, '--debug option should exist')
+
+  // Verify they are Option instances
+  t.true(portOption instanceof Option, '--port 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(eleventyOption instanceof Option, '--11ty should be Option instance')
+  t.true(debugOption instanceof Option, '--debug should be Option instance')
+
+  // Verify option properties
+  t.is(portOption.long, '--port')
+  t.is(portOption.short, '-p')
+  t.truthy(portOption.description)
+  t.true(portOption.required, '--port should require a value')
+
+  t.is(quietOption.long, '--quiet')
+  t.is(quietOption.short, '-q')
+  t.truthy(quietOption.description)
+
+  t.is(verboseOption.long, '--verbose')
+  t.is(verboseOption.short, '-v')
+  t.truthy(verboseOption.description)
+
+  t.is(eleventyOption.long, '--11ty')
+  t.truthy(eleventyOption.description)
+  t.true(eleventyOption.required, '--11ty should 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('--port'))
+  t.true(optionNames.includes('--quiet'))
+  t.true(optionNames.includes('--verbose'))
+  t.true(optionNames.includes('--11ty'))
+  t.true(optionNames.includes('--debug'))
+})

package/src/commands/preview.test.js

@@ -0,0 +1,250 @@
+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 directory structure
+  t.context.vol.fromJSON({
+    '/project/content/_data/config.yaml': 'title: Test Project',
+    '/project/content/index.md': '# Welcome',
+    '/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()
+  }
+})
+
+test.afterEach.always((t) => {
+  // Restore all mocks
+  t.context.sandbox.restore()
+
+  // Clear in-memory file system
+  t.context.vol.reset()
+})
+
+test('preview command should call eleventy CLI serve with default options', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock eleventy CLI module
+  const mockEleventyCli = {
+    serve: sandbox.stub().resolves({ exitCode: 0 })
+  }
+
+  // Mock eleventy API module
+  const mockEleventyApi = {
+    serve: sandbox.stub().resolves()
+  }
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const PreviewCommand = await esmock('./preview.js', {
+    '#lib/11ty/index.js': {
+      api: mockEleventyApi,
+      cli: mockEleventyCli
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new PreviewCommand()
+  command.name = sandbox.stub().returns('preview')
+
+  // Run preAction
+  command.preAction(command)
+
+  // Run action with default options (uses cli by default)
+  await command.action({ '11ty': 'cli', port: 8080 }, command)
+
+  t.true(mockTestcwd.called, 'testcwd should be called in preAction')
+  t.true(mockEleventyCli.serve.called, 'eleventy CLI serve should be called')
+  t.false(mockEleventyApi.serve.called, 'eleventy API serve should not be called')
+})
+
+test('preview command should call eleventy API when 11ty option is "api"', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock eleventy CLI module
+  const mockEleventyCli = {
+    serve: sandbox.stub().resolves({ exitCode: 0 })
+  }
+
+  // Mock eleventy API module
+  const mockEleventyApi = {
+    serve: sandbox.stub().resolves()
+  }
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const PreviewCommand = await esmock('./preview.js', {
+    '#lib/11ty/index.js': {
+      api: mockEleventyApi,
+      cli: mockEleventyCli
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new PreviewCommand()
+  command.name = sandbox.stub().returns('preview')
+
+  // Run action with api option
+  await command.action({ '11ty': 'api', port: 8080 }, command)
+
+  t.false(mockEleventyCli.serve.called, 'eleventy CLI serve should not be called')
+  t.true(mockEleventyApi.serve.called, 'eleventy API serve should be called')
+})
+
+test('preview command should pass port option to eleventy serve', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock eleventy CLI module
+  const mockEleventyCli = {
+    serve: sandbox.stub().resolves({ exitCode: 0 })
+  }
+
+  // Mock eleventy API module
+  const mockEleventyApi = {
+    serve: sandbox.stub().resolves()
+  }
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const PreviewCommand = await esmock('./preview.js', {
+    '#lib/11ty/index.js': {
+      api: mockEleventyApi,
+      cli: mockEleventyCli
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new PreviewCommand()
+  command.name = sandbox.stub().returns('preview')
+
+  const options = { '11ty': 'cli', port: 3000 }
+
+  // Run action with custom port
+  await command.action(options, command)
+
+  t.true(mockEleventyCli.serve.calledWith(options), 'eleventy CLI serve should be called with port option')
+})
+
+test('preview command should pass quiet and verbose options', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock eleventy CLI module
+  const mockEleventyCli = {
+    serve: sandbox.stub().resolves({ exitCode: 0 })
+  }
+
+  // Mock eleventy API module
+  const mockEleventyApi = {
+    serve: sandbox.stub().resolves()
+  }
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const PreviewCommand = await esmock('./preview.js', {
+    '#lib/11ty/index.js': {
+      api: mockEleventyApi,
+      cli: mockEleventyCli
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new PreviewCommand()
+  command.name = sandbox.stub().returns('preview')
+
+  const options = { '11ty': 'cli', quiet: true, verbose: false, port: 8080 }
+
+  // Run action with quiet and verbose options
+  await command.action(options, command)
+
+  t.true(mockEleventyCli.serve.calledWith(options), 'eleventy CLI serve should be called with all options')
+})
+
+test('preview command should call testcwd in preAction', async (t) => {
+  const { sandbox, fs, mockLogger } = t.context
+
+  // Mock eleventy modules
+  const mockEleventyCli = {
+    serve: sandbox.stub().resolves({ exitCode: 0 })
+  }
+
+  const mockEleventyApi = {
+    serve: sandbox.stub().resolves()
+  }
+
+  // Mock testcwd helper
+  const mockTestcwd = sandbox.stub()
+
+  // Use esmock to replace imports
+  const PreviewCommand = await esmock('./preview.js', {
+    '#lib/11ty/index.js': {
+      api: mockEleventyApi,
+      cli: mockEleventyCli
+    },
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#lib/logger/index.js': {
+      logger: mockLogger
+    },
+    'fs-extra': fs
+  })
+
+  const command = new PreviewCommand()
+  command.name = sandbox.stub().returns('preview')
+
+  // Run preAction
+  command.preAction(command)
+
+  t.true(mockTestcwd.called, 'testcwd should be called in preAction')
+  t.true(mockTestcwd.calledWith(command), 'testcwd should be called with command object')
+})

package/src/commands/use.js

@@ -0,0 +1,56 @@
+import Command from '#src/Command.js'
+import { setVersion } from '#lib/project/index.js'
+import { latest } from '#lib/installer/index.js'
+import testcwd from '#helpers/test-cwd.js'
+
+/**
+ * Quire CLI `use` Command
+ *
+ * Running `quire use` sets the `quire-11ty` version for a project.
+ * The version is written to a `.quire` file in the project directory.
+ *
+ * @class      UseCommand
+ * @extends    {Command}
+ */
+export default class UseCommand extends Command {
+  static definition = {
+    name: 'use',
+    aliases: ['version'],
+    hidden: true,  // hide command (incomplete functionality; possible Quire v2)
+    description: 'Sets the Quire version to use when running commands on the project.',
+    summary: 'set project quire-11ty version',
+    docsLink: 'quire-commands/',
+    version: '1.0.0',
+    args: [
+      [ '<version>', 'quire-11ty version to use' ],
+    ],
+    options: [
+      // [ '-g', '--global', 'set the quire version globally' ],
+    ],
+  }
+
+  constructor() {
+    super(UseCommand.definition)
+  }
+
+  /**
+   * Set the quire-11ty version for the current project
+   *
+   * Validates the version against npm registry before setting.
+   * Supports exact versions, semver ranges, and 'latest'.
+   *
+   * @param {string} version - The quire-11ty version to use
+   * @param {Object} options - Command options
+   */
+  async action(version, options = {}) {
+    this.debug('called with options %O', options)
+
+    // Validate and resolve the version against npm registry
+    const resolvedVersion = await latest(version)
+    setVersion(resolvedVersion)
+  }
+
+  preAction(thisCommand, actionCommand) {
+    testcwd(thisCommand)
+  }
+}

package/src/commands/use.spec.js

@@ -0,0 +1,61 @@
+import { Argument, 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() === 'use')
+})
+
+test('command is registered in CLI program', (t) => {
+  const { command } = t.context
+
+  t.truthy(command, 'command "use" 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(), 'use')
+  t.truthy(command.description())
+  t.is(typeof command._actionHandler, 'function', 'command should have action handler')
+})
+
+test('registered command has correct arguments', (t) => {
+  const { command } = t.context
+  const registeredArguments = command.registeredArguments
+
+  t.is(registeredArguments.length, 1, 'command should have 1 argument')
+
+  // First argument: version
+  const version = registeredArguments[0]
+  t.true(version instanceof Argument, 'version should be Argument instance')
+  t.is(version.name(), 'version', 'first argument should be version')
+  t.true(version.required, 'version should be required')
+  t.truthy(version.description)
+})
+
+test('registered command has no options', (t) => {
+  const { command } = t.context
+
+  // Use command should have no custom options (only inherited help options)
+  const options = command.options.filter((opt) => !opt.long.includes('help'))
+  t.is(options.length, 0, 'use command should have no custom options')
+})
+
+test('command arguments are accessible via public API', (t) => {
+  const { command } = t.context
+
+  // Test that arguments can be accessed the way Commander.js does
+  const argumentNames = command.registeredArguments.map((arg) => arg.name())
+
+  t.true(argumentNames.includes('version'))
+})