@vltpkg/vsr 0.2.0 → 0.2.1

package/test/hono-context.test.js

@@ -1,250 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-
-/**
- * This test demonstrates how to properly mock the Hono context
- * for testing routes, including waitUntil functionality
- */
-describe('Mocking Hono Context', () => {
-  /**
-   * Create a mock Hono context for testing routes
-   */
-  function createMockContext(options = {}) {
-    // Store response values
-    let responseBody = null;
-    let responseStatus = 200;
-    let responseHeaders = {};
-
-    // Store background task functions
-    const backgroundTaskFns = [];
-
-    // Default options
-    const defaults = {
-      params: {},
-      query: {},
-      headers: {},
-      dbData: null
-    };
-
-    const opts = { ...defaults, ...options };
-
-    // Mock context
-    const context = {
-      // Request
-      req: {
-        param: (name) => opts.params[name],
-        query: (name) => opts.query[name],
-        header: (name) => opts.headers[name]
-      },
-
-      // Route parameters
-      params: opts.params,
-
-      // Database methods
-      db: {
-        get: vi.fn().mockImplementation(async (key) => {
-          return opts.dbData && opts.dbData[key] ? opts.dbData[key] : null;
-        }),
-        set: vi.fn()
-      },
-
-      // Response methods
-      status: vi.fn((code) => {
-        responseStatus = code;
-        return context;
-      }),
-
-      header: vi.fn((name, value) => {
-        responseHeaders[name] = value;
-        return context;
-      }),
-
-      json: vi.fn((data) => {
-        responseBody = data;
-        return context;
-      }),
-
-      // Execution context for background tasks
-      executionCtx: {
-        waitUntil: vi.fn((promise) => {
-          // Instead of accepting the promise directly, we'll store a function
-          // This prevents immediate execution of IIFEs
-          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: () => ({
-        body: responseBody,
-        status: responseStatus,
-        headers: responseHeaders
-      }),
-
-      // Expose for testing
-      backgroundTaskFns
-    };
-
-    return context;
-  }
-
-  it('should mock Hono context successfully', async () => {
-    // Create mock context with route parameters
-    const context = createMockContext({
-      params: { id: '123', name: 'test' }
-    });
-
-    // Create a simple handler
-    async function handler(c) {
-      const id = c.params.id;
-      const name = c.params.name;
-      return c.json({ id, name });
-    }
-
-    // Execute the handler
-    await handler(context);
-
-    // Get the response
-    const { body, status } = context.getResponse();
-
-    // Verify the response
-    expect(status).toBe(200);
-    expect(body).toEqual({ id: '123', name: 'test' });
-  });
-
-  it('should handle database interactions', async () => {
-    // Setup mock DB data
-    const mockData = {
-      'package:express': { name: 'express', version: '4.18.2' }
-    };
-
-    // Create mock context with DB data
-    const context = createMockContext({
-      params: { name: 'express' },
-      dbData: mockData
-    });
-
-    // Create a handler that uses the DB
-    async function getPackage(c) {
-      const name = c.params.name;
-      const packageData = await c.db.get(`package:${name}`);
-
-      if (!packageData) {
-        return c.status(404).json({ error: 'Package not found' });
-      }
-
-      return c.json(packageData);
-    }
-
-    // Execute the handler
-    await getPackage(context);
-
-    // Get the response
-    const { body, status } = context.getResponse();
-
-    // Verify
-    expect(context.db.get).toHaveBeenCalledWith('package:express');
-    expect(status).toBe(200);
-    expect(body).toEqual({ name: 'express', version: '4.18.2' });
-  });
-
-  it('should handle background tasks with waitUntil', async () => {
-    // Setup state for tracking
-    const executionOrder = [];
-    let refreshTaskCompleted = false;
-
-    // Create mock context
-    const context = createMockContext({
-      params: { name: 'react' },
-      dbData: {
-        'package:react': {
-          name: 'react',
-          version: '18.2.0',
-          stale: true
-        }
-      }
-    });
-
-    // Create a handler that uses waitUntil
-    async function getPackageWithRefresh(c) {
-      executionOrder.push('handler-start');
-
-      const name = c.params.name;
-      const packageData = await c.db.get(`package:${name}`);
-
-      if (!packageData) {
-        executionOrder.push('handler-end-404');
-        return c.status(404).json({ error: 'Package not found' });
-      }
-
-      // If data is stale, refresh in background
-      if (packageData.stale) {
-        c.executionCtx.waitUntil(new Promise(async (resolve) => {
-          // This function shouldn't execute yet
-          const bgTask = async () => {
-            executionOrder.push('refresh-start');
-
-            // Simulate getting fresh data
-            const freshData = { ...packageData, version: '18.3.0', stale: false };
-
-            // Update the DB
-            await c.db.set(`package:${name}`, freshData);
-
-            executionOrder.push('refresh-end');
-            refreshTaskCompleted = true;
-            resolve();
-          };
-
-          // Don't execute immediately - we'll run this later
-          setTimeout(bgTask, 0);
-        }));
-      }
-
-      executionOrder.push('handler-end-success');
-      return c.json(packageData);
-    }
-
-    // Execute the handler
-    await getPackageWithRefresh(context);
-
-    // Get the response
-    const { body } = context.getResponse();
-
-    // Verify initial response
-    expect(body).toEqual({ name: 'react', version: '18.2.0', stale: true });
-    expect(executionOrder).toEqual([
-      'handler-start',
-      'handler-end-success'
-    ]);
-    expect(refreshTaskCompleted).toBe(false);
-    expect(context.backgroundTaskFns.length).toBe(1);
-
-    // Now run background tasks
-    await context.runBackgroundTasks();
-
-    // Verify background task effects
-    expect(context.db.set).toHaveBeenCalledWith(
-      'package:react',
-      { name: 'react', version: '18.3.0', stale: false }
-    );
-    expect(executionOrder).toEqual([
-      'handler-start',
-      'handler-end-success',
-      'refresh-start',
-      'refresh-end'
-    ]);
-    expect(refreshTaskCompleted).toBe(true);
-  });
-});

package/test/integrity-validation.test.js

@@ -1,183 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { getPackageTarball } from '../src/routes/packages.ts'
-
-// Mock environment and modules
-vi.mock('../../config.ts', () => ({
-  DOMAIN: 'https://registry.example.com',
-  PROXY: true,
-  PROXY_URL: 'https://registry.npmjs.org'
-}))
-
-describe('Tarball Integrity Validation', () => {
-  // Create a mock context with necessary properties
-  let mockContext
-  let mockDb
-  let mockEnv
-  let mockExecutionCtx
-
-  // Mock manifest data with integrity
-  const mockManifest = {
-    name: 'test-package',
-    version: '1.0.0',
-    dist: {
-      integrity: 'sha512-abcdefghijklmnopqrstuvwxyz0123456789',
-      tarball: 'https://registry.example.com/test-package/-/test-package-1.0.0.tgz',
-      shasum: '12345678901234567890123456789012'
-    }
-  }
-
-  beforeEach(() => {
-    // Reset mocks
-    mockDb = {
-      getVersion: vi.fn().mockImplementation(async (spec) => {
-        if (spec === 'test-package@1.0.0') {
-          return {
-            spec: 'test-package@1.0.0',
-            manifest: JSON.stringify(mockManifest),
-            published_at: '2023-01-01T00:00:00.000Z'
-          }
-        }
-        return null
-      })
-    }
-
-    mockEnv = {
-      BUCKET: {
-        get: vi.fn().mockImplementation(async (filename) => {
-          if (filename === 'test-package/test-package-1.0.0.tgz') {
-            return {
-              body: new ReadableStream({
-                start(controller) {
-                  controller.enqueue(new Uint8Array([1, 2, 3, 4]))
-                  controller.close()
-                }
-              }),
-              httpMetadata: {
-                integrity: 'sha512-abcdefghijklmnopqrstuvwxyz0123456789'
-              }
-            }
-          }
-          return null
-        }),
-        put: vi.fn().mockResolvedValue({ success: true })
-      }
-    }
-
-    mockExecutionCtx = {
-      waitUntil: vi.fn().mockImplementation((fn) => fn())
-    }
-
-    // Create mock context
-    mockContext = {
-      req: {
-        param: vi.fn().mockImplementation(() => ({ scope: 'test-package' })),
-        path: '/test-package/-/test-package-1.0.0.tgz',
-        header: vi.fn().mockImplementation((name) => {
-          if (name === 'accepts-integrity') {
-            return 'sha512-abcdefghijklmnopqrstuvwxyz0123456789'
-          }
-          return null
-        })
-      },
-      db: mockDb,
-      env: mockEnv,
-      executionCtx: mockExecutionCtx,
-      json: vi.fn().mockImplementation((body, status = 200) => ({ body, status })),
-      header: vi.fn()
-    }
-
-    // Mock global objects
-    global.Headers = vi.fn().mockImplementation(() => ({}))
-    global.Response = vi.fn().mockImplementation((body, init) => ({
-      body,
-      ...init,
-      status: 200
-    }))
-  })
-
-  it('should successfully validate matching integrity hash', async () => {
-    // Execute the function
-    const result = await getPackageTarball(mockContext)
-
-    // Should not return a JSON error response
-    expect(mockContext.json).not.toHaveBeenCalled()
-
-    // Should be a Response object with status 200
-    expect(result.status).toBe(200)
-  })
-
-  it('should return error when integrity hash does not match', async () => {
-    // Modify the header function to return a different integrity hash
-    mockContext.req.header = vi.fn().mockImplementation((name) => {
-      if (name === 'accepts-integrity') {
-        return 'sha512-differenthashvaluefortestingwhenthingsdonotmatch'
-      }
-      return null
-    })
-
-    // Execute the function
-    await getPackageTarball(mockContext)
-
-    // Should return a JSON error response
-    expect(mockContext.json).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: 'Integrity check failed',
-        code: 'EINTEGRITY',
-        expected: 'sha512-abcdefghijklmnopqrstuvwxyz0123456789',
-        actual: 'sha512-differenthashvaluefortestingwhenthingsdonotmatch'
-      }),
-      400
-    )
-  })
-
-  it('should work without computing integrity in proxied packages', async () => {
-    // Skip the actual test that was failing - we're testing the simplified implementation
-    expect(true).toBe(true)
-  })
-
-  it('should still work when no integrity header is provided', async () => {
-    // Remove integrity header
-    mockContext.req.header = vi.fn().mockImplementation(() => null)
-
-    // Execute the function
-    const result = await getPackageTarball(mockContext)
-
-    // Should not return a JSON error response
-    expect(mockContext.json).not.toHaveBeenCalled()
-
-    // Should be a Response object with status 200
-    expect(result.status).toBe(200)
-  })
-
-  it('should handle the case when manifest has no integrity information', async () => {
-    // Mock manifest without integrity
-    mockDb.getVersion = vi.fn().mockResolvedValue({
-      spec: 'test-package@1.0.0',
-      manifest: JSON.stringify({
-        name: 'test-package',
-        version: '1.0.0',
-        dist: {
-          tarball: 'https://registry.example.com/test-package/-/test-package-1.0.0.tgz'
-        }
-      }),
-      published_at: '2023-01-01T00:00:00.000Z'
-    })
-
-    // Set integrity header
-    mockContext.req.header = vi.fn().mockImplementation((name) => {
-      if (name === 'accepts-integrity') {
-        return 'sha512-abcdefghijklmnopqrstuvwxyz0123456789'
-      }
-      return null
-    })
-
-    // Execute the function
-    const result = await getPackageTarball(mockContext)
-
-    // Should not return a JSON error response
-    expect(mockContext.json).not.toHaveBeenCalled()
-
-    // Should be a Response object with status 200
-    expect(result.status).toBe(200)
-  })
-})

package/test/json-response.test.js

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { Hono } from 'hono'
-import { jsonResponseHandler } from '../src/utils/response.ts'
-
-describe('JSON Response Handler', () => {
-  let app
-
-  beforeEach(() => {
-    app = new Hono()
-    app.use(jsonResponseHandler())
-
-    // Test endpoint that returns a JSON object
-    app.get('/test-json', (c) => {
-      return c.json({
-        name: 'test-package',
-        version: '1.0.0',
-        description: 'Test package for JSON formatting',
-        author: {
-          name: 'Test User',
-          email: 'test@example.com'
-        },
-        keywords: ['test', 'json', 'formatting']
-      })
-    })
-  })
-
-  it('should return pretty-printed JSON by default', async () => {
-    const req = new Request('http://localhost/test-json')
-    const res = await app.fetch(req)
-    const body = await res.text()
-
-    // Should contain newlines and indentation
-    expect(body).toContain('\n')
-    expect(body).toContain('  ')
-
-    // Should be valid JSON
-    const parsed = JSON.parse(body)
-    expect(parsed.name).toBe('test-package')
-  })
-
-  it('should return minimal JSON when Accept header is application/vnd.npm.install-v1+json', async () => {
-    const req = new Request('http://localhost/test-json', {
-      headers: {
-        'Accept': 'application/vnd.npm.install-v1+json'
-      }
-    })
-    const res = await app.fetch(req)
-    const body = await res.text()
-
-    // Should not contain newlines or indentation
-    expect(body).not.toContain('\n')
-    expect(body).not.toMatch(/\s{2,}/)
-
-    // Should be valid JSON
-    const parsed = JSON.parse(body)
-    expect(parsed.name).toBe('test-package')
-  })
-
-  it('should handle mixed Accept headers containing application/vnd.npm.install-v1+json', async () => {
-    const req = new Request('http://localhost/test-json', {
-      headers: {
-        'Accept': 'application/json, application/vnd.npm.install-v1+json'
-      }
-    })
-    const res = await app.fetch(req)
-    const body = await res.text()
-
-    // Should not contain newlines or indentation as install-v1+json is included
-    expect(body).not.toContain('\n')
-    expect(body).not.toMatch(/\s{2,}/)
-
-    // Should be valid JSON
-    const parsed = JSON.parse(body)
-    expect(parsed.name).toBe('test-package')
-  })
-})