@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/setup/rollback.test.js

@@ -0,0 +1,452 @@
+#!/usr/bin/env node
+/**
+ * BOSS CLAUDE - Rollback System Tests
+ * Demonstrates rollback functionality and validates operations
+ */
+
+import { RollbackManager, SetupState, recordAction } from './rollback.js';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const TEST_DIR = path.join(os.tmpdir(), 'boss-claude-rollback-test');
+const TEST_STATE = path.join(TEST_DIR, 'test-state.json');
+
+/**
+ * Test utilities
+ */
+class TestRunner {
+  constructor() {
+    this.tests = [];
+    this.passed = 0;
+    this.failed = 0;
+  }
+
+  async test(name, fn) {
+    try {
+      console.log(chalk.blue(`\n▶ ${name}`));
+      await fn();
+      console.log(chalk.green(`  ✓ PASSED`));
+      this.passed++;
+    } catch (error) {
+      console.log(chalk.red(`  ✗ FAILED: ${error.message}`));
+      if (error.stack) {
+        console.log(chalk.gray(error.stack));
+      }
+      this.failed++;
+    }
+  }
+
+  summary() {
+    console.log(chalk.bold('\n' + '='.repeat(70)));
+    console.log(chalk.bold('TEST SUMMARY'));
+    console.log('='.repeat(70));
+    console.log(chalk.green(`  Passed: ${this.passed}`));
+    if (this.failed > 0) {
+      console.log(chalk.red(`  Failed: ${this.failed}`));
+    }
+    console.log(chalk.white(`  Total:  ${this.passed + this.failed}`));
+    console.log('='.repeat(70) + '\n');
+
+    return this.failed === 0;
+  }
+}
+
+/**
+ * Setup test environment
+ */
+async function setupTestEnv() {
+  if (existsSync(TEST_DIR)) {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+  }
+  await fs.mkdir(TEST_DIR, { recursive: true });
+}
+
+/**
+ * Cleanup test environment
+ */
+async function cleanupTestEnv() {
+  if (existsSync(TEST_DIR)) {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Test setup state tracking
+ */
+async function testSetupState(runner) {
+  await runner.test('SetupState - Save and Load', async () => {
+    const state = new SetupState();
+    state.state.actions.push({
+      type: 'test',
+      data: { foo: 'bar' },
+      timestamp: new Date().toISOString()
+    });
+
+    // Override state file path for testing
+    const originalStateFile = path.join(os.homedir(), '.boss-claude', 'setup-state.json');
+    const testStateFile = TEST_STATE;
+
+    // Save to test location
+    await fs.writeFile(testStateFile, JSON.stringify(state.state, null, 2));
+
+    // Load from test location
+    const loaded = JSON.parse(await fs.readFile(testStateFile, 'utf8'));
+
+    if (loaded.actions.length !== 1) {
+      throw new Error('Failed to save/load state');
+    }
+
+    if (loaded.actions[0].type !== 'test') {
+      throw new Error('State data mismatch');
+    }
+  });
+
+  await runner.test('SetupState - Record Action', async () => {
+    const state = new SetupState();
+    state.state.actions = [];
+
+    // Record multiple actions
+    state.state.actions.push({
+      type: 'github_repo',
+      data: { owner: 'test', repo: 'test-repo' },
+      timestamp: new Date().toISOString()
+    });
+
+    state.state.actions.push({
+      type: 'env_vars',
+      data: { keys: ['TEST_KEY'] },
+      timestamp: new Date().toISOString()
+    });
+
+    if (state.state.actions.length !== 2) {
+      throw new Error('Failed to record actions');
+    }
+  });
+
+  await runner.test('SetupState - Mark Completed', async () => {
+    const state = new SetupState();
+    state.state.completed = false;
+
+    state.state.completed = true;
+
+    if (!state.state.completed) {
+      throw new Error('Failed to mark completed');
+    }
+  });
+}
+
+/**
+ * Test file rollback
+ */
+async function testFileRollback(runner) {
+  await runner.test('File Rollback - Single File', async () => {
+    const testFile = path.join(TEST_DIR, 'test-file.txt');
+    await fs.writeFile(testFile, 'test content');
+
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollbackFiles({
+      data: { files: [testFile] }
+    });
+
+    if (!result.success) {
+      throw new Error('File rollback failed');
+    }
+
+    if (existsSync(testFile)) {
+      throw new Error('File was not deleted');
+    }
+  });
+
+  await runner.test('File Rollback - Multiple Files', async () => {
+    const files = [
+      path.join(TEST_DIR, 'file1.txt'),
+      path.join(TEST_DIR, 'file2.txt'),
+      path.join(TEST_DIR, 'file3.txt')
+    ];
+
+    for (const file of files) {
+      await fs.writeFile(file, 'test');
+    }
+
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollbackFiles({
+      data: { files }
+    });
+
+    if (!result.success) {
+      throw new Error('Multiple file rollback failed');
+    }
+
+    if (result.removed !== 3) {
+      throw new Error(`Expected 3 files removed, got ${result.removed}`);
+    }
+
+    for (const file of files) {
+      if (existsSync(file)) {
+        throw new Error(`File ${file} was not deleted`);
+      }
+    }
+  });
+
+  await runner.test('File Rollback - Missing File (Should Succeed)', async () => {
+    const nonExistentFile = path.join(TEST_DIR, 'does-not-exist.txt');
+
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollbackFiles({
+      data: { files: [nonExistentFile] }
+    });
+
+    if (!result.success) {
+      throw new Error('Should succeed for missing files');
+    }
+  });
+}
+
+/**
+ * Test directory rollback
+ */
+async function testDirectoryRollback(runner) {
+  await runner.test('Directory Rollback - Single Directory', async () => {
+    const testDir = path.join(TEST_DIR, 'test-subdir');
+    await fs.mkdir(testDir, { recursive: true });
+    await fs.writeFile(path.join(testDir, 'file.txt'), 'test');
+
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollbackDirectories({
+      data: { directories: [testDir] }
+    });
+
+    if (!result.success) {
+      throw new Error('Directory rollback failed');
+    }
+
+    if (existsSync(testDir)) {
+      throw new Error('Directory was not deleted');
+    }
+  });
+
+  await runner.test('Directory Rollback - Nested Directories', async () => {
+    const baseDir = path.join(TEST_DIR, 'nested');
+    const subDir = path.join(baseDir, 'level1', 'level2');
+    await fs.mkdir(subDir, { recursive: true });
+    await fs.writeFile(path.join(subDir, 'deep-file.txt'), 'test');
+
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollbackDirectories({
+      data: { directories: [baseDir] }
+    });
+
+    if (!result.success) {
+      throw new Error('Nested directory rollback failed');
+    }
+
+    if (existsSync(baseDir)) {
+      throw new Error('Base directory was not deleted');
+    }
+  });
+}
+
+/**
+ * Test dry run mode
+ */
+async function testDryRun(runner) {
+  await runner.test('Dry Run - Files Not Deleted', async () => {
+    const testFile = path.join(TEST_DIR, 'dry-run-test.txt');
+    await fs.writeFile(testFile, 'should not be deleted');
+
+    const manager = new RollbackManager({ verbose: false, dryRun: true });
+    const result = await manager.rollbackFiles({
+      data: { files: [testFile] }
+    });
+
+    if (!result.dryRun) {
+      throw new Error('Dry run flag not set in result');
+    }
+
+    if (!existsSync(testFile)) {
+      throw new Error('File was deleted in dry run mode!');
+    }
+
+    // Cleanup
+    await fs.unlink(testFile);
+  });
+
+  await runner.test('Dry Run - Directories Not Deleted', async () => {
+    const testDir = path.join(TEST_DIR, 'dry-run-dir');
+    await fs.mkdir(testDir, { recursive: true });
+
+    const manager = new RollbackManager({ verbose: false, dryRun: true });
+    const result = await manager.rollbackDirectories({
+      data: { directories: [testDir] }
+    });
+
+    if (!result.dryRun) {
+      throw new Error('Dry run flag not set in result');
+    }
+
+    if (!existsSync(testDir)) {
+      throw new Error('Directory was deleted in dry run mode!');
+    }
+
+    // Cleanup
+    await fs.rm(testDir, { recursive: true });
+  });
+}
+
+/**
+ * Test full rollback workflow
+ */
+async function testFullRollback(runner) {
+  await runner.test('Full Rollback - Multiple Action Types', async () => {
+    // Create test state
+    const state = {
+      timestamp: new Date().toISOString(),
+      completed: false,
+      actions: [
+        {
+          type: 'files',
+          data: {
+            files: [
+              path.join(TEST_DIR, 'rollback-file1.txt'),
+              path.join(TEST_DIR, 'rollback-file2.txt')
+            ]
+          },
+          timestamp: new Date().toISOString()
+        },
+        {
+          type: 'directories',
+          data: {
+            directories: [path.join(TEST_DIR, 'rollback-dir')]
+          },
+          timestamp: new Date().toISOString()
+        }
+      ]
+    };
+
+    // Create test files and directories
+    for (const file of state.actions[0].data.files) {
+      await fs.writeFile(file, 'test');
+    }
+    await fs.mkdir(state.actions[1].data.directories[0], { recursive: true });
+
+    // Save state
+    await fs.writeFile(TEST_STATE, JSON.stringify(state, null, 2));
+
+    // Execute rollback
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollback(TEST_STATE);
+
+    if (!result.success) {
+      throw new Error('Full rollback failed');
+    }
+
+    if (result.total !== 2) {
+      throw new Error(`Expected 2 actions, got ${result.total}`);
+    }
+
+    // Verify cleanup
+    for (const file of state.actions[0].data.files) {
+      if (existsSync(file)) {
+        throw new Error(`File ${file} was not deleted`);
+      }
+    }
+
+    for (const dir of state.actions[1].data.directories) {
+      if (existsSync(dir)) {
+        throw new Error(`Directory ${dir} was not deleted`);
+      }
+    }
+  });
+}
+
+/**
+ * Test error handling
+ */
+async function testErrorHandling(runner) {
+  await runner.test('Error Handling - Invalid Action Type', async () => {
+    const manager = new RollbackManager({ verbose: false });
+    const result = await manager.rollbackAction({
+      type: 'invalid_type',
+      data: {},
+      timestamp: new Date().toISOString()
+    });
+
+    if (result.success) {
+      throw new Error('Should fail for invalid action type');
+    }
+  });
+
+  await runner.test('Error Handling - Permission Denied', async () => {
+    // This test is platform-specific and may not work everywhere
+    // Skip on systems where we can't test permissions
+    const testFile = path.join(TEST_DIR, 'permission-test.txt');
+    await fs.writeFile(testFile, 'test');
+
+    try {
+      await fs.chmod(testFile, 0o000); // Remove all permissions
+
+      const manager = new RollbackManager({ verbose: false });
+      const result = await manager.rollbackFiles({
+        data: { files: [testFile] }
+      });
+
+      // Result may succeed or fail depending on permissions model
+      // Just verify it handles the case without crashing
+
+      // Cleanup - restore permissions first
+      await fs.chmod(testFile, 0o644);
+      await fs.unlink(testFile);
+    } catch (error) {
+      // Permission tests may not work on all systems
+      console.log(chalk.gray(`    Skipped: ${error.message}`));
+    }
+  });
+}
+
+/**
+ * Main test execution
+ */
+async function runTests() {
+  console.log(chalk.bold.cyan('\n🧪 BOSS CLAUDE ROLLBACK TESTS\n'));
+
+  const runner = new TestRunner();
+
+  try {
+    // Setup
+    await setupTestEnv();
+
+    // Run test suites
+    await testSetupState(runner);
+    await testFileRollback(runner);
+    await testDirectoryRollback(runner);
+    await testDryRun(runner);
+    await testFullRollback(runner);
+    await testErrorHandling(runner);
+
+    // Cleanup
+    await cleanupTestEnv();
+
+    // Summary
+    const success = runner.summary();
+
+    process.exit(success ? 0 : 1);
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n✗ Test execution failed\n'));
+    console.error(chalk.red(error.message));
+    console.error(chalk.gray(error.stack));
+
+    await cleanupTestEnv();
+    process.exit(1);
+  }
+}
+
+// Run tests if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runTests();
+}
+
+export { runTests, TestRunner };