xget/test/index.test.js

import { SELF } from 'cloudflare:test';
import { beforeEach, describe, expect, it } from 'vitest';

describe('Xget Core Functionality', () => {
  let env;

  beforeEach(() => {
    env = {};
  });

  describe('Basic Request Handling', () => {
    it('should return 404 for root path', async () => {
      const response = await SELF.fetch('https://example.com/');
      expect(response.status).toBe(404);
    });

    it('should return 400 for invalid platform prefix', async () => {
      const response = await SELF.fetch('https://example.com/invalid/test');
      expect(response.status).toBe(400);
    });

    it('should include security headers in all responses', async () => {
      const response = await SELF.fetch('https://example.com/');
      
      expect(response.headers.get('Strict-Transport-Security')).toBeTruthy();
      expect(response.headers.get('X-Frame-Options')).toBe('DENY');
      expect(response.headers.get('X-XSS-Protection')).toBe('1; mode=block');
      expect(response.headers.get('Content-Security-Policy')).toBeTruthy();
      expect(response.headers.get('Referrer-Policy')).toBe('strict-origin-when-cross-origin');
    });
  });

  describe('Platform URL Transformation', () => {
    it('should handle GitHub URLs correctly', async () => {
      const testUrl = 'https://example.com/gh/microsoft/vscode/archive/refs/heads/main.zip';
      const response = await SELF.fetch(testUrl, { method: 'HEAD' });
      
      // Should attempt to proxy to GitHub
      expect(response.status).not.toBe(400);
    });

    it('should handle GitLab URLs correctly', async () => {
      const testUrl = 'https://example.com/gl/gitlab-org/gitlab/-/archive/master/gitlab-master.zip';
      const response = await SELF.fetch(testUrl, { method: 'HEAD' });
      
      // Should attempt to proxy to GitLab
      expect(response.status).not.toBe(400);
    });

    it('should handle Hugging Face URLs correctly', async () => {
      const testUrl = 'https://example.com/hf/microsoft/DialoGPT-medium/resolve/main/config.json';
      const response = await SELF.fetch(testUrl, { method: 'HEAD' });
      
      // Should attempt to proxy to Hugging Face
      expect(response.status).not.toBe(400);
    });

    it('should handle npm URLs correctly', async () => {
      const testUrl = 'https://example.com/npm/react/-/react-18.2.0.tgz';
      const response = await SELF.fetch(testUrl, { method: 'HEAD' });
      
      // Should attempt to proxy to npm
      expect(response.status).not.toBe(400);
    });

    it('should handle PyPI URLs correctly', async () => {
      const testUrl = 'https://example.com/pypi/packages/source/r/requests/requests-2.31.0.tar.gz';
      const response = await SELF.fetch(testUrl, { method: 'HEAD' });
      
      // Should attempt to proxy to PyPI
      expect(response.status).not.toBe(400);
    });

    it('should handle conda URLs correctly', async () => {
      const testUrl = 'https://example.com/conda/pkgs/main/linux-64/numpy-1.24.3-py311h08b1b3b_1.conda';
      const response = await SELF.fetch(testUrl, { method: 'HEAD' });
      
      // Should attempt to proxy to conda
      expect(response.status).not.toBe(400);
    });
  });

  describe('HTTP Method Validation', () => {
    it('should allow GET requests', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo/file.txt', {
        method: 'GET'
      });
      
      expect(response.status).not.toBe(405);
    });

    it('should allow HEAD requests', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo/file.txt', {
        method: 'HEAD'
      });
      
      expect(response.status).not.toBe(405);
    });

    it('should reject PUT requests for non-Git operations', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo/file.txt', {
        method: 'PUT'
      });
      
      expect(response.status).toBe(405);
    });

    it('should reject DELETE requests', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo/file.txt', {
        method: 'DELETE'
      });
      
      expect(response.status).toBe(405);
    });
  });

  describe('Git Protocol Support', () => {
    it('should allow POST for Git upload-pack', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo.git/git-upload-pack', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-git-upload-pack-request',
          'User-Agent': 'git/2.34.1'
        }
      });
      
      expect(response.status).not.toBe(405);
    });

    it('should allow POST for Git receive-pack', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo.git/git-receive-pack', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-git-receive-pack-request',
          'User-Agent': 'git/2.34.1'
        }
      });
      
      expect(response.status).not.toBe(405);
    });

    it('should handle Git info/refs requests', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo.git/info/refs?service=git-upload-pack', {
        method: 'GET',
        headers: {
          'User-Agent': 'git/2.34.1'
        }
      });
      
      expect(response.status).not.toBe(405);
    });
  });

  describe('Path Length Validation', () => {
    it('should reject extremely long paths', async () => {
      const longPath = '/gh/' + 'a'.repeat(3000);
      const response = await SELF.fetch(`https://example.com${longPath}`);
      
      expect(response.status).toBe(414);
    });

    it('should accept normal length paths', async () => {
      const normalPath = '/gh/microsoft/vscode/archive/refs/heads/main.zip';
      const response = await SELF.fetch(`https://example.com${normalPath}`);
      
      expect(response.status).not.toBe(414);
    });
  });

  describe('Performance Headers', () => {
    it('should include performance metrics in response headers', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo/file.txt');
      
      expect(response.headers.get('X-Performance-Metrics')).toBeTruthy();
    });

    it('should include valid JSON in performance metrics', async () => {
      const response = await SELF.fetch('https://example.com/gh/test/repo/file.txt');
      const metricsHeader = response.headers.get('X-Performance-Metrics');
      
      expect(() => JSON.parse(metricsHeader)).not.toThrow();
    });
  });
});