@vltpkg/vsr 0.0.0-26 → 0.0.0-27

package/test/static.test.ts

@@ -1,646 +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(),
-  },
-  ASSETS: {
-    // Mock assets binding
-    fetch: () =>
-      Promise.resolve(new Response('mock asset', { status: 200 })),
-  },
-  DAEMON_ENABLED: false,
-  API_DOCS_ENABLED: false,
-}
-
-describe('Static Asset Endpoints', () => {
-  describe('Public Assets', () => {
-    describe('GET /public/*', () => {
-      it('should serve static assets from public directory', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve JavaScript assets', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve image assets', async () => {
-        const res = await app.request(
-          '/public/images/logo.png',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve font assets', async () => {
-        const res = await app.request(
-          '/public/fonts/inter.woff2',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle nested public assets', async () => {
-        const res = await app.request(
-          '/public/assets/images/favicon/favicon.ico',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('Content-Type Headers', () => {
-      it('should set correct content-type for CSS files', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          expect(
-            res.headers.get('content-type')?.includes('text/css'),
-          ).toBeTruthy()
-        }
-      })
-
-      it('should set correct content-type for JavaScript files', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          expect(
-            res.headers
-              .get('content-type')
-              ?.includes('application/javascript'),
-          ).toBeTruthy()
-        }
-      })
-
-      it('should set correct content-type for PNG images', async () => {
-        const res = await app.request(
-          '/public/images/logo.png',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          expect(
-            res.headers.get('content-type')?.includes('image/png'),
-          ).toBeTruthy()
-        }
-      })
-
-      it('should set correct content-type for SVG images', async () => {
-        const res = await app.request(
-          '/public/images/icon.svg',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          expect(
-            res.headers
-              .get('content-type')
-              ?.includes('image/svg+xml'),
-          ).toBeTruthy()
-        }
-      })
-    })
-
-    describe('Cache Headers', () => {
-      it('should set appropriate cache headers for static assets', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // Cache headers would be validated based on implementation
-          expect(res.status).toBe(200)
-        }
-      })
-
-      it('should set ETag headers for static assets', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // ETag headers would be validated based on implementation
-          expect(res.status).toBe(200)
-        }
-      })
-    })
-  })
-
-  describe('Special Static Files', () => {
-    describe('GET /favicon.ico', () => {
-      it('should serve favicon.ico', async () => {
-        const res = await app.request('/favicon.ico', {}, mockEnv)
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should set correct content-type for favicon', async () => {
-        const res = await app.request('/favicon.ico', {}, mockEnv)
-        if (res.status === 200) {
-          expect(
-            res.headers.get('content-type')?.includes('image/'),
-          ).toBeTruthy()
-        }
-      })
-
-      it('should handle HEAD requests for favicon', async () => {
-        const res = await app.request(
-          '/favicon.ico',
-          { method: 'HEAD' },
-          mockEnv,
-        )
-        expect([200, 404, 405].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('GET /robots.txt', () => {
-      it('should serve robots.txt', async () => {
-        const res = await app.request('/robots.txt', {}, mockEnv)
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should set correct content-type for robots.txt', async () => {
-        const res = await app.request('/robots.txt', {}, mockEnv)
-        if (res.status === 200) {
-          expect(
-            res.headers.get('content-type')?.includes('text/plain'),
-          ).toBeTruthy()
-        }
-      })
-
-      it('should contain valid robots.txt content', async () => {
-        const res = await app.request('/robots.txt', {}, mockEnv)
-        if (res.status === 200) {
-          const content = await res.text()
-          expect(content).toBeDefined()
-          // Would validate robots.txt format based on implementation
-        }
-      })
-    })
-
-    describe('GET /manifest.json', () => {
-      it('should serve PWA manifest.json', async () => {
-        const res = await app.request('/manifest.json', {}, mockEnv)
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should set correct content-type for manifest.json', async () => {
-        const res = await app.request('/manifest.json', {}, mockEnv)
-        if (res.status === 200) {
-          expect(res.headers.get('content-type')).toContain(
-            'application/json',
-          )
-        }
-      })
-
-      it('should contain valid PWA manifest structure', async () => {
-        const res = await app.request('/manifest.json', {}, mockEnv)
-        if (res.status === 200) {
-          const manifest = (await res.json()) as any
-          expect(manifest).toBeDefined()
-          // Would validate PWA manifest structure based on implementation
-        }
-      })
-    })
-  })
-
-  describe('Catch-All Static Handler', () => {
-    describe('GET /*', () => {
-      it('should handle catch-all static asset requests', async () => {
-        const res = await app.request(
-          '/some-static-file.txt',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle nested static asset paths', async () => {
-        const res = await app.request(
-          '/assets/css/main.css',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle static assets with query parameters', async () => {
-        const res = await app.request(
-          '/assets/js/app.js?v=1.0.0',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle static assets with hash fragments', async () => {
-        const res = await app.request(
-          '/assets/app.js#main',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('Security Considerations', () => {
-      it('should prevent directory traversal attacks', async () => {
-        const res = await app.request(
-          '/../../etc/passwd',
-          {},
-          mockEnv,
-        )
-        expect([400, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle encoded path traversal attempts', async () => {
-        const res = await app.request(
-          '/%2e%2e%2f%2e%2e%2fetc%2fpasswd',
-          {},
-          mockEnv,
-        )
-        expect([400, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle null byte injection attempts', async () => {
-        const res = await app.request('/file.txt%00.exe', {}, mockEnv)
-        expect([400, 404].includes(res.status)).toBe(true)
-      })
-    })
-  })
-
-  describe('Error Handling', () => {
-    describe('Non-existent Assets', () => {
-      it('should return 404 for non-existent static assets', async () => {
-        const res = await app.request(
-          '/public/nonexistent-file.txt',
-          {},
-          mockEnv,
-        )
-        expect(res.status).toBe(404)
-      })
-
-      it('should return 404 for non-existent nested assets', async () => {
-        const res = await app.request(
-          '/public/deep/nested/nonexistent.js',
-          {},
-          mockEnv,
-        )
-        expect(res.status).toBe(404)
-      })
-
-      it('should handle malformed asset paths', async () => {
-        const res = await app.request(
-          '/public//double//slash.css',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('HTTP Method Validation', () => {
-      it('should handle POST requests to static assets', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          { method: 'POST' },
-          mockEnv,
-        )
-        expect([200, 404, 405].includes(res.status)).toBe(true)
-      })
-
-      it('should handle PUT requests to static assets', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          { method: 'PUT' },
-          mockEnv,
-        )
-        expect([200, 404, 405].includes(res.status)).toBe(true)
-      })
-
-      it('should handle DELETE requests to static assets', async () => {
-        const res = await app.request(
-          '/public/images/logo.png',
-          { method: 'DELETE' },
-          mockEnv,
-        )
-        expect([200, 404, 405].includes(res.status)).toBe(true)
-      })
-    })
-  })
-
-  describe('Performance and Optimization', () => {
-    describe('Compression', () => {
-      it('should handle gzip compression for text assets', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {
-            headers: {
-              'Accept-Encoding': 'gzip, deflate, br',
-            },
-          },
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // Compression headers would be validated based on implementation
-          expect(res.status).toBe(200)
-        }
-      })
-
-      it('should handle brotli compression for JavaScript assets', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {
-            headers: {
-              'Accept-Encoding': 'br, gzip, deflate',
-            },
-          },
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // Compression headers would be validated based on implementation
-          expect(res.status).toBe(200)
-        }
-      })
-    })
-
-    describe('Range Requests', () => {
-      it('should handle range requests for large assets', async () => {
-        const res = await app.request(
-          '/public/videos/demo.mp4',
-          {
-            headers: {
-              Range: 'bytes=0-1023',
-            },
-          },
-          mockEnv,
-        )
-        expect([200, 206, 404, 416].includes(res.status)).toBe(true)
-      })
-
-      it('should handle invalid range requests', async () => {
-        const res = await app.request(
-          '/public/images/large-image.jpg',
-          {
-            headers: {
-              Range: 'bytes=invalid-range',
-            },
-          },
-          mockEnv,
-        )
-        expect([200, 400, 404, 416].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('Conditional Requests', () => {
-      it('should handle If-None-Match headers', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {
-            headers: {
-              'If-None-Match': '"some-etag-value"',
-            },
-          },
-          mockEnv,
-        )
-        expect([200, 304, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should handle If-Modified-Since headers', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {
-            headers: {
-              'If-Modified-Since': 'Wed, 21 Oct 2015 07:28:00 GMT',
-            },
-          },
-          mockEnv,
-        )
-        expect([200, 304, 404].includes(res.status)).toBe(true)
-      })
-    })
-  })
-
-  describe('CORS and Security Headers', () => {
-    describe('CORS Headers', () => {
-      it('should handle CORS headers for static assets', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {
-            headers: {
-              Origin: 'https://example.com',
-            },
-          },
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // CORS headers would be validated based on implementation
-          expect(res.status).toBe(200)
-        }
-      })
-
-      it('should handle preflight requests for static assets', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {
-            method: 'OPTIONS',
-            headers: {
-              Origin: 'https://example.com',
-              'Access-Control-Request-Method': 'GET',
-            },
-          },
-          mockEnv,
-        )
-        expect([200, 204, 404, 405].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('Security Headers', () => {
-      it('should include security headers for static assets', async () => {
-        const res = await app.request(
-          '/public/js/app.js',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // Security headers would be validated based on implementation
-          expect(res.status).toBe(200)
-        }
-      })
-
-      it('should set X-Content-Type-Options header', async () => {
-        const res = await app.request(
-          '/public/styles/styles.css',
-          {},
-          mockEnv,
-        )
-        if (res.status === 200) {
-          // X-Content-Type-Options header would be validated
-          expect(res.status).toBe(200)
-        }
-      })
-    })
-  })
-
-  describe('Asset Types and Extensions', () => {
-    describe('Web Assets', () => {
-      it('should serve HTML files', async () => {
-        const res = await app.request(
-          '/public/index.html',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve XML files', async () => {
-        const res = await app.request(
-          '/public/sitemap.xml',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve JSON files', async () => {
-        const res = await app.request(
-          '/public/data.json',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('Media Assets', () => {
-      it('should serve JPEG images', async () => {
-        const res = await app.request(
-          '/public/images/photo.jpg',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve WebP images', async () => {
-        const res = await app.request(
-          '/public/images/modern.webp',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve AVIF images', async () => {
-        const res = await app.request(
-          '/public/images/next-gen.avif',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve video files', async () => {
-        const res = await app.request(
-          '/public/videos/demo.mp4',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve audio files', async () => {
-        const res = await app.request(
-          '/public/audio/sound.mp3',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-    })
-
-    describe('Font Assets', () => {
-      it('should serve WOFF fonts', async () => {
-        const res = await app.request(
-          '/public/fonts/font.woff',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve WOFF2 fonts', async () => {
-        const res = await app.request(
-          '/public/fonts/font.woff2',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve TTF fonts', async () => {
-        const res = await app.request(
-          '/public/fonts/font.ttf',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-
-      it('should serve OTF fonts', async () => {
-        const res = await app.request(
-          '/public/fonts/font.otf',
-          {},
-          mockEnv,
-        )
-        expect([200, 404].includes(res.status)).toBe(true)
-      })
-    })
-  })
-})