@cloudflare/sandbox 0.4.12 → 0.4.14

package/tests/port-client.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { 
-  ExposePortResponse, 
+import type {
+  ExposePortResponse,
   GetExposedPortsResponse,
-  UnexposePortResponse 
+  UnexposePortResponse
 } from '../src/clients';
 import { PortClient } from '../src/clients/port-client';
 import {
@@ -11,7 +11,7 @@ import {
   PortError,
   PortInUseError,
   PortNotExposedError,
-  SandboxError, 
+  SandboxError,
   ServiceNotRespondingError
 } from '../src/errors';
 
@@ -21,13 +21,13 @@ describe('PortClient', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    
+
     mockFetch = vi.fn();
     global.fetch = mockFetch as unknown as typeof fetch;
-    
+
     client = new PortClient({
       baseUrl: 'http://test.com',
-      port: 3000,
+      port: 3000
     });
   });
 
@@ -42,13 +42,12 @@ describe('PortClient', () => {
         port: 3001,
         exposedAt: 'https://preview-abc123.workers.dev',
         name: 'web-server',
-        timestamp: '2023-01-01T00:00:00Z',
+        timestamp: '2023-01-01T00:00:00Z'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockResponse),
-        { status: 200 }
-      ));
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
       const result = await client.exposePort(3001, 'session-123', 'web-server');
 
@@ -65,13 +64,12 @@ describe('PortClient', () => {
         port: 8080,
         exposedAt: 'https://api-def456.workers.dev',
         name: 'api-server',
-        timestamp: '2023-01-01T00:00:00Z',
+        timestamp: '2023-01-01T00:00:00Z'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockResponse),
-        { status: 200 }
-      ));
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
       const result = await client.exposePort(8080, 'session-456', 'api-server');
 
@@ -86,13 +84,12 @@ describe('PortClient', () => {
         success: true,
         port: 5000,
         exposedAt: 'https://service-ghi789.workers.dev',
-        timestamp: '2023-01-01T00:00:00Z',
+        timestamp: '2023-01-01T00:00:00Z'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockResponse),
-        { status: 200 }
-      ));
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
       const result = await client.exposePort(5000, 'session-789');
 
@@ -101,7 +98,6 @@ describe('PortClient', () => {
       expect(result.name).toBeUndefined();
       expect(result.exposedAt).toBeDefined();
     });
-
   });
 
   describe('service management', () => {
@@ -112,35 +108,34 @@ describe('PortClient', () => {
           {
             port: 3000,
             exposedAt: 'https://frontend-abc123.workers.dev',
-            name: 'frontend',
+            name: 'frontend'
           },
           {
             port: 4000,
             exposedAt: 'https://api-def456.workers.dev',
-            name: 'api',
+            name: 'api'
           },
           {
             port: 5432,
             exposedAt: 'https://db-ghi789.workers.dev',
-            name: 'database',
+            name: 'database'
           }
         ],
         count: 3,
-        timestamp: '2023-01-01T00:10:00Z',
+        timestamp: '2023-01-01T00:10:00Z'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockResponse),
-        { status: 200 }
-      ));
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
       const result = await client.getExposedPorts('session-list');
 
       expect(result.success).toBe(true);
       expect(result.count).toBe(3);
       expect(result.ports).toHaveLength(3);
-      
-      result.ports.forEach(service => {
+
+      result.ports.forEach((service) => {
         expect(service.exposedAt).toContain('.workers.dev');
         expect(service.port).toBeGreaterThan(0);
         expect(service.name).toBeDefined();
@@ -152,13 +147,12 @@ describe('PortClient', () => {
         success: true,
         ports: [],
         count: 0,
-        timestamp: '2023-01-01T00:00:00Z',
+        timestamp: '2023-01-01T00:00:00Z'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockResponse),
-        { status: 200 }
-      ));
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
       const result = await client.getExposedPorts('session-empty');
 
@@ -171,20 +165,18 @@ describe('PortClient', () => {
       const mockResponse: UnexposePortResponse = {
         success: true,
         port: 3001,
-        timestamp: '2023-01-01T00:15:00Z',
+        timestamp: '2023-01-01T00:15:00Z'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockResponse),
-        { status: 200 }
-      ));
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
       const result = await client.unexposePort(3001, 'session-unexpose');
 
       expect(result.success).toBe(true);
       expect(result.port).toBe(3001);
     });
-
   });
 
   describe('port validation and error handling', () => {
@@ -193,14 +185,14 @@ describe('PortClient', () => {
         error: 'Port already exposed: 3000',
         code: 'PORT_ALREADY_EXPOSED'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 409 }
-      ));
-
-      await expect(client.exposePort(3000, 'session-err'))
-        .rejects.toThrow(PortAlreadyExposedError);
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 409 })
+      );
+
+      await expect(client.exposePort(3000, 'session-err')).rejects.toThrow(
+        PortAlreadyExposedError
+      );
     });
 
     it('should handle invalid port numbers', async () => {
@@ -208,14 +200,14 @@ describe('PortClient', () => {
         error: 'Invalid port number: 0',
         code: 'INVALID_PORT_NUMBER'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 400 }
-      ));
-
-      await expect(client.exposePort(0, 'session-err'))
-        .rejects.toThrow(InvalidPortError);
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 400 })
+      );
+
+      await expect(client.exposePort(0, 'session-err')).rejects.toThrow(
+        InvalidPortError
+      );
     });
 
     it('should handle port in use errors', async () => {
@@ -223,14 +215,14 @@ describe('PortClient', () => {
         error: 'Port in use: 3000 is already bound by another process',
         code: 'PORT_IN_USE'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 409 }
-      ));
-
-      await expect(client.exposePort(3000, 'session-err'))
-        .rejects.toThrow(PortInUseError);
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 409 })
+      );
+
+      await expect(client.exposePort(3000, 'session-err')).rejects.toThrow(
+        PortInUseError
+      );
     });
 
     it('should handle service not responding errors', async () => {
@@ -238,14 +230,14 @@ describe('PortClient', () => {
         error: 'Service not responding on port 8080',
         code: 'SERVICE_NOT_RESPONDING'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 503 }
-      ));
-
-      await expect(client.exposePort(8080, 'session-err'))
-        .rejects.toThrow(ServiceNotRespondingError);
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 503 })
+      );
+
+      await expect(client.exposePort(8080, 'session-err')).rejects.toThrow(
+        ServiceNotRespondingError
+      );
     });
 
     it('should handle unexpose non-existent port', async () => {
@@ -253,14 +245,14 @@ describe('PortClient', () => {
         error: 'Port not exposed: 9999',
         code: 'PORT_NOT_EXPOSED'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 404 }
-      ));
-
-      await expect(client.unexposePort(9999, 'session-err'))
-        .rejects.toThrow(PortNotExposedError);
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 404 })
+      );
+
+      await expect(client.unexposePort(9999, 'session-err')).rejects.toThrow(
+        PortNotExposedError
+      );
     });
 
     it('should handle port operation failures', async () => {
@@ -268,14 +260,14 @@ describe('PortClient', () => {
         error: 'Port operation failed: unable to setup proxy',
         code: 'PORT_OPERATION_ERROR'
       };
-      
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 500 }
-      ));
-
-      await expect(client.exposePort(3000, 'session-err'))
-        .rejects.toThrow(PortError);
+
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 500 })
+      );
+
+      await expect(client.exposePort(3000, 'session-err')).rejects.toThrow(
+        PortError
+      );
     });
   });
 
@@ -283,19 +275,19 @@ describe('PortClient', () => {
     it('should handle network failures gracefully', async () => {
       mockFetch.mockRejectedValue(new Error('Network connection failed'));
 
-      await expect(client.exposePort(3000, 'session-net'))
-        .rejects.toThrow('Network connection failed');
+      await expect(client.exposePort(3000, 'session-net')).rejects.toThrow(
+        'Network connection failed'
+      );
     });
 
     it('should handle malformed server responses', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        'invalid json {',
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response('invalid json {', { status: 200 })
+      );
 
-      await expect(client.exposePort(3000, 'session-malform'))
-        .rejects.toThrow(SandboxError);
+      await expect(client.exposePort(3000, 'session-malform')).rejects.toThrow(
+        SandboxError
+      );
     });
-
   });
-});
+});