@cloudflare/sandbox 0.0.0-02ee8fe

package/tests/git-client.test.ts

@@ -0,0 +1,328 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { GitCheckoutResponse } from '../src/clients';
+import { GitClient } from '../src/clients/git-client';
+import {
+  GitAuthenticationError,
+  GitBranchNotFoundError,
+  GitCheckoutError,
+  GitCloneError,
+  GitError,
+  GitNetworkError,
+  GitRepositoryNotFoundError,
+  InvalidGitUrlError,
+  SandboxError
+} from '../src/errors';
+
+describe('GitClient', () => {
+  let client: GitClient;
+  let mockFetch: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockFetch = vi.fn();
+    global.fetch = mockFetch as unknown as typeof fetch;
+    
+    client = new GitClient({
+      baseUrl: 'http://test.com',
+      port: 3000,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('repository cloning', () => {
+    it('should clone public repositories successfully', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'react\'...\nReceiving objects: 100% (1284/1284), done.',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'https://github.com/facebook/react.git',
+        branch: 'main',
+        targetDir: 'react',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('https://github.com/facebook/react.git', 'test-session');
+
+      expect(result.success).toBe(true);
+      expect(result.repoUrl).toBe('https://github.com/facebook/react.git');
+      expect(result.branch).toBe('main');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should clone repositories to specific branches', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'project\'...\nSwitching to branch \'development\'',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'https://github.com/company/project.git',
+        branch: 'development',
+        targetDir: 'project',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout(
+        'https://github.com/company/project.git',
+        'test-session',
+        { branch: 'development' }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.branch).toBe('development');
+    });
+
+    it('should clone repositories to custom directories', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'workspace/my-app\'...\nDone.',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'https://github.com/user/my-app.git',
+        branch: 'main',
+        targetDir: 'workspace/my-app',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout(
+        'https://github.com/user/my-app.git',
+        'test-session',
+        { targetDir: 'workspace/my-app' }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.targetDir).toBe('workspace/my-app');
+    });
+
+    it('should handle large repository clones with warnings', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'linux\'...\nReceiving objects: 100% (8125432/8125432), 2.34 GiB, done.',
+        stderr: 'warning: filtering not recognized by server',
+        exitCode: 0,
+        repoUrl: 'https://github.com/torvalds/linux.git',
+        branch: 'master',
+        targetDir: 'linux',
+        timestamp: '2023-01-01T00:05:30Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('https://github.com/torvalds/linux.git', 'test-session');
+
+      expect(result.success).toBe(true);
+      expect(result.stderr).toContain('warning:');
+    });
+
+    it('should handle SSH repository URLs', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'private-project\'...\nDone.',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'git@github.com:company/private-project.git',
+        branch: 'main',
+        targetDir: 'private-project',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('git@github.com:company/private-project.git', 'test-session');
+
+      expect(result.success).toBe(true);
+      expect(result.repoUrl).toBe('git@github.com:company/private-project.git');
+    });
+
+    it('should handle concurrent repository operations', async () => {
+      mockFetch.mockImplementation((url: string, options: RequestInit) => {
+        const body = JSON.parse(options.body as string);
+        const repoName = body.repoUrl.split('/').pop().replace('.git', '');
+
+        return Promise.resolve(new Response(JSON.stringify({
+          success: true,
+          stdout: `Cloning into '${repoName}'...\nDone.`,
+          stderr: '',
+          exitCode: 0,
+          repoUrl: body.repoUrl,
+          branch: body.branch || 'main',
+          targetDir: body.targetDir || repoName,
+          timestamp: new Date().toISOString(),
+        })));
+      });
+
+      const operations = await Promise.all([
+        client.checkout('https://github.com/facebook/react.git', 'session-1'),
+        client.checkout('https://github.com/microsoft/vscode.git', 'session-2'),
+        client.checkout('https://github.com/nodejs/node.git', 'session-3', { branch: 'v18.x' }),
+      ]);
+
+      expect(operations).toHaveLength(3);
+      operations.forEach(result => {
+        expect(result.success).toBe(true);
+      });
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('repository error handling', () => {
+    it('should handle repository not found errors', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Repository not found', code: 'GIT_REPOSITORY_NOT_FOUND' }),
+        { status: 404 }
+      ));
+
+      await expect(client.checkout('https://github.com/user/nonexistent.git', 'test-session'))
+        .rejects.toThrow(GitRepositoryNotFoundError);
+    });
+
+    it('should handle authentication failures', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Authentication failed', code: 'GIT_AUTH_FAILED' }),
+        { status: 401 }
+      ));
+
+      await expect(client.checkout('https://github.com/company/private.git', 'test-session'))
+        .rejects.toThrow(GitAuthenticationError);
+    });
+
+    it('should handle branch not found errors', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Branch not found', code: 'GIT_BRANCH_NOT_FOUND' }),
+        { status: 404 }
+      ));
+
+      await expect(client.checkout(
+        'https://github.com/user/repo.git',
+        'test-session',
+        { branch: 'nonexistent-branch' }
+      )).rejects.toThrow(GitBranchNotFoundError);
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Network error', code: 'GIT_NETWORK_ERROR' }),
+        { status: 503 }
+      ));
+
+      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
+        .rejects.toThrow(GitNetworkError);
+    });
+
+    it('should handle clone failures', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Clone failed', code: 'GIT_CLONE_FAILED' }),
+        { status: 507 }
+      ));
+
+      await expect(client.checkout('https://github.com/large/repository.git', 'test-session'))
+        .rejects.toThrow(GitCloneError);
+    });
+
+    it('should handle checkout failures', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Checkout failed', code: 'GIT_CHECKOUT_FAILED' }),
+        { status: 409 }
+      ));
+
+      await expect(client.checkout(
+        'https://github.com/user/repo.git',
+        'test-session',
+        { branch: 'feature-branch' }
+      )).rejects.toThrow(GitCheckoutError);
+    });
+
+    it('should handle invalid Git URLs', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Invalid Git URL', code: 'INVALID_GIT_URL' }),
+        { status: 400 }
+      ));
+
+      await expect(client.checkout('not-a-valid-url', 'test-session'))
+        .rejects.toThrow(InvalidGitUrlError);
+    });
+
+    it('should handle partial clone failures', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: false,
+        stdout: 'Cloning into \'repo\'...\nReceiving objects:  45% (450/1000)',
+        stderr: 'error: RPC failed\nfatal: early EOF',
+        exitCode: 128,
+        repoUrl: 'https://github.com/problematic/repo.git',
+        branch: 'main',
+        targetDir: 'repo',
+        timestamp: '2023-01-01T00:01:30Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('https://github.com/problematic/repo.git', 'test-session');
+
+      expect(result.success).toBe(false);
+      expect(result.exitCode).toBe(128);
+      expect(result.stderr).toContain('RPC failed');
+    });
+  });
+
+  describe('error handling edge cases', () => {
+    it('should handle network failures', async () => {
+      mockFetch.mockRejectedValue(new Error('Network connection failed'));
+
+      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
+        .rejects.toThrow('Network connection failed');
+    });
+
+    it('should handle malformed server responses', async () => {
+      mockFetch.mockResolvedValue(new Response('invalid json {', { status: 200 }));
+
+      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
+        .rejects.toThrow(SandboxError);
+    });
+
+    it('should map server errors to client errors', async () => {
+      const serverErrorScenarios = [
+        { status: 400, code: 'INVALID_GIT_URL', error: InvalidGitUrlError },
+        { status: 401, code: 'GIT_AUTH_FAILED', error: GitAuthenticationError },
+        { status: 404, code: 'GIT_REPOSITORY_NOT_FOUND', error: GitRepositoryNotFoundError },
+        { status: 404, code: 'GIT_BRANCH_NOT_FOUND', error: GitBranchNotFoundError },
+        { status: 500, code: 'GIT_OPERATION_FAILED', error: GitError },
+        { status: 503, code: 'GIT_NETWORK_ERROR', error: GitNetworkError },
+      ];
+
+      for (const scenario of serverErrorScenarios) {
+        mockFetch.mockResolvedValueOnce(new Response(
+          JSON.stringify({ error: 'Test error', code: scenario.code }),
+          { status: scenario.status }
+        ));
+
+        await expect(client.checkout('https://github.com/test/repo.git', 'test-session'))
+          .rejects.toThrow(scenario.error);
+      }
+    });
+  });
+
+  describe('constructor options', () => {
+    it('should initialize with minimal options', () => {
+      const minimalClient = new GitClient();
+      expect(minimalClient).toBeInstanceOf(GitClient);
+    });
+
+    it('should initialize with full options', () => {
+      const fullOptionsClient = new GitClient({
+        baseUrl: 'http://custom.com',
+        port: 8080,
+      });
+      expect(fullOptionsClient).toBeInstanceOf(GitClient);
+    });
+  });
+});

package/tests/port-client.test.ts

@@ -0,0 +1,301 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { 
+  ExposePortResponse, 
+  GetExposedPortsResponse,
+  UnexposePortResponse 
+} from '../src/clients';
+import { PortClient } from '../src/clients/port-client';
+import {
+  InvalidPortError,
+  PortAlreadyExposedError,
+  PortError,
+  PortInUseError,
+  PortNotExposedError,
+  SandboxError, 
+  ServiceNotRespondingError
+} from '../src/errors';
+
+describe('PortClient', () => {
+  let client: PortClient;
+  let mockFetch: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockFetch = vi.fn();
+    global.fetch = mockFetch as unknown as typeof fetch;
+    
+    client = new PortClient({
+      baseUrl: 'http://test.com',
+      port: 3000,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('service exposure', () => {
+    it('should expose web services successfully', async () => {
+      const mockResponse: ExposePortResponse = {
+        success: true,
+        port: 3001,
+        exposedAt: 'https://preview-abc123.workers.dev',
+        name: 'web-server',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+      
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.exposePort(3001, 'session-123', 'web-server');
+
+      expect(result.success).toBe(true);
+      expect(result.port).toBe(3001);
+      expect(result.exposedAt).toBe('https://preview-abc123.workers.dev');
+      expect(result.name).toBe('web-server');
+      expect(result.exposedAt.startsWith('https://')).toBe(true);
+    });
+
+    it('should expose API services on different ports', async () => {
+      const mockResponse: ExposePortResponse = {
+        success: true,
+        port: 8080,
+        exposedAt: 'https://api-def456.workers.dev',
+        name: 'api-server',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+      
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.exposePort(8080, 'session-456', 'api-server');
+
+      expect(result.success).toBe(true);
+      expect(result.port).toBe(8080);
+      expect(result.name).toBe('api-server');
+      expect(result.exposedAt).toContain('api-');
+    });
+
+    it('should expose services without explicit names', async () => {
+      const mockResponse: ExposePortResponse = {
+        success: true,
+        port: 5000,
+        exposedAt: 'https://service-ghi789.workers.dev',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+      
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.exposePort(5000, 'session-789');
+
+      expect(result.success).toBe(true);
+      expect(result.port).toBe(5000);
+      expect(result.name).toBeUndefined();
+      expect(result.exposedAt).toBeDefined();
+    });
+
+  });
+
+  describe('service management', () => {
+    it('should list all exposed services', async () => {
+      const mockResponse: GetExposedPortsResponse = {
+        success: true,
+        ports: [
+          {
+            port: 3000,
+            exposedAt: 'https://frontend-abc123.workers.dev',
+            name: 'frontend',
+          },
+          {
+            port: 4000,
+            exposedAt: 'https://api-def456.workers.dev',
+            name: 'api',
+          },
+          {
+            port: 5432,
+            exposedAt: 'https://db-ghi789.workers.dev',
+            name: 'database',
+          }
+        ],
+        count: 3,
+        timestamp: '2023-01-01T00:10:00Z',
+      };
+      
+      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 => {
+        expect(service.exposedAt).toContain('.workers.dev');
+        expect(service.port).toBeGreaterThan(0);
+        expect(service.name).toBeDefined();
+      });
+    });
+
+    it('should handle empty exposed ports list', async () => {
+      const mockResponse: GetExposedPortsResponse = {
+        success: true,
+        ports: [],
+        count: 0,
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+      
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.getExposedPorts('session-empty');
+
+      expect(result.success).toBe(true);
+      expect(result.count).toBe(0);
+      expect(result.ports).toHaveLength(0);
+    });
+
+    it('should unexpose services cleanly', async () => {
+      const mockResponse: UnexposePortResponse = {
+        success: true,
+        port: 3001,
+        timestamp: '2023-01-01T00:15:00Z',
+      };
+      
+      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', () => {
+    it('should handle port already exposed errors', async () => {
+      const errorResponse = {
+        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);
+    });
+
+    it('should handle invalid port numbers', async () => {
+      const errorResponse = {
+        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);
+    });
+
+    it('should handle port in use errors', async () => {
+      const errorResponse = {
+        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);
+    });
+
+    it('should handle service not responding errors', async () => {
+      const errorResponse = {
+        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);
+    });
+
+    it('should handle unexpose non-existent port', async () => {
+      const errorResponse = {
+        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);
+    });
+
+    it('should handle port operation failures', async () => {
+      const errorResponse = {
+        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);
+    });
+  });
+
+  describe('edge cases and resilience', () => {
+    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');
+    });
+
+    it('should handle malformed server responses', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        'invalid json {',
+        { status: 200 }
+      ));
+
+      await expect(client.exposePort(3000, 'session-malform'))
+        .rejects.toThrow(SandboxError);
+    });
+
+  });
+});