xget/test/setup.js

/**
 * Test setup and global configuration
 */

import { afterAll, afterEach, beforeAll, beforeEach } from 'vitest';

// Global test configuration
const TEST_CONFIG = {
  timeout: 30000, // 30 seconds
  retries: 2,
  bail: false
};

// Global test state
let testStartTime;
let testMetrics = {
  totalTests: 0,
  passedTests: 0,
  failedTests: 0,
  skippedTests: 0
};

/**
 * Global setup - runs once before all tests
 */
beforeAll(async () => {
  console.log('🚀 Starting Xget test suite...');
  testStartTime = Date.now();

  // Initialize test environment
  await setupTestEnvironment();

  // Verify test dependencies
  await verifyTestDependencies();

  console.log('✅ Test environment initialized');
});

/**
 * Global teardown - runs once after all tests
 */
afterAll(async () => {
  const duration = Date.now() - testStartTime;

  console.log('\n📊 Test Suite Summary:');
  console.log(`   Duration: ${duration}ms`);
  console.log(`   Total: ${testMetrics.totalTests}`);
  console.log(`   Passed: ${testMetrics.passedTests}`);
  console.log(`   Failed: ${testMetrics.failedTests}`);
  console.log(`   Skipped: ${testMetrics.skippedTests}`);

  // Cleanup test environment
  await cleanupTestEnvironment();

  console.log('🏁 Test suite completed');
});

/**
 * Setup before each test
 */
beforeEach(async context => {
  testMetrics.totalTests++;

  // Reset any global state
  resetGlobalState();

  // Setup test-specific environment
  await setupTestCase(context);
});

/**
 * Cleanup after each test
 */
afterEach(async context => {
  // Update test metrics based on result
  if (context.meta?.result === 'pass') {
    testMetrics.passedTests++;
  } else if (context.meta?.result === 'fail') {
    testMetrics.failedTests++;
  } else if (context.meta?.result === 'skip') {
    testMetrics.skippedTests++;
  }

  // Cleanup test-specific resources
  await cleanupTestCase(context);
});

/**
 * Setup test environment
 */
async function setupTestEnvironment() {
  // Verify Cloudflare Workers environment
  if (typeof globalThis.fetch === 'undefined') {
    throw new Error('fetch is not available in test environment');
  }

  // Setup global test utilities
  globalThis.TEST_CONFIG = TEST_CONFIG;

  // Initialize performance monitoring
  if (typeof performance === 'undefined') {
    globalThis.performance = {
      now: () => Date.now()
    };
  }

  // Setup console overrides for testing
  setupConsoleOverrides();
}

/**
 * Verify test dependencies
 */
async function verifyTestDependencies() {
  const requiredGlobals = ['Request', 'Response', 'Headers', 'URL', 'URLSearchParams'];

  for (const global of requiredGlobals) {
    if (typeof globalThis[global] === 'undefined') {
      throw new Error(`Required global ${global} is not available`);
    }
  }

  // Verify SELF is available for Cloudflare Workers testing
  try {
    const { SELF } = await import('cloudflare:test');
    if (!SELF) {
      throw new Error('SELF is not available');
    }
  } catch (error) {
    console.warn('Warning: Cloudflare Workers test environment not available');
  }
}

/**
 * Setup console overrides for testing
 */
function setupConsoleOverrides() {
  const originalConsole = { ...console };

  // Store original console methods
  globalThis.originalConsole = originalConsole;

  // Override console methods for testing
  console.warn = (...args) => {
    if (process.env.NODE_ENV !== 'test' || process.env.VERBOSE_TESTS) {
      originalConsole.warn(...args);
    }
  };

  console.log = (...args) => {
    if (process.env.NODE_ENV !== 'test' || process.env.VERBOSE_TESTS) {
      originalConsole.log(...args);
    }
  };
}

/**
 * Reset global state between tests
 */
function resetGlobalState() {
  // Clear any cached data
  if (globalThis.testCache) {
    globalThis.testCache.clear();
  }

  // Reset performance counters
  if (globalThis.testPerformance) {
    globalThis.testPerformance.reset();
  }
}

/**
 * Setup individual test case
 */
async function setupTestCase(context) {
  // Create test-specific cache
  globalThis.testCache = new Map();

  // Setup test-specific performance monitoring
  globalThis.testPerformance = {
    marks: new Map(),
    mark: name => {
      globalThis.testPerformance.marks.set(name, performance.now());
    },
    measure: (name, startMark, endMark) => {
      const start = globalThis.testPerformance.marks.get(startMark) || 0;
      const end = globalThis.testPerformance.marks.get(endMark) || performance.now();
      return end - start;
    },
    reset: () => {
      globalThis.testPerformance.marks.clear();
    }
  };

  // Mark test start time
  globalThis.testPerformance.mark('test-start');
}

/**
 * Cleanup individual test case
 */
async function cleanupTestCase(context) {
  // Mark test end time
  globalThis.testPerformance.mark('test-end');

  // Log test performance if verbose
  if (process.env.VERBOSE_TESTS) {
    const duration = globalThis.testPerformance.measure('test-duration', 'test-start', 'test-end');
    console.log(`Test "${context.meta?.name}" took ${duration.toFixed(2)}ms`);
  }

  // Cleanup test-specific resources
  if (globalThis.testCache) {
    globalThis.testCache.clear();
  }

  if (globalThis.testPerformance) {
    globalThis.testPerformance.reset();
  }
}

/**
 * Cleanup test environment
 */
async function cleanupTestEnvironment() {
  // Restore original console
  if (globalThis.originalConsole) {
    Object.assign(console, globalThis.originalConsole);
    delete globalThis.originalConsole;
  }

  // Cleanup global test utilities
  delete globalThis.TEST_CONFIG;
  delete globalThis.testCache;
  delete globalThis.testPerformance;
}

/**
 * Custom test utilities available globally
 */
globalThis.testUtils = {
  /**
   * Create a test timeout
   */
  timeout: ms =>
    new Promise((_, reject) => {
      setTimeout(() => reject(new Error(`Test timed out after ${ms}ms`)), ms);
    }),

  /**
   * Wait for a condition to be true
   */
  waitFor: async (condition, timeout = 5000, interval = 100) => {
    const start = Date.now();

    while (Date.now() - start < timeout) {
      if (await condition()) {
        return true;
      }
      await new Promise(resolve => setTimeout(resolve, interval));
    }

    throw new Error(`Condition not met within ${timeout}ms`);
  },

  /**
   * Retry a function with exponential backoff
   */
  retry: async (fn, maxRetries = 3, baseDelay = 100) => {
    let lastError;

    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn();
      } catch (error) {
        lastError = error;

        if (i < maxRetries - 1) {
          const delay = baseDelay * Math.pow(2, i);
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      }
    }

    throw lastError;
  }
};

// Export test configuration for use in other files
export { TEST_CONFIG, testMetrics };