@cloudflare/sandbox 0.0.0-e1fa354 → 0.0.0-e489cbb

package/tests/command-client.test.ts

@@ -0,0 +1,407 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ExecuteResponse } from '../src/clients';
+import { CommandClient } from '../src/clients/command-client';
+import { CommandError, CommandNotFoundError, SandboxError } from '../src/errors';
+
+describe('CommandClient', () => {
+  let client: CommandClient;
+  let mockFetch: ReturnType<typeof vi.fn>;
+  let onCommandComplete: ReturnType<typeof vi.fn>;
+  let onError: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockFetch = vi.fn();
+    global.fetch = mockFetch as unknown as typeof fetch;
+    
+    onCommandComplete = vi.fn();
+    onError = vi.fn();
+    
+    client = new CommandClient({
+      baseUrl: 'http://test.com',
+      port: 3000,
+      onCommandComplete,
+      onError,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('execute', () => {
+    it('should execute simple commands successfully', async () => {
+      const mockResponse: ExecuteResponse = {
+        success: true,
+        stdout: 'Hello World\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'echo "Hello World"',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.execute('echo "Hello World"', 'session-exec');
+
+      expect(result.success).toBe(true);
+      expect(result.stdout).toBe('Hello World\n');
+      expect(result.stderr).toBe('');
+      expect(result.exitCode).toBe(0);
+      expect(result.command).toBe('echo "Hello World"');
+      expect(onCommandComplete).toHaveBeenCalledWith(
+        true, 0, 'Hello World\n', '', 'echo "Hello World"'
+      );
+    });
+
+    it('should handle command failures with proper exit codes', async () => {
+      const mockResponse: ExecuteResponse = {
+        success: false,
+        stdout: '',
+        stderr: 'command not found: nonexistent-cmd\n',
+        exitCode: 127,
+        command: 'nonexistent-cmd',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.execute('nonexistent-cmd', 'session-exec');
+
+      expect(result.success).toBe(false);
+      expect(result.exitCode).toBe(127);
+      expect(result.stderr).toContain('command not found');
+      expect(result.stdout).toBe('');
+      expect(onCommandComplete).toHaveBeenCalledWith(
+        false, 127, '', 'command not found: nonexistent-cmd\n', 'nonexistent-cmd'
+      );
+    });
+
+    it('should handle container-level errors with proper error mapping', async () => {
+      const errorResponse = {
+        code: 'COMMAND_NOT_FOUND',
+        message: 'Command not found: invalidcmd',
+        context: { command: 'invalidcmd' },
+        httpStatus: 404,
+        timestamp: new Date().toISOString()
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(errorResponse),
+        { status: 404 }
+      ));
+
+      await expect(client.execute('invalidcmd', 'session-err'))
+        .rejects.toThrow(CommandNotFoundError);
+      expect(onError).toHaveBeenCalledWith(
+        expect.stringContaining('Command not found'),
+        'invalidcmd'
+      );
+    });
+
+    it('should handle network failures gracefully', async () => {
+      mockFetch.mockRejectedValue(new Error('Network connection failed'));
+
+      await expect(client.execute('ls', 'session-err'))
+        .rejects.toThrow('Network connection failed');
+      expect(onError).toHaveBeenCalledWith('Network connection failed', 'ls');
+    });
+
+    it('should handle server errors with proper status codes', async () => {
+      const scenarios = [
+        { status: 400, code: 'COMMAND_EXECUTION_ERROR', error: CommandError },
+        { status: 500, code: 'EXECUTION_ERROR', error: SandboxError },
+      ];
+
+      for (const scenario of scenarios) {
+        mockFetch.mockResolvedValueOnce(new Response(
+          JSON.stringify({
+            code: scenario.code,
+            message: 'Test error',
+            context: {},
+            httpStatus: scenario.status,
+            timestamp: new Date().toISOString()
+          }),
+          { status: scenario.status }
+        ));
+        await expect(client.execute('test-command', 'session-err'))
+          .rejects.toThrow(scenario.error);
+      }
+    });
+
+    it('should handle commands with large output', async () => {
+      const largeOutput = 'line of output\n'.repeat(10000);
+      const mockResponse: ExecuteResponse = {
+        success: true,
+        stdout: largeOutput,
+        stderr: '',
+        exitCode: 0,
+        command: 'find / -type f',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await client.execute('find / -type f', 'session-exec');
+
+      expect(result.success).toBe(true);
+      expect(result.stdout.length).toBeGreaterThan(100000);
+      expect(result.stdout.split('\n')).toHaveLength(10001);
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should handle concurrent command executions', async () => {
+      mockFetch.mockImplementation((url: string, options: RequestInit) => {
+        const body = JSON.parse(options.body as string);
+        const command = body.command;
+        return Promise.resolve(new Response(
+          JSON.stringify({
+            success: true,
+            stdout: `output for ${command}\n`,
+            stderr: '',
+            exitCode: 0,
+            command: command,
+            timestamp: '2023-01-01T00:00:00Z',
+          }),
+          { status: 200 }
+        ));
+      });
+
+      const commands = ['echo 1', 'echo 2', 'echo 3', 'pwd', 'ls'];
+      const results = await Promise.all(
+        commands.map(cmd => client.execute(cmd, 'session-concurrent'))
+      );
+
+      expect(results).toHaveLength(5);
+      results.forEach((result, index) => {
+        expect(result.success).toBe(true);
+        expect(result.stdout).toBe(`output for ${commands[index]}\n`);
+        expect(result.exitCode).toBe(0);
+      });
+      expect(onCommandComplete).toHaveBeenCalledTimes(5);
+    });
+
+    it('should handle malformed server responses', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        'invalid json {',
+        { status: 200, headers: { 'Content-Type': 'application/json' } }
+      ));
+
+      await expect(client.execute('ls', 'session-err'))
+        .rejects.toThrow(SandboxError);
+      expect(onError).toHaveBeenCalled();
+    });
+
+    it('should handle empty command input', async () => {
+      const errorResponse = {
+        code: 'INVALID_COMMAND',
+        message: 'Invalid command: empty command provided',
+        context: {},
+        httpStatus: 400,
+        timestamp: new Date().toISOString()
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(errorResponse),
+        { status: 400 }
+      ));
+
+      await expect(client.execute('', 'session-err'))
+        .rejects.toThrow(CommandError);
+    });
+
+    it('should handle streaming command execution', async () => {
+      const streamContent = [
+        'data: {"type":"start","command":"tail -f app.log","timestamp":"2023-01-01T00:00:00Z"}\n\n',
+        'data: {"type":"stdout","data":"log line 1\\n","timestamp":"2023-01-01T00:00:01Z"}\n\n',
+        'data: {"type":"stdout","data":"log line 2\\n","timestamp":"2023-01-01T00:00:02Z"}\n\n',
+        'data: {"type":"complete","exitCode":0,"timestamp":"2023-01-01T00:00:03Z"}\n\n'
+      ].join('');
+
+      const mockStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(streamContent));
+          controller.close();
+        }
+      });
+
+      mockFetch.mockResolvedValue(new Response(mockStream, {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' }
+      }));
+
+      const stream = await client.executeStream('tail -f app.log', 'session-stream');
+      expect(stream).toBeInstanceOf(ReadableStream);
+
+      const reader = stream.getReader();
+      const decoder = new TextDecoder();
+      let content = '';
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          content += decoder.decode(value);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+
+      expect(content).toContain('tail -f app.log');
+      expect(content).toContain('log line 1');
+      expect(content).toContain('log line 2');
+      expect(content).toContain('"type":"complete"');
+    });
+
+
+    it('should handle streaming errors gracefully', async () => {
+      const errorResponse = {
+        code: 'STREAM_START_ERROR',
+        message: 'Command failed to start streaming',
+        context: { command: 'invalid-stream-command' },
+        httpStatus: 400,
+        timestamp: new Date().toISOString()
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(errorResponse),
+        { status: 400 }
+      ));
+
+      await expect(client.executeStream('invalid-stream-command', 'session-err'))
+        .rejects.toThrow(CommandError);
+      expect(onError).toHaveBeenCalledWith(
+        expect.stringContaining('Command failed to start streaming'),
+        'invalid-stream-command'
+      );
+    });
+
+    it('should handle streaming without response body', async () => {
+      mockFetch.mockResolvedValue(new Response(null, {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' }
+      }));
+
+      await expect(client.executeStream('test-command', 'session-err'))
+        .rejects.toThrow('No response body for streaming');
+    });
+
+    it('should handle network failures during streaming setup', async () => {
+      mockFetch.mockRejectedValue(new Error('Connection lost during streaming'));
+
+      await expect(client.executeStream('stream-command', 'session-err'))
+        .rejects.toThrow('Connection lost during streaming');
+      expect(onError).toHaveBeenCalledWith(
+        'Connection lost during streaming',
+        'stream-command'
+      );
+    });
+  });
+
+  describe('callback integration', () => {
+    it('should work without any callbacks', async () => {
+      const clientWithoutCallbacks = new CommandClient({
+        baseUrl: 'http://test.com',
+        port: 3000,
+      });
+
+      const mockResponse: ExecuteResponse = {
+        success: true,
+        stdout: 'test output\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'echo test',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockResponse),
+        { status: 200 }
+      ));
+
+      const result = await clientWithoutCallbacks.execute('echo test', 'session-nocb');
+
+      expect(result.success).toBe(true);
+      expect(result.stdout).toBe('test output\n');
+    });
+
+    it('should handle errors gracefully without callbacks', async () => {
+      const clientWithoutCallbacks = new CommandClient({
+        baseUrl: 'http://test.com',
+        port: 3000,
+      });
+
+      mockFetch.mockRejectedValue(new Error('Network failed'));
+
+      await expect(clientWithoutCallbacks.execute('test', 'session-nocb'))
+        .rejects.toThrow('Network failed');
+    });
+
+    it('should call onCommandComplete for both success and failure', async () => {
+      const successResponse: ExecuteResponse = {
+        success: true,
+        stdout: 'success\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'echo success',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValueOnce(new Response(
+        JSON.stringify(successResponse),
+        { status: 200 }
+      ));
+
+      await client.execute('echo success', 'session-cb');
+      expect(onCommandComplete).toHaveBeenLastCalledWith(
+        true, 0, 'success\n', '', 'echo success'
+      );
+
+      const failureResponse: ExecuteResponse = {
+        success: false,
+        stdout: '',
+        stderr: 'error\n',
+        exitCode: 1,
+        command: 'false',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValueOnce(new Response(
+        JSON.stringify(failureResponse),
+        { status: 200 }
+      ));
+
+      await client.execute('false', 'session-cb');
+      expect(onCommandComplete).toHaveBeenLastCalledWith(
+        false, 1, '', 'error\n', 'false'
+      );
+    });
+  });
+
+  describe('constructor options', () => {
+    it('should initialize with minimal options', async () => {
+      const minimalClient = new CommandClient();
+      expect(minimalClient).toBeDefined();
+    });
+
+    it('should initialize with full options', async () => {
+      const fullOptionsClient = new CommandClient({
+        baseUrl: 'http://custom.com',
+        port: 8080,
+        onCommandComplete: vi.fn(),
+        onError: vi.fn(),
+      });
+      expect(fullOptionsClient).toBeDefined();
+    });
+  });
+});