@cloudflare/sandbox 0.4.12 → 0.4.14

package/tests/git-client.test.ts

@@ -19,13 +19,13 @@ describe('GitClient', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    
+
     mockFetch = vi.fn();
     global.fetch = mockFetch as unknown as typeof fetch;
-    
+
     client = new GitClient({
       baseUrl: 'http://test.com',
-      port: 3000,
+      port: 3000
     });
   });
 
@@ -37,18 +37,24 @@ describe('GitClient', () => {
     it('should clone public repositories successfully', async () => {
       const mockResponse: GitCheckoutResponse = {
         success: true,
-        stdout: 'Cloning into \'react\'...\nReceiving objects: 100% (1284/1284), done.',
+        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',
+        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.checkout('https://github.com/facebook/react.git', 'test-session');
+      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');
@@ -59,16 +65,18 @@ describe('GitClient', () => {
     it('should clone repositories to specific branches', async () => {
       const mockResponse: GitCheckoutResponse = {
         success: true,
-        stdout: 'Cloning into \'project\'...\nSwitching to branch \'development\'',
+        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',
+        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.checkout(
         'https://github.com/company/project.git',
@@ -83,16 +91,18 @@ describe('GitClient', () => {
     it('should clone repositories to custom directories', async () => {
       const mockResponse: GitCheckoutResponse = {
         success: true,
-        stdout: 'Cloning into \'workspace/my-app\'...\nDone.',
+        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',
+        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.checkout(
         'https://github.com/user/my-app.git',
@@ -107,18 +117,24 @@ describe('GitClient', () => {
     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.',
+        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',
+        timestamp: '2023-01-01T00:05:30Z'
       };
 
-      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
-      const result = await client.checkout('https://github.com/torvalds/linux.git', 'test-session');
+      const result = await client.checkout(
+        'https://github.com/torvalds/linux.git',
+        'test-session'
+      );
 
       expect(result.success).toBe(true);
       expect(result.stderr).toContain('warning:');
@@ -127,18 +143,23 @@ describe('GitClient', () => {
     it('should handle SSH repository URLs', async () => {
       const mockResponse: GitCheckoutResponse = {
         success: true,
-        stdout: 'Cloning into \'private-project\'...\nDone.',
+        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',
+        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.checkout('git@github.com:company/private-project.git', 'test-session');
+      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');
@@ -149,26 +170,32 @@ describe('GitClient', () => {
         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(),
-        })));
+        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' }),
+        client.checkout('https://github.com/nodejs/node.git', 'session-3', {
+          branch: 'v18.x'
+        })
       ]);
 
       expect(operations).toHaveLength(3);
-      operations.forEach(result => {
+      operations.forEach((result) => {
         expect(result.success).toBe(true);
       });
       expect(mockFetch).toHaveBeenCalledTimes(3);
@@ -177,96 +204,141 @@ describe('GitClient', () => {
 
   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 }
-      ));
+      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);
+      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 }
-      ));
+      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);
+      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 }
-      ));
+      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);
+      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 }
-      ));
+      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);
+      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 }
-      ));
+      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);
+      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 }
-      ));
+      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);
+      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 }
-      ));
+      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);
+      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)',
+        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',
+        timestamp: '2023-01-01T00:01:30Z'
       };
 
-      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockResponse), { status: 200 })
+      );
 
-      const result = await client.checkout('https://github.com/problematic/repo.git', 'test-session');
+      const result = await client.checkout(
+        'https://github.com/problematic/repo.git',
+        'test-session'
+      );
 
       expect(result.success).toBe(false);
       expect(result.exitCode).toBe(128);
@@ -278,35 +350,50 @@ describe('GitClient', () => {
     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');
+      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 }));
+      mockFetch.mockResolvedValue(
+        new Response('invalid json {', { status: 200 })
+      );
 
-      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
-        .rejects.toThrow(SandboxError);
+      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: 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 },
+        { 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);
+        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);
       }
     });
   });
@@ -320,7 +407,7 @@ describe('GitClient', () => {
     it('should initialize with full options', () => {
       const fullOptionsClient = new GitClient({
         baseUrl: 'http://custom.com',
-        port: 8080,
+        port: 8080
       });
       expect(fullOptionsClient).toBeInstanceOf(GitClient);
     });