agentsqripts/cli/lib/argumentParser.test.js

Comprehensive static code analysis toolkit for identifying technical debt, security vulnerabilities, performance issues, and code quality problems

/**
 * @file Unit tests for CLI argument parser utility
 * @description Tests argument parsing, validation, and error handling for CLI tools
 */

const { parseArgs } = require('./argumentParser');
const qtests = require('qtests');

/**
 * Test runner for argument parser
 */
async function runTests() {
  console.log('=== Testing CLI Argument Parser ===');
  
  const results = {
    total: 0,
    passed: 0
  };

  // Test basic argument parsing
  results.total++;
  try {
    const testArgs = ['node', 'script.js', '/path/to/target', '--extensions', '.js,.ts', '--output-format', 'json'];
    const { options, targetPath, error } = parseArgs(testArgs, {
      defaults: {
        extensions: ['.js'],
        outputFormat: 'summary'
      },
      flags: {
        extensions: { type: 'list' },
        outputFormat: { type: 'string' }
      }
    });

    qtests.assert(error === null, 'parseArgs should not return error for valid args');
    qtests.assert(targetPath === '/path/to/target', 'parseArgs should extract target path');
    qtests.assert(options.extensions.includes('.js'), 'parseArgs should parse extension list');
    qtests.assert(options.outputFormat === 'json', 'parseArgs should parse output format');
    
    console.log('✓ parseArgs correctly parses valid arguments');
    results.passed++;
  } catch (error) {
    console.log(`✗ parseArgs basic test failed: ${error.message}`);
  }

  // Test default values
  results.total++;
  try {
    const testArgs = ['node', 'script.js', '/path/to/target'];
    const { options, error } = parseArgs(testArgs, {
      defaults: {
        extensions: ['.js'],
        outputFormat: 'summary'
      }
    });

    qtests.assert(error === null, 'parseArgs should not return error for minimal args');
    qtests.assert(Array.isArray(options.extensions), 'parseArgs should use default extensions');
    qtests.assert(options.outputFormat === 'summary', 'parseArgs should use default output format');
    
    console.log('✓ parseArgs correctly applies default values');
    results.passed++;
  } catch (error) {
    console.log(`✗ parseArgs defaults test failed: ${error.message}`);
  }

  // Test validation errors
  results.total++;
  try {
    const testArgs = ['node', 'script.js', '/path/to/target', '--output-format', 'invalid'];
    const { error } = parseArgs(testArgs, {
      defaults: { outputFormat: 'summary' },
      flags: {
        outputFormat: { 
          type: 'string', 
          validate: (v) => ['json', 'summary', 'detailed'].includes(v)
        }
      }
    });

    qtests.assert(error !== null, 'parseArgs should return error for invalid values');
    qtests.assert(error.includes('outputFormat'), 'parseArgs error should mention the invalid field');
    
    console.log('✓ parseArgs correctly validates argument values');
    results.passed++;
  } catch (error) {
    console.log(`✗ parseArgs validation test failed: ${error.message}`);
  }

  // Test list parsing
  results.total++;
  try {
    const testArgs = ['node', 'script.js', '/path', '--extensions', '.js,.ts,.jsx'];
    const { options } = parseArgs(testArgs, {
      flags: {
        extensions: { type: 'list' }
      }
    });

    qtests.assert(Array.isArray(options.extensions), 'parseArgs should create array for list type');
    qtests.assert(options.extensions.length === 3, 'parseArgs should parse all list items');
    qtests.assert(options.extensions.includes('.jsx'), 'parseArgs should include all list items');
    
    console.log('✓ parseArgs correctly parses list arguments');
    results.passed++;
  } catch (error) {
    console.log(`✗ parseArgs list parsing test failed: ${error.message}`);
  }

  // Test missing target path error
  results.total++;
  try {
    const testArgs = ['node', 'script.js'];
    const { error } = parseArgs(testArgs, {});

    qtests.assert(error !== null, 'parseArgs should return error for missing target path');
    qtests.assert(error.includes('target path'), 'parseArgs error should mention missing target path');
    
    console.log('✓ parseArgs correctly handles missing target path');
    results.passed++;
  } catch (error) {
    console.log(`✗ parseArgs missing target test failed: ${error.message}`);
  }

  console.log(`=== Argument Parser Test Results ===`);
  console.log(`Tests passed: ${results.passed}/${results.total}`);
  console.log(`Success rate: ${((results.passed / results.total) * 100).toFixed(1)}%`);

  return results;
}

module.exports = { runTests };