@vltpkg/vsr 0.2.0 → 0.2.2

package/test/stale-while-revalidate.test.js

@@ -1,273 +0,0 @@
-/**
- * Test suite for stale-while-revalidate cache strategy
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { getCachedPackageWithRefresh, getCachedVersionWithRefresh } from '../src/utils/cache.ts'
-
-describe('Stale-while-revalidate cache strategy', () => {
-  let mockContext
-  let mockFetchUpstream
-  let mockQueue
-
-  beforeEach(() => {
-    // Mock database operations
-    const mockDb = {
-      getCachedPackage: vi.fn(),
-      upsertCachedPackage: vi.fn(),
-      getCachedVersion: vi.fn(),
-      upsertCachedVersion: vi.fn()
-    }
-
-    // Mock Cloudflare Queue
-    mockQueue = {
-      send: vi.fn().mockResolvedValue(true)
-    }
-
-    // Mock context
-    mockContext = {
-      db: mockDb,
-      env: {
-        CACHE_REFRESH_QUEUE: mockQueue
-      },
-      waitUntil: vi.fn()
-    }
-
-    // Mock upstream fetch function
-    mockFetchUpstream = vi.fn().mockResolvedValue({
-      'dist-tags': { latest: '1.0.0' },
-      versions: { '1.0.0': { name: 'test-package', version: '1.0.0' } },
-      time: { modified: new Date().toISOString() }
-    })
-  })
-
-  describe('getCachedPackageWithRefresh', () => {
-    it('should return fresh cache data immediately without queuing refresh', async () => {
-      // Mock fresh cache data (within TTL)
-      const freshCacheTime = new Date(Date.now() - 2 * 60 * 1000) // 2 minutes ago
-      mockContext.db.getCachedPackage.mockResolvedValue({
-        name: 'test-package',
-        tags: { latest: '1.0.0' },
-        origin: 'upstream',
-        cachedAt: freshCacheTime.toISOString()
-      })
-
-      const result = await getCachedPackageWithRefresh(
-        mockContext,
-        'test-package',
-        mockFetchUpstream,
-        { packumentTtlMinutes: 5 }
-      )
-
-      expect(result.fromCache).toBe(true)
-      expect(result.stale).toBe(false)
-      expect(mockQueue.send).not.toHaveBeenCalled()
-      expect(mockFetchUpstream).not.toHaveBeenCalled()
-    })
-
-    it('should return stale cache data and queue background refresh', async () => {
-      // Mock stale cache data (beyond TTL but within stale window)
-      const staleCacheTime = new Date(Date.now() - 10 * 60 * 1000) // 10 minutes ago
-      mockContext.db.getCachedPackage.mockResolvedValue({
-        name: 'test-package',
-        tags: { latest: '1.0.0' },
-        origin: 'upstream',
-        cachedAt: staleCacheTime.toISOString()
-      })
-
-      const result = await getCachedPackageWithRefresh(
-        mockContext,
-        'test-package',
-        mockFetchUpstream,
-        {
-          packumentTtlMinutes: 5,
-          staleWhileRevalidateMinutes: 60
-        }
-      )
-
-      expect(result.fromCache).toBe(true)
-      expect(result.stale).toBe(true)
-      expect(mockQueue.send).toHaveBeenCalledWith({
-        type: 'package_refresh',
-        packageName: 'test-package',
-        upstream: 'npm',
-        timestamp: expect.any(Number),
-        options: {
-          packumentTtlMinutes: 5,
-          upstream: 'npm'
-        }
-      })
-      expect(mockFetchUpstream).not.toHaveBeenCalled()
-    })
-
-    it('should fetch upstream synchronously when no cache exists', async () => {
-      // Mock no cache data
-      mockContext.db.getCachedPackage.mockResolvedValue(null)
-
-      const result = await getCachedPackageWithRefresh(
-        mockContext,
-        'test-package',
-        mockFetchUpstream,
-        { packumentTtlMinutes: 5 }
-      )
-
-      expect(result.fromCache).toBe(false)
-      expect(result.stale).toBe(false)
-      expect(mockFetchUpstream).toHaveBeenCalled()
-      expect(mockContext.waitUntil).toHaveBeenCalled()
-    })
-
-    it('should fallback to waitUntil when queue is not available', async () => {
-      // Remove queue from context
-      mockContext.env.CACHE_REFRESH_QUEUE = null
-
-      // Mock stale cache data
-      const staleCacheTime = new Date(Date.now() - 10 * 60 * 1000)
-      mockContext.db.getCachedPackage.mockResolvedValue({
-        name: 'test-package',
-        tags: { latest: '1.0.0' },
-        origin: 'upstream',
-        cachedAt: staleCacheTime.toISOString()
-      })
-
-      const result = await getCachedPackageWithRefresh(
-        mockContext,
-        'test-package',
-        mockFetchUpstream,
-        {
-          packumentTtlMinutes: 5,
-          staleWhileRevalidateMinutes: 60
-        }
-      )
-
-      expect(result.fromCache).toBe(true)
-      expect(result.stale).toBe(true)
-      expect(mockContext.waitUntil).toHaveBeenCalled()
-    })
-
-    it('should handle very stale cache data (beyond stale window)', async () => {
-      // Mock very stale cache data (beyond stale window)
-      const veryOldCacheTime = new Date(Date.now() - 2 * 60 * 60 * 1000) // 2 hours ago
-      mockContext.db.getCachedPackage.mockResolvedValue({
-        name: 'test-package',
-        tags: { latest: '1.0.0' },
-        origin: 'upstream',
-        cachedAt: veryOldCacheTime.toISOString()
-      })
-
-      const result = await getCachedPackageWithRefresh(
-        mockContext,
-        'test-package',
-        mockFetchUpstream,
-        {
-          packumentTtlMinutes: 5,
-          staleWhileRevalidateMinutes: 60 // 1 hour stale window
-        }
-      )
-
-      // Should fetch fresh data since cache is beyond stale window
-      expect(result.fromCache).toBe(false)
-      expect(mockFetchUpstream).toHaveBeenCalled()
-    })
-  })
-
-  describe('getCachedVersionWithRefresh', () => {
-    it('should use longer TTL and stale windows for manifests', async () => {
-      // Mock stale manifest data (1 year + 1 day old)
-      const staleManifestTime = new Date(Date.now() - (365 + 1) * 24 * 60 * 60 * 1000)
-      mockContext.db.getCachedVersion.mockResolvedValue({
-        spec: 'test-package@1.0.0',
-        manifest: { name: 'test-package', version: '1.0.0' },
-        cachedAt: staleManifestTime.toISOString()
-      })
-
-      const mockFetchManifest = vi.fn().mockResolvedValue({
-        manifest: { name: 'test-package', version: '1.0.0' },
-        publishedAt: new Date().toISOString()
-      })
-
-      const result = await getCachedVersionWithRefresh(
-        mockContext,
-        'test-package@1.0.0',
-        mockFetchManifest,
-        {
-          manifestTtlMinutes: 525600, // 1 year
-          staleWhileRevalidateMinutes: 1051200 // 2 years
-        }
-      )
-
-      expect(result.fromCache).toBe(true)
-      expect(result.stale).toBe(true)
-      expect(mockQueue.send).toHaveBeenCalledWith({
-        type: 'version_refresh',
-        spec: 'test-package@1.0.0',
-        upstream: 'npm',
-        timestamp: expect.any(Number),
-        options: {
-          manifestTtlMinutes: 525600,
-          upstream: 'npm'
-        }
-      })
-    })
-  })
-
-  describe('TTL and stale window calculations', () => {
-    it('should correctly calculate cache validity based on age', async () => {
-      const testCases = [
-        {
-          ageMinutes: 3,
-          ttlMinutes: 5,
-          staleMinutes: 60,
-          expectedValid: true,
-          expectedStale: false,
-          description: 'fresh cache'
-        },
-        {
-          ageMinutes: 10,
-          ttlMinutes: 5,
-          staleMinutes: 60,
-          expectedValid: false,
-          expectedStale: true,
-          description: 'stale but within stale window'
-        },
-        {
-          ageMinutes: 70,
-          ttlMinutes: 5,
-          staleMinutes: 60,
-          expectedValid: false,
-          expectedStale: false,
-          description: 'beyond stale window'
-        }
-      ]
-
-      for (const testCase of testCases) {
-        const cacheTime = new Date(Date.now() - testCase.ageMinutes * 60 * 1000)
-        mockContext.db.getCachedPackage.mockResolvedValue({
-          name: 'test-package',
-          tags: { latest: '1.0.0' },
-          origin: 'upstream',
-          cachedAt: cacheTime.toISOString()
-        })
-
-        const result = await getCachedPackageWithRefresh(
-          mockContext,
-          'test-package',
-          mockFetchUpstream,
-          {
-            packumentTtlMinutes: testCase.ttlMinutes,
-            staleWhileRevalidateMinutes: testCase.staleMinutes
-          }
-        )
-
-        if (testCase.expectedValid) {
-          expect(result.fromCache, testCase.description).toBe(true)
-          expect(result.stale, testCase.description).toBe(false)
-        } else if (testCase.expectedStale) {
-          expect(result.fromCache, testCase.description).toBe(true)
-          expect(result.stale, testCase.description).toBe(true)
-        } else {
-          expect(result.fromCache, testCase.description).toBe(false)
-        }
-      }
-    })
-  })
-})

package/test/static-assets.test.js

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import app from '../src/index.ts'
-
-describe('Static Asset Handling', () => {
-  const mockEnv = {
-    DB: {
-      prepare: () => ({
-        bind: () => ({
-          all: () => [],
-          get: () => null,
-          run: () => ({ success: true })
-        })
-      })
-    },
-    BUCKET: {
-      get: () => null,
-      put: () => Promise.resolve()
-    }
-  }
-
-  it('should handle favicon.ico requests gracefully', async () => {
-    const response = await app.request('/favicon.ico', {}, mockEnv)
-    expect(response.status).toBe(404)
-
-    const data = await response.json()
-    expect(data.error).toBe('Not found')
-  })
-
-  it('should handle robots.txt requests gracefully', async () => {
-    const response = await app.request('/robots.txt', {}, mockEnv)
-    expect(response.status).toBe(404)
-
-    const data = await response.json()
-    expect(data.error).toBe('Not found')
-  })
-
-  it('should allow asset paths to pass through (handled by Wrangler in production)', async () => {
-    // Wrangler serves files from src/assets/ at root level, now under /public/ prefix
-    // In our test environment, these reach our package handler since Wrangler isn't serving them
-    // In production, Wrangler serves these before they reach Hono
-    const response = await app.request('/public/styles/styles.css', {}, mockEnv)
-
-    // In test environment, should return 404 from our handler (not blocked by static patterns)
-    // This proves our static asset detection is not interfering with asset paths
-    expect(response.status).toBe(404)
-
-    const data = await response.json()
-    expect(data.error).toBe('Not found')
-  })
-
-  it('should allow image paths to pass through (handled by Wrangler in production)', async () => {
-    // Test another asset path that Wrangler would serve
-    const response = await app.request('/public/images/logo.png', {}, mockEnv)
-
-    // Should not be blocked by static asset pattern detection
-    expect(response.status).toBe(404)
-
-    const data = await response.json()
-    expect(data.error).toBe('Not found')
-  })
-
-  it('should reject static assets that slip through to package handler', async () => {
-    // Test a file extension that might slip through to the package handler
-    const response = await app.request('/some-file.png', {}, mockEnv)
-    expect(response.status).toBe(404)
-
-    const data = await response.json()
-    expect(data.error).toBe('Not found')
-  })
-
-  it('should reject manifest.json requests gracefully', async () => {
-    const response = await app.request('/manifest.json', {}, mockEnv)
-    expect(response.status).toBe(404)
-
-    const data = await response.json()
-    expect(data.error).toBe('Not found')
-  })
-
-  it('should still handle legitimate package requests', async () => {
-    // Make sure we didn't break legitimate package requests
-    const response = await app.request('/lodash', {}, mockEnv)
-    expect(response.status).toBe(302) // Should redirect to default upstream
-    expect(response.headers.get('location')).toBe('/local/lodash')
-  })
-})

package/test/upstream-routing.test.js

@@ -1,86 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import app from '../src/index.ts'
-
-describe('Upstream Routing', () => {
-  const mockEnv = {
-    DB: {
-      prepare: () => ({
-        bind: () => ({
-          all: () => [],
-          get: () => null,
-          run: () => ({ success: true })
-        })
-      })
-    },
-    BUCKET: {
-      get: () => null,
-      put: () => Promise.resolve()
-    }
-  }
-
-  beforeEach(() => {
-    // Reset any mocks
-  })
-
-  afterEach(() => {
-    // Clean up
-  })
-
-  it('should reject reserved upstream names for upstream routes only', async () => {
-    // Internal routes should work fine
-    const response1 = await app.request('/-/ping', {}, mockEnv)
-    expect(response1.status).toBe(200)
-
-    // Hash-based routes should work even though * is reserved
-    const response2 = await app.request('/*/abc123def456', {}, mockEnv)
-    expect(response2.status).toBe(501) // Not implemented, but not blocked by validation
-    const data2 = await response2.json()
-    expect(data2.error).toContain('Hash-based package lookup not yet implemented')
-
-    // Reserved upstream names should be rejected for upstream routes
-    const response3 = await app.request('/docs/some-package', {}, mockEnv)
-    expect(response3.status).toBe(400)
-    const data3 = await response3.json()
-    expect(data3.error).toContain('reserved')
-  })
-
-  it('should redirect root-level packages to default upstream', async () => {
-    const response = await app.request('/lodash', {}, mockEnv)
-    expect(response.status).toBe(302)
-    expect(response.headers.get('location')).toBe('/local/lodash')
-  })
-
-  it('should redirect scoped packages to default upstream', async () => {
-    const response = await app.request('/@babel/core', {}, mockEnv)
-    expect(response.status).toBe(302)
-    expect(response.headers.get('location')).toBe('/local/@babel/core')
-  })
-
-  it('should handle upstream package requests', async () => {
-    const response = await app.request('/npm/lodash', {}, mockEnv)
-    // The npm upstream is configured and should work correctly
-    // It might succeed (200) if network is available, or fail with various error codes
-    expect([200, 400, 404, 501, 502, 503]).toContain(response.status)
-  })
-
-  it('should handle hash-based package requests', async () => {
-    const response = await app.request('/*/abc123def456', {}, mockEnv)
-    expect(response.status).toBe(501)
-    const data = await response.json()
-    expect(data.error).toContain('Hash-based package lookup not yet implemented')
-  })
-
-  it('should handle hash-based tarball requests', async () => {
-    const response = await app.request('/*/abc123def456/-/package-1.0.0.tgz', {}, mockEnv)
-    expect(response.status).toBe(501)
-    const data = await response.json()
-    expect(data.error).toContain('Hash-based tarball lookup not yet implemented')
-  })
-
-  it('should preserve existing internal routes', async () => {
-    const response = await app.request('/-/ping', {}, mockEnv)
-    expect(response.status).toBe(200)
-    const data = await response.json()
-    expect(data.ok).toBe(true)
-  })
-})

package/test/utils/test-helpers.js

@@ -1,84 +0,0 @@
-/**
- * Creates a mock Hono context for testing
- *
- * @param {Object} options - Options for creating the context
- * @param {Object} options.req - Request properties
- * @param {Object} options.db - Mock database client
- * @param {string} [options.pkg] - Optional package name (for packageSpec mock)
- * @param {string} [options.username] - Optional username (for param mock)
- * @returns {Object} Mock Hono context
- */
-export function createContext(options = {}) {
-  const { req = {}, db = {}, pkg = null, username = null } = options;
-
-  // Create a mock response
-  let statusCode = 200;
-  let responseBody = null;
-  let responseHeaders = new Map();
-
-  // Create the context object
-  const context = {
-    // Request properties
-    req: {
-      method: req.method || 'GET',
-      header: (name) => req.headers?.[name] || null,
-      param: (name) => {
-        if (name === 'username' && username) {
-          return username;
-        }
-        if (req.param instanceof Map) {
-          return req.param.get(name);
-        }
-        if (typeof req.param === 'function') {
-          return req.param(name);
-        }
-        return req.param?.[name] || null;
-      },
-      query: (name) => {
-        if (req.query instanceof Map) {
-          return req.query.get(name);
-        }
-        if (typeof req.query === 'function') {
-          return req.query(name);
-        }
-        return req.query?.[name] || null;
-      },
-      json: req.json || (async () => (req.body || {})),
-      body: req.body || {},
-      ...req
-    },
-
-    // Database client
-    db,
-
-    // Mock packageSpec if pkg is provided
-    pkg,
-
-    // Mock username for parameter access
-    username,
-
-    // Response methods
-    status: (code) => {
-      statusCode = code;
-      return context;
-    },
-
-    json: (body, status) => {
-      responseBody = body;
-      if (status) statusCode = status;
-
-      return {
-        status: statusCode,
-        headers: responseHeaders,
-        json: async () => responseBody
-      };
-    },
-
-    header: (name, value) => {
-      responseHeaders.set(name, value);
-      return context;
-    }
-  };
-
-  return context;
-}