@aerocorp/cli/tests/integration.js

AeroCorp CLI 7.0.5 - Future-Proofed AI-Powered Infrastructure Platform with Quantum Security & Agentic Automation (2025-2035)

#!/usr/bin/env node

/**
 * 🧪 AeroCorp CLI 5.1.0 - Comprehensive Integration Tests
 * Testing all advanced features: AI, GitOps, Edge Computing, Quantum Security
 */

const { execSync } = require('child_process');
const chalk = require('chalk');
const fs = require('fs-extra');
const path = require('path');

class TestRunner {
  constructor() {
    this.passed = 0;
    this.failed = 0;
    this.tests = [];
  }

  async runTest(name, testFn) {
    console.log(chalk.blue(`🧪 Testing: ${name}`));

    try {
      await testFn();
      console.log(chalk.green(`✅ PASSED: ${name}`));
      this.passed++;
      this.tests.push({ name, status: 'PASSED' });
    } catch (error) {
      console.log(chalk.red(`❌ FAILED: ${name}`));
      console.log(chalk.red(`   Error: ${error.message}`));
      this.failed++;
      this.tests.push({ name, status: 'FAILED', error: error.message });
    }
  }

  displayResults() {
    console.log(chalk.cyan('\n🧪 Test Results Summary:'));
    console.log(chalk.cyan('========================'));
    console.log(chalk.green(`✅ Passed: ${this.passed}`));
    console.log(chalk.red(`❌ Failed: ${this.failed}`));
    console.log(chalk.blue(`📊 Total: ${this.passed + this.failed}`));

    if (this.failed === 0) {
      console.log(chalk.green('\n🎉 All tests passed! CLI is ready for deployment.'));
      console.log(chalk.blue('🚀 AeroCorp CLI 5.1.0 - Future-Proofed for 2030'));
    } else {
      console.log(chalk.yellow('\n⚠️  Some tests failed. Please review before deployment.'));
    }

    return this.failed === 0;
  }
}

async function runIntegrationTests() {
  console.log(chalk.cyan('╔═══════════════════════════════════════════════╗'));
  console.log(chalk.cyan('║  AeroCorp CLI 3.0.0 - Integration Tests      ║'));
  console.log(chalk.cyan('╚═══════════════════════════════════════════════╝'));
  console.log(chalk.blue('🤖 AI • 🔮 GitOps • 🌐 Edge • 🔐 Quantum Security'));

  const runner = new TestRunner();
  const cliPath = path.join(__dirname, '..', 'src', 'cli.js');

  // 🧪 Test 1: CLI Executable
  await runner.runTest('CLI Executable', async () => {
    if (!fs.existsSync(cliPath)) {
      throw new Error('CLI file does not exist');
    }

    const stats = fs.statSync(cliPath);
    if (!stats.isFile()) {
      throw new Error('CLI path is not a file');
    }
  });

  // 🧪 Test 2: Version Command
  await runner.runTest('Version Command', async () => {
    try {
      const output = execSync(`node "${cliPath}" version`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('5.1.0')) {
        throw new Error('Version output does not contain 5.1.0');
      }
      if (!output.includes('Future-Proofed')) {
        throw new Error('Version output missing future-proofed message');
      }
    } catch (error) {
      if (error.status) {
        throw new Error(`Command failed with exit code ${error.status}`);
      }
      throw error;
    }
  });

  // 🧪 Test 3: Help Command
  await runner.runTest('Help Command', async () => {
    try {
      const output = execSync(`node "${cliPath}" --help`, { encoding: 'utf8', timeout: 10000 });
      const requiredCommands = ['login', 'deploy', 'health', 'ai', 'gitops', 'edge', 'config'];

      for (const cmd of requiredCommands) {
        if (!output.includes(cmd)) {
          throw new Error(`Help output missing command: ${cmd}`);
        }
      }
    } catch (error) {
      if (error.status && error.status !== 0) {
        // Help command might exit with status 0 or 1, both are acceptable
        if (error.status !== 1) {
          throw new Error(`Help command failed with unexpected exit code ${error.status}`);
        }
      } else if (!error.status) {
        throw error;
      }
    }
  });

  // 🧪 Test 4: Status Command
  await runner.runTest('Status Command', async () => {
    try {
      const output = execSync(`node "${cliPath}" status`, { encoding: 'utf8', timeout: 15000 });
      if (!output.includes('System Status')) {
        throw new Error('Status output missing system status information');
      }
    } catch (error) {
      if (error.status) {
        throw new Error(`Status command failed with exit code ${error.status}`);
      }
      throw error;
    }
  });

  // 🧪 Test 5: AI Commands
  await runner.runTest('AI Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" ai --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('analyze') || !output.includes('optimize')) {
        throw new Error('AI commands missing analyze or optimize subcommands');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`AI help command failed with exit code ${error.status}`);
      }
    }
  });

  // 🧪 Test 6: GitOps Commands
  await runner.runTest('GitOps Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" gitops --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('init') || !output.includes('sync') || !output.includes('status')) {
        throw new Error('GitOps commands missing required subcommands');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`GitOps help command failed with exit code ${error.status}`);
      }
    }
  });

  // 🧪 Test 7: Edge Computing Commands
  await runner.runTest('Edge Computing Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" edge --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('regions') || !output.includes('deploy')) {
        throw new Error('Edge commands missing required subcommands');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`Edge help command failed with exit code ${error.status}`);
      }
    }
  });

  // 🧪 Test 8: Configuration Commands
  await runner.runTest('Configuration Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" config --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('get') || !output.includes('set') || !output.includes('list')) {
        throw new Error('Config commands missing required subcommands');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`Config help command failed with exit code ${error.status}`);
      }
    }
  });

  // 🧪 Test 9: Security Commands
  await runner.runTest('Security Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" security --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('scan') || !output.includes('compliance')) {
        throw new Error('Security commands missing required subcommands');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`Security help command failed with exit code ${error.status}`);
      }
    }
  });

  // 🧪 Test 10: Package.json Validation
  await runner.runTest('Package.json Validation', async () => {
    const packagePath = path.join(__dirname, '..', 'package.json');
    if (!fs.existsSync(packagePath)) {
      throw new Error('package.json does not exist');
    }

    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));

    if (pkg.version !== '5.1.0') {
      throw new Error(`Package version is ${pkg.version}, expected 5.1.0`);
    }

    if (!pkg.description.includes('Future-Proofed')) {
      throw new Error('Package description missing Future-Proofed reference');
    }

    const requiredKeywords = ['ai-ml', 'gitops', 'edge-computing', 'quantum-security'];
    for (const keyword of requiredKeywords) {
      if (!pkg.keywords.includes(keyword)) {
        throw new Error(`Package missing keyword: ${keyword}`);
      }
    }
  });

  // 🧪 Test 11: Dependencies Check
  await runner.runTest('Dependencies Check', async () => {
    const packagePath = path.join(__dirname, '..', 'package.json');
    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));

    const requiredDeps = ['commander', 'chalk', 'boxen', 'axios', 'inquirer', 'ora', 'yaml', 'node-cron', 'semver'];

    for (const dep of requiredDeps) {
      if (!pkg.dependencies[dep]) {
        throw new Error(`Missing required dependency: ${dep}`);
      }
    }
  });

  // 🧪 Test 12: File Structure
  await runner.runTest('File Structure', async () => {
    const requiredFiles = [
      'package.json',
      'src/cli.js',
      'AGENTIC_DEV_GUIDE.md',
      'tests/integration.js'
    ];

    for (const file of requiredFiles) {
      const filePath = path.join(__dirname, '..', file);
      if (!fs.existsSync(filePath)) {
        throw new Error(`Required file missing: ${file}`);
      }
    }
  });

  // 🧪 Test 13: Security Features
  await runner.runTest('Security Features Test', async () => {
    try {
      const output = execSync(`node "${cliPath}" security scan`, { encoding: 'utf8', timeout: 15000 });
      if (!output.includes('security scan') && !output.includes('Security')) {
        throw new Error('Security scan output missing expected content');
      }
    } catch (error) {
      if (error.status) {
        throw new Error(`Security scan failed with exit code ${error.status}`);
      }
      throw error;
    }
  });

  // 🧪 Test 14: Monitoring Commands
  await runner.runTest('Monitoring Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" monitor --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('status') || !output.includes('alerts')) {
        throw new Error('Monitor commands missing required subcommands');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`Monitor help command failed with exit code ${error.status}`);
      }
    }
  });

  // 🧪 Test 15: Serverless Commands
  await runner.runTest('Serverless Commands', async () => {
    try {
      const output = execSync(`node "${cliPath}" serverless --help`, { encoding: 'utf8', timeout: 10000 });
      if (!output.includes('deploy')) {
        throw new Error('Serverless commands missing deploy subcommand');
      }
    } catch (error) {
      if (error.status && error.status !== 1) {
        throw new Error(`Serverless help command failed with exit code ${error.status}`);
      }
    }
  });

  return runner.displayResults();
}

// 🚀 Run tests if called directly
if (require.main === module) {
  runIntegrationTests()
    .then((success) => {
      process.exit(success ? 0 : 1);
    })
    .catch((error) => {
      console.error(chalk.red(`❌ Test runner failed: ${error.message}`));
      process.exit(1);
    });
}

module.exports = { runIntegrationTests };