@vltpkg/vsr 0.0.0-26 → 0.0.0-28

package/test/packument.test.ts

@@ -1,530 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { app } from '../src/index.ts'
-
-// Mock environment for testing
-const mockEnv = {
-  DB: {
-    // Minimal D1 interface to prevent database errors
-    prepare: () => ({
-      bind: () => ({
-        get: () => Promise.resolve(null),
-        all: () => Promise.resolve({ results: [] }),
-        run: () => Promise.resolve({ success: true }),
-        raw: () => Promise.resolve([]),
-      }),
-      get: () => Promise.resolve(null),
-      all: () => Promise.resolve({ results: [] }),
-      run: () => Promise.resolve({ success: true }),
-      raw: () => Promise.resolve([]),
-    }),
-    batch: () => Promise.resolve([]),
-    exec: () => Promise.resolve(),
-  },
-  BUCKET: {
-    get: () => Promise.resolve(null),
-    put: () => Promise.resolve(),
-    delete: () => Promise.resolve(),
-  },
-  KV: {
-    get: () => Promise.resolve(null),
-    put: () => Promise.resolve(),
-    delete: () => Promise.resolve(),
-  },
-}
-
-describe('Package Packument Endpoints', () => {
-  describe('Local/Private Package Packuments', () => {
-    describe('Basic Packument Requests', () => {
-      it('should handle unscoped package packument request', async () => {
-        const res = await app.request('/lodash', {}, mockEnv)
-        // Should redirect to default upstream since package doesn't exist locally
-        expect(res.status).toBe(302)
-        expect(res.headers.get('location')).toBe('/local/lodash')
-      })
-
-      it('should handle scoped package packument request', async () => {
-        const res = await app.request('/@types/node', {}, mockEnv)
-        // Scoped packages should return 404 since they're not handled by the root route
-        expect(res.status).toBe(404)
-      })
-
-      it('should return 404 for invalid package names', async () => {
-        const res = await app.request(
-          '/invalid..package',
-          {},
-          mockEnv,
-        )
-        expect(res.status).toBe(404)
-      })
-
-      it('should return 404 for packages starting with dots', async () => {
-        const res = await app.request('/.hidden-package', {}, mockEnv)
-        expect(res.status).toBe(404)
-      })
-
-      it('should return 404 for packages starting with underscores', async () => {
-        const res = await app.request(
-          '/_internal-package',
-          {},
-          mockEnv,
-        )
-        expect(res.status).toBe(404)
-      })
-    })
-
-    describe('Version Range Filtering', () => {
-      it('should handle packument requests without version range', async () => {
-        const res = await app.request('/lodash', {}, mockEnv)
-        // Should redirect to default upstream since package doesn't exist locally
-        expect(res.status).toBe(302)
-        expect(res.headers.get('location')).toBe('/local/lodash')
-      })
-
-      it('should handle packument requests with valid semver range', async () => {
-        const res = await app.request(
-          '/lodash?versionRange=^4.0.0',
-          {},
-          mockEnv,
-        )
-        // Should redirect to default upstream since package doesn't exist locally
-        expect(res.status).toBe(302)
-        // Query parameters may not be preserved in redirects, just check the base path
-        expect(res.headers.get('location')).toBe('/local/lodash')
-      })
-
-      it('should return 400 for invalid semver ranges', async () => {
-        const res = await app.request(
-          '/lodash?versionRange=invalid-range',
-          {},
-          mockEnv,
-        )
-        // Should redirect to default upstream since package doesn't exist locally
-        expect(res.status).toBe(302)
-        // Query parameters may not be preserved in redirects, just check the base path
-        expect(res.headers.get('location')).toBe('/local/lodash')
-      })
-    })
-  })
-
-  describe('Upstream Public Package Packuments', () => {
-    describe('NPM Registry Upstream', () => {
-      it('should handle npm packument requests', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        // With real bindings, this should work properly (200) or return proper errors (404, etc.)
-        // May return 502 due to upstream connection issues in test environment
-        expect([200, 404, 500, 502].includes(res.status)).toBe(true)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-
-      it('should handle npm scoped package requests', async () => {
-        const res = await app.request('/npm/@types/node', {}, mockEnv)
-        // With real bindings, this should work properly
-        // May return 502 due to upstream connection issues in test environment
-        expect([200, 404, 500, 502].includes(res.status)).toBe(true)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-
-      it('should return packument structure for npm packages', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          expect(res.headers.get('content-type')).toContain(
-            'application/json',
-          )
-
-          const data = (await res.json()) as any
-          expect(data).toHaveProperty('name')
-          expect(data).toHaveProperty('dist-tags')
-          expect(data).toHaveProperty('versions')
-          expect(data).toHaveProperty('time')
-          expect(data.name).toBe('lodash')
-          expect(typeof data['dist-tags']).toBe('object')
-          expect(typeof data.versions).toBe('object')
-          expect(typeof data.time).toBe('object')
-        }
-      })
-
-      it('should handle URL-encoded scoped packages', async () => {
-        const res = await app.request(
-          '/npm/@babel%2Fcore',
-          {},
-          mockEnv,
-        )
-        // This will likely return 502 due to database mocking issues, but we test the route exists
-        expect([200, 502].includes(res.status)).toBe(true)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-
-      it('should handle version range filtering for npm packages', async () => {
-        const res = await app.request(
-          '/npm/lodash?versionRange=%5E4.0.0',
-          {},
-          mockEnv,
-        )
-        // May return 502 due to database mocking issues
-        expect([200, 502].includes(res.status)).toBe(true)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-
-      it('should return 400 for invalid semver ranges in npm packages', async () => {
-        const res = await app.request(
-          '/npm/lodash?versionRange=invalid-range',
-          {},
-          mockEnv,
-        )
-        expect(res.status).toBe(400)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-
-        const data = (await res.json()) as any
-        expect(data).toHaveProperty('error')
-        expect(data.error).toContain('Invalid semver range')
-      })
-    })
-
-    describe('Local Registry Upstream', () => {
-      it('should handle local upstream packument requests', async () => {
-        const res = await app.request(
-          '/local/some-package',
-          {},
-          mockEnv,
-        )
-        // Local upstream should work but package likely doesn't exist
-        expect([200, 404, 502].includes(res.status)).toBe(true)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-
-      it('should handle local upstream scoped package requests', async () => {
-        const res = await app.request(
-          '/local/@scope/package',
-          {},
-          mockEnv,
-        )
-        // Local upstream should work but package likely doesn't exist
-        expect([200, 404, 502].includes(res.status)).toBe(true)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-    })
-
-    describe('Unconfigured Registry Upstreams', () => {
-      it('should return 404 for jsr packument requests', async () => {
-        const res = await app.request('/jsr/@std/fs', {}, mockEnv)
-        // JSR is not configured in the default config, should return 404
-        expect(res.status).toBe(404)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-
-      it('should return 404 for custom upstream packument requests', async () => {
-        const res = await app.request(
-          '/custom/some-package',
-          {},
-          mockEnv,
-        )
-        // Custom upstream is not configured in the default config, should return 404
-        expect(res.status).toBe(404)
-        expect(res.headers.get('content-type')).toContain(
-          'application/json',
-        )
-      })
-    })
-  })
-
-  describe('Packument Response Structure', () => {
-    describe('Required Fields', () => {
-      it('should include name field in packument response', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          const data = (await res.json()) as any
-          expect(data).toHaveProperty('name')
-          expect(typeof data.name).toBe('string')
-          expect(data.name.length).toBeGreaterThan(0)
-        }
-      })
-
-      it('should include dist-tags field in packument response', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          const data = (await res.json()) as any
-          expect(data).toHaveProperty('dist-tags')
-          expect(typeof data['dist-tags']).toBe('object')
-          expect(data['dist-tags']).toHaveProperty('latest')
-        }
-      })
-
-      it('should include versions field in packument response', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          const data = (await res.json()) as any
-          expect(data).toHaveProperty('versions')
-          expect(typeof data.versions).toBe('object')
-          // Should have at least one version
-          expect(Object.keys(data.versions).length).toBeGreaterThan(0)
-        }
-      })
-
-      it('should include time field in packument response', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          const data = (await res.json()) as any
-          expect(data).toHaveProperty('time')
-          expect(typeof data.time).toBe('object')
-          expect(data.time).toHaveProperty('modified')
-        }
-      })
-    })
-
-    describe('Version Objects Structure', () => {
-      it('should have properly structured version objects', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          const data = (await res.json()) as any
-          const versions = data.versions
-          const versionKeys = Object.keys(versions)
-
-          if (versionKeys.length > 0) {
-            const firstVersion = versions[versionKeys[0]]
-            expect(firstVersion).toHaveProperty('name')
-            expect(firstVersion).toHaveProperty('version')
-            expect(firstVersion).toHaveProperty('dist')
-            expect(firstVersion.dist).toHaveProperty('tarball')
-          }
-        }
-      })
-
-      it('should have tarball URLs rewritten for upstream packages', async () => {
-        const res = await app.request('/npm/lodash', {}, mockEnv)
-        if (res.status === 200) {
-          const data = (await res.json()) as any
-          const versions = data.versions
-          const versionKeys = Object.keys(versions)
-
-          if (versionKeys.length > 0) {
-            const firstVersion = versions[versionKeys[0]]
-            expect(firstVersion.dist.tarball).toMatch(
-              /^https?:\/\/.*\/npm\/lodash\/-\/lodash-.*\.tgz$/,
-            )
-          }
-        }
-      })
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should return 404 for non-existent packages in upstream', async () => {
-      const res = await app.request(
-        '/npm/this-package-definitely-does-not-exist-12345',
-        {},
-        mockEnv,
-      )
-      expect(res.status).toBe(404)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-
-      const data = (await res.json()) as any
-      expect(data).toHaveProperty('error')
-    })
-
-    it('should return 404 for invalid upstream names', async () => {
-      const res = await app.request(
-        '/invalid-upstream/some-package',
-        {},
-        mockEnv,
-      )
-      // Invalid upstreams return 404 since they're not configured
-      expect(res.status).toBe(404)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-
-      const data = (await res.json()) as any
-      expect(data).toHaveProperty('error')
-    })
-
-    it('should return 404 for unknown upstream registries', async () => {
-      const res = await app.request(
-        '/unknown-registry/some-package',
-        {},
-        mockEnv,
-      )
-      expect(res.status).toBe(404)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-
-      const data = (await res.json()) as any
-      expect(data).toHaveProperty('error')
-      expect(data.error).toContain('Unknown upstream')
-    })
-
-    it('should handle malformed package names gracefully', async () => {
-      const res = await app.request('/npm/invalid..name', {}, mockEnv)
-      expect([400, 404].includes(res.status)).toBe(true)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-  })
-
-  describe('Response Headers and Caching', () => {
-    it('should set appropriate content-type headers', async () => {
-      const res = await app.request('/npm/lodash', {}, mockEnv)
-      // May return 502 due to database mocking, but should have correct content-type
-      expect([200, 502].includes(res.status)).toBe(true)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-
-    it('should set cache-control headers for packuments', async () => {
-      const res = await app.request('/npm/lodash', {}, mockEnv)
-      if (res.status === 200) {
-        expect(res.headers.get('cache-control')).toBeTruthy()
-      }
-    })
-  })
-
-  describe('Special Package Name Handling', () => {
-    it('should handle packages with special characters', async () => {
-      const res = await app.request(
-        '/npm/package-with-dashes',
-        {},
-        mockEnv,
-      )
-      // Package doesn't exist, should return 404
-      expect(res.status).toBe(404)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-
-    it('should handle packages with numbers', async () => {
-      const res = await app.request('/npm/package123', {}, mockEnv)
-      // Package doesn't exist, may return 502 due to database mocking
-      expect([404, 502].includes(res.status)).toBe(true)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-
-    it('should handle deeply scoped packages', async () => {
-      const res = await app.request(
-        '/npm/@org/sub/package',
-        {},
-        mockEnv,
-      )
-      // Package doesn't exist, should return 404
-      expect(res.status).toBe(404)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-
-    it('should handle scoped packages with URL encoding', async () => {
-      const res = await app.request('/npm/@types%2Fnode', {}, mockEnv)
-      // This will likely return 502 due to database mocking issues, but we test the route exists
-      expect([200, 502].includes(res.status)).toBe(true)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-  })
-
-  describe('Version Range Query Parameters', () => {
-    it('should filter versions by semver range', async () => {
-      const res = await app.request(
-        '/npm/lodash?versionRange=4.17.x',
-        {},
-        mockEnv,
-      )
-      if (res.status === 200) {
-        const data = (await res.json()) as any
-        expect(data).toHaveProperty('versions')
-
-        // All returned versions should match the range
-        const versions = Object.keys(data.versions)
-        versions.forEach((version: string) => {
-          expect(version).toMatch(/^4\.17\./)
-        })
-      }
-    })
-
-    it('should handle exact version ranges', async () => {
-      const res = await app.request(
-        '/npm/lodash?versionRange=4.17.21',
-        {},
-        mockEnv,
-      )
-      // May return 502 due to database mocking issues
-      expect([200, 502].includes(res.status)).toBe(true)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-
-    it('should handle complex semver ranges', async () => {
-      const res = await app.request(
-        '/npm/lodash?versionRange=%3E%3D4.0.0%20%3C5.0.0',
-        {},
-        mockEnv,
-      )
-      // URL-encoded ">=4.0.0 <5.0.0"
-      // May return 502 due to database mocking issues
-      expect([200, 502].includes(res.status)).toBe(true)
-      expect(res.headers.get('content-type')).toContain(
-        'application/json',
-      )
-    })
-
-    it('should return empty versions object for non-matching ranges', async () => {
-      const res = await app.request(
-        '/npm/lodash?versionRange=999.x',
-        {},
-        mockEnv,
-      )
-      if (res.status === 200) {
-        const data = (await res.json()) as any
-        expect(data).toHaveProperty('versions')
-        expect(Object.keys(data.versions)).toHaveLength(0)
-      }
-    })
-  })
-
-  describe('Performance and Limits', () => {
-    it('should handle requests for packages with many versions', async () => {
-      const res = await app.request('/npm/lodash', {}, mockEnv)
-      if (res.status === 200) {
-        const data = (await res.json()) as any
-        expect(data).toHaveProperty('versions')
-
-        // Should not return an excessive number of versions (performance limit)
-        const versionCount = Object.keys(data.versions).length
-        expect(versionCount).toBeLessThanOrEqual(100) // Reasonable upper limit
-      }
-    })
-
-    it('should respond within reasonable time limits', async () => {
-      const startTime = Date.now()
-      const res = await app.request('/npm/lodash', {}, mockEnv)
-      const endTime = Date.now()
-
-      // Should respond within 10 seconds (generous for network requests)
-      expect(endTime - startTime).toBeLessThan(10000)
-      expect([200, 404, 502].includes(res.status)).toBe(true)
-    })
-  })
-})

package/test/ping.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { app } from '../src/index.ts'
-
-describe('Ping Endpoint', () => {
-  describe('Root Registry', () => {
-    it('should return empty JSON response', async () => {
-      const res = await app.request('/-/ping')
-      expect(res.status).toBe(200)
-      expect(await res.json()).toEqual({})
-    })
-
-    it('should return npm notice header', async () => {
-      const res = await app.request('/-/ping')
-      expect(res.status).toBe(200)
-      expect(res.headers.get('npm-notice')).toBe('PONG')
-    })
-  })
-
-  describe('Upstream Registry', () => {
-    it('should work on npm upstream path', async () => {
-      const res = await app.request('/npm/-/ping')
-      expect(res.status).toBe(200)
-      expect(await res.json()).toEqual({})
-      expect(res.headers.get('npm-notice')).toBe('PONG')
-    })
-
-    it('should work on jsr upstream path', async () => {
-      const res = await app.request('/jsr/-/ping')
-      expect(res.status).toBe(200)
-      expect(await res.json()).toEqual({})
-      expect(res.headers.get('npm-notice')).toBe('PONG')
-    })
-
-    it('should work on custom upstream path', async () => {
-      const res = await app.request('/custom/-/ping')
-      expect(res.status).toBe(200)
-      expect(await res.json()).toEqual({})
-      expect(res.headers.get('npm-notice')).toBe('PONG')
-    })
-  })
-})