@cloudflare/sandbox 0.4.12 → 0.4.15

package/tests/request-handler.test.ts

@@ -7,7 +7,7 @@ vi.mock('../src/sandbox', () => {
   const mockFn = vi.fn();
   return {
     getSandbox: mockFn,
-    Sandbox: vi.fn(),
+    Sandbox: vi.fn()
   };
 });
 
@@ -25,11 +25,11 @@ describe('proxyToSandbox - WebSocket Support', () => {
     mockSandbox = {
       validatePortToken: vi.fn().mockResolvedValue(true),
       fetch: vi.fn().mockResolvedValue(new Response('WebSocket response')),
-      containerFetch: vi.fn().mockResolvedValue(new Response('HTTP response')),
+      containerFetch: vi.fn().mockResolvedValue(new Response('HTTP response'))
     };
 
     mockEnv = {
-      Sandbox: {} as any,
+      Sandbox: {} as any
     };
 
     vi.mocked(getSandbox).mockReturnValue(mockSandbox as Sandbox);
@@ -37,12 +37,15 @@ describe('proxyToSandbox - WebSocket Support', () => {
 
   describe('WebSocket detection and routing', () => {
     it('should detect WebSocket upgrade header (case-insensitive)', async () => {
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
-        headers: {
-          'Upgrade': 'websocket',
-          'Connection': 'Upgrade',
-        },
-      });
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/ws',
+        {
+          headers: {
+            Upgrade: 'websocket',
+            Connection: 'Upgrade'
+          }
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
@@ -52,32 +55,40 @@ describe('proxyToSandbox - WebSocket Support', () => {
     });
 
     it('should set cf-container-target-port header for WebSocket', async () => {
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
-        headers: {
-          'Upgrade': 'websocket',
-        },
-      });
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/ws',
+        {
+          headers: {
+            Upgrade: 'websocket'
+          }
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
       expect(mockSandbox.fetch).toHaveBeenCalledTimes(1);
-      const fetchCall = vi.mocked(mockSandbox.fetch as any).mock.calls[0][0] as Request;
+      const fetchCall = vi.mocked(mockSandbox.fetch as any).mock
+        .calls[0][0] as Request;
       expect(fetchCall.headers.get('cf-container-target-port')).toBe('8080');
     });
 
     it('should preserve original headers for WebSocket', async () => {
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
-        headers: {
-          'Upgrade': 'websocket',
-          'Sec-WebSocket-Key': 'test-key-123',
-          'Sec-WebSocket-Version': '13',
-          'User-Agent': 'test-client',
-        },
-      });
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/ws',
+        {
+          headers: {
+            Upgrade: 'websocket',
+            'Sec-WebSocket-Key': 'test-key-123',
+            'Sec-WebSocket-Version': '13',
+            'User-Agent': 'test-client'
+          }
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
-      const fetchCall = vi.mocked(mockSandbox.fetch as any).mock.calls[0][0] as Request;
+      const fetchCall = vi.mocked(mockSandbox.fetch as any).mock
+        .calls[0][0] as Request;
       expect(fetchCall.headers.get('Upgrade')).toBe('websocket');
       expect(fetchCall.headers.get('Sec-WebSocket-Key')).toBe('test-key-123');
       expect(fetchCall.headers.get('Sec-WebSocket-Version')).toBe('13');
@@ -87,9 +98,12 @@ describe('proxyToSandbox - WebSocket Support', () => {
 
   describe('HTTP routing (existing behavior)', () => {
     it('should route HTTP requests through containerFetch', async () => {
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/api/data', {
-        method: 'GET',
-      });
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/api/data',
+        {
+          method: 'GET'
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
@@ -99,13 +113,16 @@ describe('proxyToSandbox - WebSocket Support', () => {
     });
 
     it('should route POST requests through containerFetch', async () => {
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/api/data', {
-        method: 'POST',
-        body: JSON.stringify({ data: 'test' }),
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/api/data',
+        {
+          method: 'POST',
+          body: JSON.stringify({ data: 'test' }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
@@ -114,11 +131,14 @@ describe('proxyToSandbox - WebSocket Support', () => {
     });
 
     it('should not detect SSE as WebSocket', async () => {
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/events', {
-        headers: {
-          'Accept': 'text/event-stream',
-        },
-      });
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/events',
+        {
+          headers: {
+            Accept: 'text/event-stream'
+          }
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
@@ -130,26 +150,40 @@ describe('proxyToSandbox - WebSocket Support', () => {
 
   describe('Token validation', () => {
     it('should validate token for both WebSocket and HTTP requests', async () => {
-      const wsRequest = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
-        headers: { 'Upgrade': 'websocket' },
-      });
+      const wsRequest = new Request(
+        'https://8080-sandbox-token12345678901.example.com/ws',
+        {
+          headers: { Upgrade: 'websocket' }
+        }
+      );
 
       await proxyToSandbox(wsRequest, mockEnv);
-      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(8080, 'token12345678901');
+      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(
+        8080,
+        'token12345678901'
+      );
 
       vi.clearAllMocks();
 
-      const httpRequest = new Request('https://8080-sandbox-token12345678901.example.com/api');
+      const httpRequest = new Request(
+        'https://8080-sandbox-token12345678901.example.com/api'
+      );
       await proxyToSandbox(httpRequest, mockEnv);
-      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(8080, 'token12345678901');
+      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(
+        8080,
+        'token12345678901'
+      );
     });
 
     it('should reject requests with invalid token', async () => {
       vi.mocked(mockSandbox.validatePortToken as any).mockResolvedValue(false);
 
-      const request = new Request('https://8080-sandbox-invalidtoken1234.example.com/ws', {
-        headers: { 'Upgrade': 'websocket' },
-      });
+      const request = new Request(
+        'https://8080-sandbox-invalidtoken1234.example.com/ws',
+        {
+          headers: { Upgrade: 'websocket' }
+        }
+      );
 
       const response = await proxyToSandbox(request, mockEnv);
 
@@ -159,15 +193,18 @@ describe('proxyToSandbox - WebSocket Support', () => {
       const body = await response?.json();
       expect(body).toMatchObject({
         error: 'Access denied: Invalid token or port not exposed',
-        code: 'INVALID_TOKEN',
+        code: 'INVALID_TOKEN'
       });
     });
 
     it('should reject reserved port 3000', async () => {
       // Port 3000 is reserved as control plane port and rejected by validatePort()
-      const request = new Request('https://3000-sandbox-anytoken12345678.example.com/status', {
-        method: 'GET',
-      });
+      const request = new Request(
+        'https://3000-sandbox-anytoken12345678.example.com/status',
+        {
+          method: 'GET'
+        }
+      );
 
       const response = await proxyToSandbox(request, mockEnv);
 
@@ -180,13 +217,19 @@ describe('proxyToSandbox - WebSocket Support', () => {
 
   describe('Port routing', () => {
     it('should route to correct port from subdomain', async () => {
-      const request = new Request('https://9000-sandbox-token12345678901.example.com/api', {
-        method: 'GET',
-      });
+      const request = new Request(
+        'https://9000-sandbox-token12345678901.example.com/api',
+        {
+          method: 'GET'
+        }
+      );
 
       await proxyToSandbox(request, mockEnv);
 
-      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(9000, 'token12345678901');
+      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(
+        9000,
+        'token12345678901'
+      );
     });
   });
 
@@ -212,13 +255,18 @@ describe('proxyToSandbox - WebSocket Support', () => {
 
   describe('Error handling', () => {
     it('should handle errors during WebSocket routing', async () => {
-      (mockSandbox.fetch as any).mockImplementation(() => Promise.reject(new Error('Connection failed')));
-
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
-        headers: {
-          'Upgrade': 'websocket',
-        },
-      });
+      (mockSandbox.fetch as any).mockImplementation(() =>
+        Promise.reject(new Error('Connection failed'))
+      );
+
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/ws',
+        {
+          headers: {
+            Upgrade: 'websocket'
+          }
+        }
+      );
 
       const response = await proxyToSandbox(request, mockEnv);
 
@@ -228,9 +276,13 @@ describe('proxyToSandbox - WebSocket Support', () => {
     });
 
     it('should handle errors during HTTP routing', async () => {
-      (mockSandbox.containerFetch as any).mockImplementation(() => Promise.reject(new Error('Service error')));
+      (mockSandbox.containerFetch as any).mockImplementation(() =>
+        Promise.reject(new Error('Service error'))
+      );
 
-      const request = new Request('https://8080-sandbox-token12345678901.example.com/api');
+      const request = new Request(
+        'https://8080-sandbox-token12345678901.example.com/api'
+      );
 
       const response = await proxyToSandbox(request, mockEnv);