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

package/src/commands/epub.test.js

@@ -0,0 +1,503 @@
+import test from 'ava'
+import sinon from 'sinon'
+import esmock from 'esmock'
+
+test.beforeEach((t) => {
+  t.context.sandbox = sinon.createSandbox()
+
+  // Create mock reporter
+  t.context.mockReporter = {
+    configure: t.context.sandbox.stub().returnsThis(),
+    start: t.context.sandbox.stub().returnsThis(),
+    update: t.context.sandbox.stub().returnsThis(),
+    succeed: t.context.sandbox.stub().returnsThis(),
+    fail: t.context.sandbox.stub().returnsThis(),
+    stop: t.context.sandbox.stub().returnsThis(),
+  }
+})
+
+test.afterEach.always((t) => {
+  t.context.sandbox.restore()
+})
+
+test('epub command should call generateEpub with epubjs engine', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs' }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'should pass lib to generateEpub')
+  // Nota bene: reporter.start/succeed are called by façade (lib/epub/index.js), not the command
+})
+
+test('epub command should call generateEpub with pandoc engine', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/pandoc.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'pandoc' }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'pandoc', 'should pass lib to generateEpub')
+})
+
+test('epub command should open EPUB when --open flag is provided', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const outputPath = '/project/epubjs.epub'
+  const mockGenerateEpub = sandbox.stub().resolves(outputPath)
+  const mockOpen = sandbox.stub()
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: mockOpen
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs', open: true }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.true(mockOpen.called, 'open should be called when --open flag is provided')
+  t.is(mockOpen.firstCall.args[0], outputPath, 'should open the generated EPUB path')
+})
+
+test('epub command should not open EPUB when --open flag is not provided', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+  const mockOpen = sandbox.stub()
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: mockOpen
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs' }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.false(mockOpen.called, 'open should not be called without --open flag')
+})
+
+test('epub command should pass debug option to generateEpub', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs', debug: true }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'should pass lib to generateEpub')
+  t.true(mockGenerateEpub.firstCall.args[0].debug, 'should pass debug option')
+})
+
+test('epub command should throw MissingBuildOutputError when build output is missing', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      default: { getEpubDir: () => '_epub' },
+      hasEpubOutput: () => false
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  const error = await t.throwsAsync(() => command.action({ engine: 'epubjs' }, command))
+
+  t.is(error.code, 'BUILD_OUTPUT_MISSING', 'should throw BUILD_OUTPUT_MISSING error')
+  t.regex(error.message, /EPUB/, 'error should mention EPUB')
+  t.false(mockGenerateEpub.called, 'generateEpub should not be called when build output is missing')
+})
+
+test('epub command should run build first when --build flag is set and output missing', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+  const mockBuild = sandbox.stub().resolves()
+  let buildCalled = false
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => {
+        // Return false first (before build), true after build
+        if (!buildCalled) return false
+        return true
+      }
+    },
+    '#lib/11ty/index.js': {
+      default: {
+        build: async (opts) => {
+          buildCalled = true
+          return mockBuild(opts)
+        }
+      }
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs', build: true }, command)
+
+  t.true(mockBuild.called, 'build should be called when --build flag is set')
+  t.true(mockGenerateEpub.called, 'generateEpub should be called after build')
+})
+
+test('epub command should support deprecated --lib option', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/pandoc.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  // Use deprecated --lib option (should still work)
+  await command.action({ lib: 'pandoc' }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called with deprecated --lib')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'pandoc', 'should pass lib to generateEpub from deprecated option')
+})
+
+test('epub command should propagate errors from generateEpub', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const epubError = new Error('EPUB generation failed')
+  const mockGenerateEpub = sandbox.stub().rejects(epubError)
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  // Error is propagated; reporter lifecycle is handled by façade (lib/epub/index.js)
+  await t.throwsAsync(() => command.action({ engine: 'epubjs' }, command), { message: 'EPUB generation failed' })
+})
+
+test('epub command should configure reporter with quiet option', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs', quiet: true }, command)
+
+  t.true(
+    mockReporter.configure.calledWith(sinon.match({ quiet: true })),
+    'reporter.configure should be called with quiet option'
+  )
+})
+
+test('epub command should pass output option to generateEpub', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const customOutput = '/custom/path/my-book.epub'
+  const mockGenerateEpub = sandbox.stub().resolves(customOutput)
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+
+  await command.action({ engine: 'epubjs', output: customOutput }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].output, customOutput, 'should pass output option to generateEpub')
+})
+
+test('epub command should use epubEngine from config when --engine not specified', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/pandoc.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+  // Mock config to return 'pandoc' for epubEngine
+  command.config = { get: (key) => key === 'epubEngine' ? 'pandoc' : undefined }
+
+  // No --engine specified, should use config value
+  await command.action({}, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'pandoc', 'should use epubEngine from config')
+})
+
+test('epub command should use default engine when --engine not specified and config not set', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+  // Mock config to return undefined (no epubEngine set)
+  command.config = { get: () => undefined }
+
+  // No --engine specified, no config, should use default 'epubjs'
+  await command.action({}, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'should use default epubjs when no config')
+})
+
+test('epub command --engine flag should override config epubEngine', async (t) => {
+  const { sandbox, mockReporter } = t.context
+
+  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
+
+  const EPUBCommand = await esmock('./epub.js', {
+    '#lib/epub/index.js': {
+      default: mockGenerateEpub
+    },
+    '#lib/project/index.js': {
+      hasEpubOutput: () => true
+    },
+    '#lib/reporter/index.js': {
+      default: mockReporter
+    },
+    'fs-extra': {
+      existsSync: () => true
+    },
+    open: {
+      default: sandbox.stub()
+    }
+  })
+
+  const command = new EPUBCommand()
+  command.name = sandbox.stub().returns('epub')
+  // Mock config to return 'pandoc' for epubEngine
+  command.config = { get: (key) => key === 'epubEngine' ? 'pandoc' : undefined }
+
+  // --engine epubjs should override config's 'pandoc'
+  await command.action({ engine: 'epubjs' }, command)
+
+  t.true(mockGenerateEpub.called, 'generateEpub should be called')
+  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'CLI --engine should override config')
+})

package/src/commands/index.js

@@ -8,14 +8,21 @@ const __dirname = path.dirname(__filename)
 
 const thisfile = path.basename(__filename)
 
+/**
+ * Filter out files that are not command modules
+ * @param directory entry 
+ * @returns Boolean 
+ */
+const filterEntries = (entry) => entry !== thisfile && entry.match(/^.*(?<!spec|test)\.js$/)
+
 /**
  * Dynamically import command modules in parallel
  * and call the class constuctor for each command
  */
 const commands = await Promise.all(
   fs.readdirSync(__dirname)
-    .filter((file) => file !== thisfile && file.match(/^.*\.js$/))
-    .map(async (file) => await dynamicImport(path.resolve(__dirname, file)))
+    .filter((entry) => filterEntries(entry))
+    .map(async (entry) => await dynamicImport(path.resolve(__dirname, entry)))
 ).then((modules) => {
   return modules.map(({ default: CommandClass }) => new CommandClass())
 })

package/src/commands/info.js

@@ -1,5 +1,6 @@
 import Command from '#src/Command.js'
-import { execaCommand } from 'execa'
+import npm from '#lib/npm/index.js'
+import { execa } from 'execa'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
@@ -17,9 +18,13 @@ export default class InfoCommand extends Command {
   static definition = {
     name: 'info',
     description: 'List Quire cli, quire-11ty, and node versions',
-    summary: 'list info',
+    summary: 'show version information',
+    docsLink: 'quire-commands/#get-help',
+    helpText: `
+Example:
+  quire info --debug    Include node, npm, and OS versions
+`,
     version: '1.0.0',
-    args: [],
     options: [
       ['--debug', 'include os versions in output']
     ],
@@ -30,15 +35,7 @@ export default class InfoCommand extends Command {
   }
 
   async action(options, command) {
-    if (options.debug) {
-      console.debug(
-        '[CLI] Command \'%s\' called with options %o',
-        this.name(),
-        options
-      )
-    } else {
-      console.debug('[CLI] Command \'%s\' called', this.name())
-    }
+    this.debug('called with options %O', options)
 
     // Load filename from config with a default constraint if it doesn't exist
     const versionFileName = this.config.get('versionFile')
@@ -49,7 +46,7 @@ export default class InfoCommand extends Command {
 
       versionInfo = JSON.parse(versionFileData)      
     } catch (error) {
-      console.warn(
+      this.logger.warn(
         `This project was generated with the quire-cli prior to version 1.0.0.rc-8. Updating the version file to the new format, though this project's version file will not contain specific starter version information.`
       )
 
@@ -85,7 +82,7 @@ export default class InfoCommand extends Command {
           {
             name: 'quire-cli',
             get: async () => {
-              const { stdout } = await execaCommand('quire --version')
+              const { stdout } = await execa('quire', ['--version'])
               return stdout
             },
           },
@@ -97,10 +94,7 @@ export default class InfoCommand extends Command {
           {
             debug: true,
             name: 'npm',
-            get: async () => {
-              const { stdout } = await execaCommand('npm --version')
-              return stdout
-            },
+            get: async () => await npm.version(),
           },
           {
             debug: true,
@@ -114,17 +108,17 @@ export default class InfoCommand extends Command {
     /**
      * Filter the command output based on `debug` settings
      */
-    versions.forEach(async ({ items, title }) => {
-      const versions = await Promise.all(
+    for (const { items, title } of versions) {
+      const versionList = await Promise.all(
         items
           .filter(({ debug }) => !debug || (options.debug && debug))
           .map(async ({ name, get }) => `${name} ${await get()}`)
       )
-      console.info(`${title}\n ${versions.join('\n ')}`)
-    })
+      this.logger.info(`${title}\n ${versionList.join('\n ')}`)
+    }
   }
 
-  preAction(command) {
-    testcwd(command)
+  preAction(thisCommand, actionCommand) {
+    testcwd(thisCommand)
   }
 }

package/src/commands/info.spec.js

@@ -0,0 +1,64 @@
+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() === 'info')
+})
+
+test('command is registered in CLI program', (t) => {
+  const { command } = t.context
+
+  t.truthy(command, 'command "info" 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(), 'info')
+  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, 'info command should have no arguments')
+})
+
+test('registered command has correct options', (t) => {
+  const { command } = t.context
+
+  // Get all options
+  const debugOption = command.options.find((opt) => opt.long === '--debug')
+
+  // Verify all options exist
+  t.truthy(debugOption, '--debug option should exist')
+
+  // Verify they are Option instances
+  t.true(debugOption instanceof Option, '--debug should be Option instance')
+
+  // Verify option properties
+  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('--debug'))
+})