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

package/src/lib/doctor/formatters/json.test.js

@@ -0,0 +1,174 @@
+/**
+ * Tests for JSON formatter
+ */
+import test from 'ava'
+import { formatJson } from './json.js'
+
+const mockSections = [
+  {
+    section: 'Environment',
+    results: [
+      { id: 'os', name: 'Operating system', ok: true, message: 'macOS 14' },
+      { id: 'node', name: 'Node.js', ok: false, level: 'error', message: 'v18 (requires v22)', remediation: 'Upgrade Node.js', docsUrl: 'https://example.com/docs' },
+    ],
+  },
+  {
+    section: 'Project',
+    results: [
+      { id: 'deps', name: 'Dependencies', ok: false, level: 'warn', message: 'Outdated' },
+      { id: 'build', name: 'Build', ok: true, level: 'na', message: 'No build yet' },
+      { id: 'data', name: 'Data', ok: false, level: 'timeout', message: 'Timed out' },
+    ],
+  },
+]
+
+test('formatJson returns valid JSON string', (t) => {
+  const { json } = formatJson(mockSections)
+  t.notThrows(() => JSON.parse(json))
+})
+
+test('formatJson includes summary counts', (t) => {
+  const { json } = formatJson(mockSections)
+  const output = JSON.parse(json)
+  t.deepEqual(output.summary, {
+    passed: 1,
+    failed: 1,
+    warnings: 1,
+    timeouts: 1,
+    na: 1,
+    total: 5,
+  })
+})
+
+test('formatJson includes all results with correct structure', (t) => {
+  const { json } = formatJson(mockSections)
+  const output = JSON.parse(json)
+  t.is(output.results.length, 5)
+
+  const osCheck = output.results.find((c) => c.id === 'os')
+  t.deepEqual(osCheck, {
+    id: 'os',
+    name: 'Operating system',
+    section: 'Environment',
+    status: 'passed',
+    message: 'macOS 14',
+  })
+})
+
+test('formatJson includes remediation and docsUrl for failed checks', (t) => {
+  const { json } = formatJson(mockSections)
+  const output = JSON.parse(json)
+
+  const nodeCheck = output.results.find((c) => c.id === 'node')
+  t.is(nodeCheck.remediation, 'Upgrade Node.js')
+  t.is(nodeCheck.docsUrl, 'https://example.com/docs')
+})
+
+test('formatJson returns exitCode 1 when checks fail', (t) => {
+  const { exitCode } = formatJson(mockSections)
+  t.is(exitCode, 1)
+})
+
+test('formatJson returns exitCode 0 when no checks fail', (t) => {
+  const healthySections = [
+    {
+      section: 'Environment',
+      results: [{ id: 'os', name: 'OS', ok: true }],
+    },
+  ]
+  const { exitCode } = formatJson(healthySections)
+  t.is(exitCode, 0)
+})
+
+test('formatJson with errors filter includes only failed checks', (t) => {
+  const { json } = formatJson(mockSections, { errors: true })
+  const output = JSON.parse(json)
+  t.is(output.results.length, 1)
+  t.is(output.results[0].id, 'node')
+  t.is(output.results[0].status, 'failed')
+})
+
+test('formatJson with warnings filter includes only warning checks', (t) => {
+  const { json } = formatJson(mockSections, { warnings: true })
+  const output = JSON.parse(json)
+  t.is(output.results.length, 1)
+  t.is(output.results[0].id, 'deps')
+  t.is(output.results[0].status, 'warning')
+})
+
+test('formatJson summary reflects unfiltered counts when --errors filter is active', (t) => {
+  const { json, exitCode } = formatJson(mockSections, { errors: true })
+  const output = JSON.parse(json)
+  // results array is filtered to errors only
+  t.is(output.results.length, 1)
+  // summary counts reflect all results
+  t.is(output.summary.passed, 1)
+  t.is(output.summary.failed, 1)
+  t.is(output.summary.warnings, 1)
+  t.is(output.summary.total, 5)
+  t.is(exitCode, 1)
+})
+
+test('formatJson summary reflects unfiltered counts when --warnings filter is active', (t) => {
+  const { json, exitCode } = formatJson(mockSections, { warnings: true })
+  const output = JSON.parse(json)
+  // results array is filtered to warnings only
+  t.is(output.results.length, 1)
+  // summary counts reflect all results, including the error
+  t.is(output.summary.failed, 1)
+  t.is(output.summary.warnings, 1)
+  t.is(output.summary.total, 5)
+  t.is(exitCode, 1)
+})
+
+test('formatJson omits filter property when no filter is active', (t) => {
+  const { json } = formatJson(mockSections)
+  const output = JSON.parse(json)
+  t.is(output.filter, undefined)
+})
+
+test('formatJson includes filter property with --errors', (t) => {
+  const { json } = formatJson(mockSections, { errors: true })
+  const output = JSON.parse(json)
+  t.deepEqual(output.filter, ['errors'])
+})
+
+test('formatJson includes filter property with --warnings', (t) => {
+  const { json } = formatJson(mockSections, { warnings: true })
+  const output = JSON.parse(json)
+  t.deepEqual(output.filter, ['warnings'])
+})
+
+test('formatJson includes filter property with both --errors and --warnings', (t) => {
+  const { json } = formatJson(mockSections, { errors: true, warnings: true })
+  const output = JSON.parse(json)
+  t.deepEqual(output.filter, ['errors', 'warnings'])
+})
+
+test('formatJson with verbose includes details', (t) => {
+  const sectionsWithDetails = [
+    {
+      section: 'Environment',
+      results: [
+        { id: 'os', name: 'OS', ok: true, message: 'macOS', details: '/usr/bin' },
+      ],
+    },
+  ]
+  const { json } = formatJson(sectionsWithDetails, { verbose: true })
+  const output = JSON.parse(json)
+  t.is(output.results[0].details, '/usr/bin')
+})
+
+test('formatJson without verbose excludes details', (t) => {
+  const sectionsWithDetails = [
+    {
+      section: 'Environment',
+      results: [
+        { id: 'os', name: 'OS', ok: true, message: 'macOS', details: '/usr/bin' },
+      ],
+    },
+  ]
+  const { json } = formatJson(sectionsWithDetails, { verbose: false })
+  const output = JSON.parse(json)
+  t.is(output.results[0].details, undefined)
+})

package/src/lib/doctor/formatters/shared.js

@@ -0,0 +1,129 @@
+/**
+ * Shared utilities for doctor output formatters
+ *
+ * @module lib/doctor/formatters/shared
+ */
+import chalk from 'chalk'
+
+/**
+ * Default terminal width when stdout is not a TTY (piped/redirected)
+ * @type {number}
+ */
+const DEFAULT_COLUMNS = 80
+
+/**
+ * Get the current terminal width
+ *
+ * Falls back to DEFAULT_COLUMNS when stdout is not a TTY
+ * (e.g., piped to a file or another process).
+ *
+ * @returns {number} Terminal width in columns
+ */
+export function getTerminalWidth() {
+  return process.stdout.columns || DEFAULT_COLUMNS
+}
+
+/**
+ * Status types for check results
+ * @typedef {'passed'|'failed'|'warning'|'timeout'|'na'} CheckStatus
+ */
+
+/**
+ * Colored status icons for check results (for terminal output)
+ */
+export const STATUS_ICONS = {
+  passed: chalk.green('✓'),
+  failed: chalk.red('✗'),
+  warning: chalk.yellow('⚠'),
+  timeout: chalk.magenta('⏱'),
+  na: chalk.gray('○'),
+}
+
+/**
+ * Determine the status string for a check result
+ * @param {Object} result - Check result with ok and level properties
+ * @returns {CheckStatus}
+ */
+export function getStatus(result) {
+  if (result.level === 'na') return 'na'
+  if (result.level === 'timeout') return 'timeout'
+  if (result.ok) return 'passed'
+  if (result.level === 'warn') return 'warning'
+  return 'failed'
+}
+
+/**
+ * Count results by status
+ * @param {Array} sections - Check results organized by section
+ * @param {Object} [options] - Filter options
+ * @param {boolean} [options.errors] - Only count failed checks
+ * @param {boolean} [options.warnings] - Only count warning checks
+ * @returns {{passed: number, failed: number, warnings: number, timeouts: number, na: number, total: number}}
+ */
+export function countResults(sections, options = {}) {
+  let passed = 0
+  let failed = 0
+  let warnings = 0
+  let timeouts = 0
+  let na = 0
+
+  for (const { results } of sections) {
+    for (const result of results) {
+      const status = getStatus(result)
+
+      // Apply filters
+      if (options.errors && options.warnings) {
+        if (status !== 'failed' && status !== 'warning') continue
+      } else {
+        if (options.errors && status !== 'failed') continue
+        if (options.warnings && status !== 'warning') continue
+      }
+
+      // Count by status
+      if (status === 'passed') passed++
+      else if (status === 'failed') failed++
+      else if (status === 'warning') warnings++
+      else if (status === 'timeout') timeouts++
+      else if (status === 'na') na++
+    }
+  }
+
+  return {
+    passed,
+    failed,
+    warnings,
+    timeouts,
+    na,
+    total: passed + failed + warnings + timeouts + na,
+  }
+}
+
+/**
+ * Filter results based on options
+ * @param {Array} sections - Check results organized by section
+ * @param {Object} [options] - Filter options
+ * @param {boolean} [options.errors] - Only include failed checks
+ * @param {boolean} [options.warnings] - Only include warning checks
+ * @returns {Array} Filtered sections (only sections with results after filtering)
+ */
+export function filterResults(sections, options = {}) {
+  const filtered = []
+
+  for (const { section, results } of sections) {
+    const filteredResults = results.filter((result) => {
+      const status = getStatus(result)
+      if (options.errors && options.warnings) {
+        return status === 'failed' || status === 'warning'
+      }
+      if (options.errors && status !== 'failed') return false
+      if (options.warnings && status !== 'warning') return false
+      return true
+    })
+
+    if (filteredResults.length > 0) {
+      filtered.push({ section, results: filteredResults })
+    }
+  }
+
+  return filtered
+}

package/src/lib/doctor/formatters/shared.test.js

@@ -0,0 +1,194 @@
+/**
+ * Tests for shared formatter utilities
+ */
+import test from 'ava'
+import { getStatus, STATUS_ICONS, countResults, filterResults, getTerminalWidth } from './shared.js'
+
+// =============================================================================
+// getStatus tests
+// =============================================================================
+
+test('getStatus returns "na" for level na', (t) => {
+  t.is(getStatus({ ok: true, level: 'na' }), 'na')
+  t.is(getStatus({ ok: false, level: 'na' }), 'na')
+})
+
+test('getStatus returns "timeout" for level timeout', (t) => {
+  t.is(getStatus({ ok: false, level: 'timeout' }), 'timeout')
+})
+
+test('getStatus returns "passed" when ok is true', (t) => {
+  t.is(getStatus({ ok: true }), 'passed')
+  t.is(getStatus({ ok: true, level: 'error' }), 'passed')
+})
+
+test('getStatus returns "warning" for level warn when not ok', (t) => {
+  t.is(getStatus({ ok: false, level: 'warn' }), 'warning')
+})
+
+test('getStatus returns "failed" for level error when not ok', (t) => {
+  t.is(getStatus({ ok: false, level: 'error' }), 'failed')
+  t.is(getStatus({ ok: false }), 'failed')
+})
+
+// =============================================================================
+// STATUS_ICONS tests
+// =============================================================================
+
+test('STATUS_ICONS has all required status types', (t) => {
+  t.truthy(STATUS_ICONS.passed)
+  t.truthy(STATUS_ICONS.failed)
+  t.truthy(STATUS_ICONS.warning)
+  t.truthy(STATUS_ICONS.timeout)
+  t.truthy(STATUS_ICONS.na)
+})
+
+test('STATUS_ICONS are strings containing expected characters', (t) => {
+  // Strip ANSI codes to check actual characters
+  const stripAnsi = (str) => str.replace(/\u001b\[[0-9;]*m/g, '')
+  t.is(stripAnsi(STATUS_ICONS.passed), '✓')
+  t.is(stripAnsi(STATUS_ICONS.failed), '✗')
+  t.is(stripAnsi(STATUS_ICONS.warning), '⚠')
+  t.is(stripAnsi(STATUS_ICONS.timeout), '⏱')
+  t.is(stripAnsi(STATUS_ICONS.na), '○')
+})
+
+// =============================================================================
+// countResults tests
+// =============================================================================
+
+const mockSections = [
+  {
+    section: 'Environment',
+    results: [
+      { id: 'os', ok: true },
+      { id: 'cli', ok: true },
+      { id: 'node', ok: false, level: 'error' },
+    ],
+  },
+  {
+    section: 'Project',
+    results: [
+      { id: 'project', ok: false, level: 'warn' },
+      { id: 'deps', ok: true, level: 'na' },
+      { id: 'data', ok: false, level: 'timeout' },
+    ],
+  },
+]
+
+test('countResults counts all status types correctly', (t) => {
+  const counts = countResults(mockSections)
+  t.is(counts.passed, 2)
+  t.is(counts.failed, 1)
+  t.is(counts.warnings, 1)
+  t.is(counts.timeouts, 1)
+  t.is(counts.na, 1)
+  t.is(counts.total, 6)
+})
+
+test('countResults with errors filter counts only failed', (t) => {
+  const counts = countResults(mockSections, { errors: true })
+  t.is(counts.failed, 1)
+  t.is(counts.passed, 0)
+  t.is(counts.warnings, 0)
+  t.is(counts.total, 1)
+})
+
+test('countResults with warnings filter counts only warnings', (t) => {
+  const counts = countResults(mockSections, { warnings: true })
+  t.is(counts.warnings, 1)
+  t.is(counts.passed, 0)
+  t.is(counts.failed, 0)
+  t.is(counts.total, 1)
+})
+
+// =============================================================================
+// filterResults tests
+// =============================================================================
+
+test('filterResults returns all results when no filter applied', (t) => {
+  const filtered = filterResults(mockSections)
+  t.is(filtered.length, 2)
+  t.is(filtered[0].results.length, 3)
+  t.is(filtered[1].results.length, 3)
+})
+
+test('filterResults with errors filter returns only failed checks', (t) => {
+  const filtered = filterResults(mockSections, { errors: true })
+  t.is(filtered.length, 1) // Only Environment section has failed check
+  t.is(filtered[0].section, 'Environment')
+  t.is(filtered[0].results.length, 1)
+  t.is(filtered[0].results[0].id, 'node')
+})
+
+test('filterResults with warnings filter returns only warning checks', (t) => {
+  const filtered = filterResults(mockSections, { warnings: true })
+  t.is(filtered.length, 1) // Only Project section has warning check
+  t.is(filtered[0].section, 'Project')
+  t.is(filtered[0].results.length, 1)
+  t.is(filtered[0].results[0].id, 'project')
+})
+
+test('countResults with both errors and warnings filter counts failed and warnings', (t) => {
+  const counts = countResults(mockSections, { errors: true, warnings: true })
+  t.is(counts.failed, 1)
+  t.is(counts.warnings, 1)
+  t.is(counts.passed, 0)
+  t.is(counts.timeouts, 0)
+  t.is(counts.na, 0)
+  t.is(counts.total, 2)
+})
+
+test('filterResults with both errors and warnings returns failed and warning checks', (t) => {
+  const filtered = filterResults(mockSections, { errors: true, warnings: true })
+  t.is(filtered.length, 2) // Both sections have matching checks
+  // Environment has failed check
+  t.is(filtered[0].section, 'Environment')
+  t.is(filtered[0].results.length, 1)
+  t.is(filtered[0].results[0].id, 'node')
+  // Project has warning check
+  t.is(filtered[1].section, 'Project')
+  t.is(filtered[1].results.length, 1)
+  t.is(filtered[1].results[0].id, 'project')
+})
+
+test('filterResults excludes empty sections', (t) => {
+  const sections = [
+    { section: 'A', results: [{ ok: true }] },
+    { section: 'B', results: [{ ok: true }] },
+  ]
+  const filtered = filterResults(sections, { errors: true })
+  t.is(filtered.length, 0)
+})
+
+// =============================================================================
+// getTerminalWidth tests
+// =============================================================================
+
+test('getTerminalWidth returns a positive number', (t) => {
+  const width = getTerminalWidth()
+  t.is(typeof width, 'number')
+  t.true(width > 0)
+})
+
+test('getTerminalWidth returns at least 80 when not a TTY', (t) => {
+  // In test environments stdout is typically not a TTY,
+  // so columns is undefined and the fallback (80) is used
+  const original = process.stdout.columns
+  process.stdout.columns = undefined
+  try {
+    t.is(getTerminalWidth(), 80)
+  } finally {
+    process.stdout.columns = original
+  }
+})
+
+test('getTerminalWidth returns stdout.columns when available', (t) => {
+  const original = process.stdout.columns
+  process.stdout.columns = 120
+  try {
+    t.is(getTerminalWidth(), 120)
+  } finally {
+    process.stdout.columns = original
+  }
+})