@vltpkg/vsr 0.2.0 → 0.2.1

package/test/route-with-waituntil.test.js

@@ -1,298 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-// Mock config
-const CONFIG = {
-  DOMAIN: 'registry.npmjs.org',
-  PROXY_PACKAGES: ['fastify', 'hono']
-};
-
-/**
- * This test demonstrates testing an actual route handler that uses
- * the Hono context and waitUntil, with proper mocking of both.
- */
-describe('Route Handler with waitUntil', () => {
-  /**
-   * Creates a mock Hono context with necessary properties
-   */
-  function createMockContext(options = {}) {
-    // Track background task functions
-    const backgroundTaskFns = [];
-    let responseData = null;
-    let responseStatus = 200;
-    let responseHeaders = {};
-    let wasJsonCalled = false;
-
-    // Default options
-    const defaults = {
-      params: { packageName: 'test-package' },
-      fresh: false,
-      cacheData: null,
-      upstreamData: { name: 'test-package', version: '1.0.0' },
-      upstreamError: null
-    };
-
-    const opts = { ...defaults, ...options };
-
-    // Mock fetch function
-    const mockFetch = vi.fn().mockImplementation(async (url) => {
-      if (opts.upstreamError) {
-        throw opts.upstreamError;
-      }
-      return {
-        json: async () => opts.upstreamData,
-        status: 200,
-        ok: true
-      };
-    });
-
-    // Mock DB
-    const mockDb = {
-      get: vi.fn().mockImplementation(async (key) => {
-        if (!opts.cacheData) return null;
-
-        return {
-          value: opts.cacheData,
-          timestamp: opts.fresh
-            ? Date.now() - 60000  // 1 minute old (fresh)
-            : Date.now() - 3600000 // 1 hour old (stale)
-        };
-      }),
-      set: vi.fn()
-    };
-
-    // Create context
-    return {
-      // Request info
-      req: {
-        url: `https://registry.npmjs.org/${opts.params.packageName}`,
-        fresh: opts.fresh
-      },
-
-      // Route parameters
-      params: opts.params,
-
-      // Database methods
-      db: mockDb,
-
-      // Response methods
-      status: vi.fn((code) => {
-        responseStatus = code;
-        return context;
-      }),
-
-      header: vi.fn((name, value) => {
-        responseHeaders[name] = value;
-        return context;
-      }),
-
-      json: vi.fn((data) => {
-        responseData = data;
-        wasJsonCalled = true;
-        return context;
-      }),
-
-      // Execution context for background tasks
-      executionCtx: {
-        waitUntil: vi.fn((promise) => {
-          // Instead of accepting the promise directly, we'll store a function
-          // that will return the promise when called
-          const promiseCreator = () => promise;
-          backgroundTaskFns.push(promiseCreator);
-        })
-      },
-
-      // Utility methods for testing
-      runBackgroundTasks: async () => {
-        const tasks = [...backgroundTaskFns];
-        backgroundTaskFns.length = 0;
-
-        for (const taskFn of tasks) {
-          try {
-            await taskFn();
-          } catch (error) {
-            console.error('Background task error:', error);
-          }
-        }
-      },
-
-      getResponse: () => ({
-        data: responseData,
-        status: responseStatus,
-        headers: responseHeaders,
-        wasJsonCalled
-      }),
-
-      // Expose methods for testing
-      fetch: mockFetch,
-      backgroundTaskFns
-    };
-  }
-
-  // The context needs to be accessible in tests
-  let context;
-
-  /**
-   * This is a simplified version of getPackageMetadata that demonstrates
-   * the stale-while-revalidate caching pattern
-   */
-  async function getPackageMetadata(c) {
-    const { packageName } = c.params;
-
-    try {
-      // Try to get from cache first
-      const cachedData = await c.db.get(`package:${packageName}`);
-
-      if (cachedData) {
-        const isStale = Date.now() - cachedData.timestamp > 5 * 60 * 1000;
-
-        if (!isStale) {
-          // Return fresh cached data
-          return c.json(cachedData.value);
-        }
-
-        // Return stale data, but refresh in background
-        c.executionCtx.waitUntil(new Promise(async (resolve) => {
-          // In a real implementation this executes immediately
-          // In our test, we'll capture the function and run it later
-          const bgRefresh = async () => {
-            try {
-              const response = await c.fetch(`https://${CONFIG.DOMAIN}/${packageName}`);
-              const freshData = await response.json();
-
-              await c.db.set(`package:${packageName}`, {
-                value: freshData,
-                timestamp: Date.now()
-              });
-
-              resolve();
-            } catch (error) {
-              console.error(`Error refreshing ${packageName}:`, error);
-              resolve();
-            }
-          };
-
-          // Don't call bgRefresh() directly, we'll run it during runBackgroundTasks
-          setTimeout(bgRefresh, 0);
-        }));
-
-        // Return stale data immediately
-        return c.json(cachedData.value);
-      }
-
-      // Not in cache, fetch directly
-      const response = await c.fetch(`https://${CONFIG.DOMAIN}/${packageName}`);
-      const packageData = await response.json();
-
-      // Store in cache
-      await c.db.set(`package:${packageName}`, {
-        value: packageData,
-        timestamp: Date.now()
-      });
-
-      return c.json(packageData);
-    } catch (error) {
-      // Handle upstream errors gracefully
-      console.error(`Error fetching ${packageName}:`, error);
-      return c.status(500).json({
-        error: `Failed to fetch package: ${packageName}`,
-        message: error.message
-      });
-    }
-  }
-
-  describe('getPackageMetadata', () => {
-    beforeEach(() => {
-      vi.clearAllMocks();
-    });
-
-    it('should return cached data if fresh', async () => {
-      // Create mock context with fresh cached data
-      context = createMockContext({
-        fresh: true,
-        cacheData: { name: 'test-package', version: '1.0.0' }
-      });
-
-      // Execute the handler
-      await getPackageMetadata(context);
-
-      const { data } = context.getResponse();
-
-      // Verify
-      expect(context.db.get).toHaveBeenCalledWith('package:test-package');
-      expect(context.fetch).not.toHaveBeenCalled();
-      expect(data).toEqual({ name: 'test-package', version: '1.0.0' });
-      expect(context.backgroundTaskFns.length).toBe(0);
-    });
-
-    it('should return stale data and refresh in background', async () => {
-      // Setup context with stale data
-      context = createMockContext({
-        fresh: false,
-        cacheData: { name: 'test-package', version: '1.0.0' },
-        upstreamData: { name: 'test-package', version: '1.0.1' }
-      });
-
-      // Execute the handler
-      await getPackageMetadata(context);
-
-      const { data } = context.getResponse();
-
-      // Verify initial response
-      expect(context.db.get).toHaveBeenCalledWith('package:test-package');
-      expect(context.fetch).not.toHaveBeenCalled(); // Not yet called
-      expect(data).toEqual({ name: 'test-package', version: '1.0.0' });
-      expect(context.backgroundTaskFns.length).toBe(1);
-
-      // Now run background tasks
-      await context.runBackgroundTasks();
-
-      // Verify background refresh
-      expect(context.fetch).toHaveBeenCalledWith('https://registry.npmjs.org/test-package');
-      expect(context.db.set).toHaveBeenCalledWith('package:test-package', {
-        value: { name: 'test-package', version: '1.0.1' },
-        timestamp: expect.any(Number)
-      });
-    });
-
-    it('should fetch directly if not in cache', async () => {
-      // Setup context with no cached data
-      context = createMockContext({
-        cacheData: null,
-        upstreamData: { name: 'test-package', version: '1.0.1' }
-      });
-
-      // Execute the handler
-      await getPackageMetadata(context);
-
-      const { data } = context.getResponse();
-
-      // Verify
-      expect(context.db.get).toHaveBeenCalledWith('package:test-package');
-      expect(context.fetch).toHaveBeenCalledWith('https://registry.npmjs.org/test-package');
-      expect(data).toEqual({ name: 'test-package', version: '1.0.1' });
-      expect(context.backgroundTaskFns.length).toBe(0);
-    });
-
-    it('should handle upstream errors gracefully', async () => {
-      // Setup context with error
-      context = createMockContext({
-        cacheData: null,
-        upstreamError: new Error('Network error')
-      });
-
-      // Execute the handler
-      await getPackageMetadata(context);
-
-      const { data, status } = context.getResponse();
-
-      // Verify
-      expect(context.db.get).toHaveBeenCalledWith('package:test-package');
-      expect(context.fetch).toThrow;
-      expect(status).toBe(500);
-      expect(data).toEqual({
-        error: 'Failed to fetch package: test-package',
-        message: 'Network error'
-      });
-    });
-  });
-});

package/test/run-tests.js

@@ -1,151 +0,0 @@
-const { spawn } = require('child_process')
-const { execSync } = require('child_process')
-const { setTimeout } = require('timers')
-
-function sleep(ms) {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms)
-  })
-}
-
-async function waitForServer(url, maxAttempts = 5) {
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      const response = await fetch(url, {
-        headers: {
-          'User-Agent': 'vlt-serverless-registry-test'
-        }
-      })
-      if (response.ok) {
-        console.log('Server is ready!')
-        return true
-      }
-    } catch (err) {
-      console.log(`Waiting for server to start... (attempt ${i + 1}/${maxAttempts})`)
-      await new Promise(resolve => setTimeout(resolve, 2000)) // Wait 2 seconds between attempts
-    }
-  }
-  throw new Error('Server failed to start')
-}
-
-async function runTests() {
-  let wrangler = null
-  let vitest = null
-  let testTimeout = null
-
-  // Function to clean up processes
-  const cleanup = async () => {
-    console.log('Cleaning up processes...')
-    if (testTimeout) {
-      clearTimeout(testTimeout)
-      testTimeout = null
-    }
-    if (wrangler) {
-      wrangler.kill()
-      wrangler = null
-    }
-    if (vitest) {
-      vitest.kill()
-      vitest = null
-    }
-  }
-
-  // Handle process termination
-  const handleTermination = async () => {
-    console.log('Received termination signal, cleaning up...')
-    await cleanup()
-    process.exit(0)
-  }
-
-  process.on('SIGINT', handleTermination)
-  process.on('SIGTERM', handleTermination)
-
-  try {
-    // Kill any existing wrangler processes
-    try {
-      execSync('pkill -f wrangler', { stdio: 'ignore' })
-    } catch (err) {
-      // Ignore errors if no process was found
-    }
-
-    // Setup test database
-    console.log('Setting up test database...')
-    execSync('npm run test:setup', { stdio: 'inherit' })
-
-    // Start wrangler dev server
-    console.log('Starting wrangler dev server...')
-    wrangler = spawn('wrangler', ['dev', '--local', '--persist-to', 'local-store', '--experimental-json-config'], {
-      stdio: ['pipe', 'pipe', 'pipe']
-    })
-
-    let serverStarted = false
-    let serverError = null
-
-    // Handle server output
-    wrangler.stdout.on('data', (data) => {
-      const output = data.toString().trim()
-      console.log(`[Wrangler] ${output}`)
-
-      // Check for server ready message
-      if (output.includes('Ready in') || output.includes('Listening on')) {
-        serverStarted = true
-      }
-    })
-
-    wrangler.stderr.on('data', (data) => {
-      const output = data.toString().trim()
-      console.error(`[Wrangler Error] ${output}`)
-
-      // Check for common errors
-      if (output.includes('Error') || output.includes('Failed')) {
-        serverError = output
-      }
-    })
-
-    // Wait for server to start
-    try {
-      await waitForServer('http://localhost:1337')
-    } catch (err) {
-      console.error('Failed to start server:', err)
-      if (serverError) {
-        console.error('Server error:', serverError)
-      }
-      await cleanup()
-      process.exit(1)
-    }
-
-    // Run vitest
-    console.log('Running tests...')
-    vitest = spawn('vitest', ['run', '--no-watch'], {
-      stdio: 'inherit',
-      env: {
-        ...process.env,
-        NODE_ENV: 'test',
-        VITEST_MAX_TIMEOUT: '120000' // 2 minutes
-      }
-    })
-
-    // Set a timeout for the entire test process
-    testTimeout = setTimeout(() => {
-      console.error('Tests timed out after 120 seconds')
-      cleanup().then(() => process.exit(1))
-    }, 120000)
-
-    // Wait for vitest to complete
-    vitest.on('close', async (code) => {
-      console.log('Tests completed')
-      await cleanup()
-      process.exit(code)
-    })
-
-  } catch (err) {
-    console.error('Test runner failed:', err)
-    await cleanup()
-    process.exit(1)
-  }
-}
-
-runTests().catch((err) => {
-  console.error('Test runner failed:', err)
-  process.exit(1)
-})

package/test/setup-cache-tests.js

@@ -1,190 +0,0 @@
-import { vi, afterAll } from 'vitest';
-
-// Setup mock global objects for testing
-// This runs before the tests to provide necessary mocks
-
-// Mock global web standard objects that are available in Cloudflare Workers
-// but not in Node.js test environment
-
-// Mock Request class if not available
-if (typeof Request === 'undefined') {
-  global.Request = class Request {
-    constructor(input, init) {
-      this.url = input;
-      this.method = (init?.method || 'GET').toUpperCase();
-      this.headers = new Headers(init?.headers);
-      this.body = init?.body;
-      this.json = async () => {
-        if (typeof this.body === 'string') {
-          return JSON.parse(this.body);
-        } else if (this.body && typeof this.body.json === 'function') {
-          return this.body.json();
-        }
-        return undefined;
-      };
-      this.text = async () => {
-        if (typeof this.body === 'string') {
-          return this.body;
-        } else if (this.body && typeof this.body.text === 'function') {
-          return this.body.text();
-        }
-        return '';
-      };
-      this.arrayBuffer = async () => new ArrayBuffer(0);
-      this.formData = async () => new FormData();
-      this.blob = async () => new Blob();
-    }
-
-    get path() {
-      try {
-        return new URL(this.url).pathname;
-      } catch (e) {
-        return this.url;
-      }
-    }
-  };
-}
-
-// Mock Response class if not available
-if (typeof Response === 'undefined') {
-  global.Response = class Response {
-    constructor(body, init) {
-      this.body = body;
-      this.status = init?.status || 200;
-      this.statusText = init?.statusText || '';
-      this.headers = new Headers(init?.headers);
-      this.ok = this.status >= 200 && this.status < 300;
-      this.type = 'default';
-      this.redirected = false;
-      this.url = '';
-      this._bodyUsed = false;
-    }
-
-    get bodyUsed() {
-      return this._bodyUsed;
-    }
-
-    async arrayBuffer() {
-      this._bodyUsed = true;
-      if (this.body instanceof ArrayBuffer) return this.body;
-      if (typeof this.body === 'string') {
-        const encoder = new TextEncoder();
-        return encoder.encode(this.body).buffer;
-      }
-      return new ArrayBuffer(0);
-    }
-
-    async text() {
-      this._bodyUsed = true;
-      if (typeof this.body === 'string') return this.body;
-      if (this.body && typeof this.body.text === 'function') return this.body.text();
-      if (this.body && typeof this.body === 'object') return JSON.stringify(this.body);
-      return '';
-    }
-
-    async json() {
-      this._bodyUsed = true;
-      if (typeof this.body === 'string') return JSON.parse(this.body);
-      if (this.body && typeof this.body.json === 'function') return this.body.json();
-      if (this.body && typeof this.body === 'object') return this.body;
-      return {};
-    }
-
-    clone() {
-      return new Response(this.body, {
-        status: this.status,
-        statusText: this.statusText,
-        headers: new Headers(this.headers)
-      });
-    }
-  };
-}
-
-// Mock Headers class if not available
-if (typeof Headers === 'undefined') {
-  global.Headers = class Headers {
-    constructor(init) {
-      this._headers = new Map();
-      if (init) {
-        if (init instanceof Headers) {
-          init.forEach((value, key) => {
-            this.append(key, value);
-          });
-        } else if (Array.isArray(init)) {
-          init.forEach(([key, value]) => {
-            this.append(key, value);
-          });
-        } else if (typeof init === 'object') {
-          Object.entries(init).forEach(([key, value]) => {
-            this.append(key, value);
-          });
-        }
-      }
-    }
-
-    append(name, value) {
-      name = name.toLowerCase();
-      if (this._headers.has(name)) {
-        this._headers.set(name, `${this._headers.get(name)}, ${value}`);
-      } else {
-        this._headers.set(name, value);
-      }
-    }
-
-    delete(name) {
-      this._headers.delete(name.toLowerCase());
-    }
-
-    get(name) {
-      return this._headers.get(name.toLowerCase()) || null;
-    }
-
-    has(name) {
-      return this._headers.has(name.toLowerCase());
-    }
-
-    set(name, value) {
-      this._headers.set(name.toLowerCase(), value);
-    }
-
-    forEach(callback) {
-      this._headers.forEach((value, key) => {
-        callback(value, key, this);
-      });
-    }
-  };
-}
-
-// Mock TransformStream if not available
-if (typeof TransformStream === 'undefined') {
-  global.TransformStream = class TransformStream {
-    constructor() {
-      this.readable = {
-        getReader: () => ({
-          read: async () => ({ done: true, value: undefined }),
-          cancel: async () => {}
-        })
-      };
-      this.writable = {
-        getWriter: () => ({
-          write: async () => {},
-          close: async () => {},
-          abort: async () => {}
-        })
-      };
-    }
-  };
-}
-
-// Mock console to avoid noise in tests
-const originalConsole = { ...console };
-console.debug = vi.fn();
-console.log = vi.fn();
-console.info = vi.fn();
-// Keep error and warn for debugging
-
-// Clean up all mocks after tests are done
-afterAll(() => {
-  vi.restoreAllMocks();
-  Object.assign(console, originalConsole);
-});

package/test/setup.js

@@ -1,64 +0,0 @@
-import { beforeAll, afterAll } from 'vitest'
-import { execSync } from 'child_process'
-
-// Mock environment variables needed for testing
-beforeAll(() => {
-  process.env.DOMAIN = 'http://localhost:0'
-  process.env.PROXY = 'true'
-  process.env.PROXY_URL = 'https://registry.npmjs.org'
-
-  // Setup test database
-  try {
-    execSync('npm run test:setup', { stdio: 'inherit' })
-  } catch (err) {
-    console.error('Failed to setup test database:', err)
-    process.exit(1)
-  }
-
-  // Mock the Cloudflare Workers environment
-  globalThis.env = {
-    DB: {
-      prepare: async (query) => ({
-        bind: async (...args) => ({
-          run: async () => {
-            // For token validation
-            if (query.includes('SELECT * FROM tokens')) {
-              return {
-                results: [{
-                  token: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
-                  uuid: 'admin',
-                  scope: JSON.stringify([
-                    {
-                      values: ['*'],
-                      types: {
-                        pkg: { read: true, write: true },
-                        user: { read: true, write: true }
-                      }
-                    }
-                  ])
-                }]
-              }
-            }
-            return { results: [] }
-          }
-        })
-      })
-    },
-    BUCKET: {
-      get: async () => null,
-      put: async () => {}
-    },
-    executionCtx: {
-      waitUntil: (promise) => promise
-    }
-  }
-})
-
-afterAll(() => {
-  // Cleanup test database
-  try {
-    execSync('npm run test:cleanup', { stdio: 'inherit' })
-  } catch (err) {
-    console.error('Failed to cleanup test database:', err)
-  }
-})