@cloudflare/sandbox 0.5.4 → 0.6.0

package/tests/file-stream.test.ts

@@ -1,310 +0,0 @@
-import type { FileMetadata } from '@repo/shared';
-import { describe, expect, it } from 'vitest';
-import { collectFile, streamFile } from '../src/file-stream';
-
-describe('File Streaming Utilities', () => {
-  /**
-   * Helper to create a mock SSE stream for testing
-   */
-  function createMockSSEStream(events: string[]): ReadableStream<Uint8Array> {
-    return new ReadableStream({
-      start(controller) {
-        for (const event of events) {
-          controller.enqueue(new TextEncoder().encode(event));
-        }
-        controller.close();
-      }
-    });
-  }
-
-  describe('streamFile', () => {
-    it('should stream text file chunks and return metadata', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":11,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {"type":"chunk","data":"Hello"}\n\n',
-        'data: {"type":"chunk","data":" World"}\n\n',
-        'data: {"type":"complete","bytesRead":11}\n\n'
-      ]);
-
-      const chunks: string[] = [];
-      const generator = streamFile(stream);
-      let result = await generator.next();
-
-      // Collect chunks
-      while (!result.done) {
-        chunks.push(result.value as string);
-        result = await generator.next();
-      }
-
-      // Metadata is the return value
-      const metadata = result.value;
-
-      expect(chunks).toEqual(['Hello', ' World']);
-      expect(metadata).toEqual({
-        mimeType: 'text/plain',
-        size: 11,
-        isBinary: false,
-        encoding: 'utf-8'
-      });
-    });
-
-    it('should stream binary file with base64 decoding', async () => {
-      // Base64 encoded "test" = "dGVzdA=="
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"image/png","size":4,"isBinary":true,"encoding":"base64"}\n\n',
-        'data: {"type":"chunk","data":"dGVzdA=="}\n\n',
-        'data: {"type":"complete","bytesRead":4}\n\n'
-      ]);
-
-      const chunks: (string | Uint8Array)[] = [];
-      const generator = streamFile(stream);
-      let result = await generator.next();
-
-      // Collect chunks
-      while (!result.done) {
-        chunks.push(result.value);
-        result = await generator.next();
-      }
-
-      const metadata = result.value;
-
-      // For binary files, chunks should be Uint8Array
-      expect(chunks.length).toBeGreaterThan(0);
-      expect(chunks[0]).toBeInstanceOf(Uint8Array);
-
-      // Verify we can reconstruct the original data
-      const allBytes = new Uint8Array(
-        chunks.reduce((acc, chunk) => {
-          if (chunk instanceof Uint8Array) {
-            return acc + chunk.length;
-          }
-          return acc;
-        }, 0)
-      );
-
-      let offset = 0;
-      for (const chunk of chunks) {
-        if (chunk instanceof Uint8Array) {
-          allBytes.set(chunk, offset);
-          offset += chunk.length;
-        }
-      }
-
-      const decoded = new TextDecoder().decode(allBytes);
-      expect(decoded).toBe('test');
-
-      expect(metadata?.isBinary).toBe(true);
-      expect(metadata?.encoding).toBe('base64');
-      expect(metadata?.mimeType).toBe('image/png');
-    });
-
-    it('should handle empty files', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":0,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {"type":"complete","bytesRead":0}\n\n'
-      ]);
-
-      const chunks: string[] = [];
-      const generator = streamFile(stream);
-      let result = await generator.next();
-
-      while (!result.done) {
-        chunks.push(result.value as string);
-        result = await generator.next();
-      }
-
-      const metadata = result.value;
-
-      expect(chunks).toEqual([]);
-      expect(metadata?.size).toBe(0);
-    });
-
-    it('should handle error events', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":100,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {"type":"chunk","data":"Hello"}\n\n',
-        'data: {"type":"error","error":"Read error: Permission denied"}\n\n'
-      ]);
-
-      const generator = streamFile(stream);
-
-      try {
-        let result = await generator.next();
-        while (!result.done) {
-          result = await generator.next();
-        }
-        // Should have thrown
-        expect(true).toBe(false);
-      } catch (error) {
-        expect((error as Error).message).toContain(
-          'Read error: Permission denied'
-        );
-      }
-    });
-  });
-
-  describe('collectFile', () => {
-    it('should collect entire text file into string', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":11,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {"type":"chunk","data":"Hello"}\n\n',
-        'data: {"type":"chunk","data":" World"}\n\n',
-        'data: {"type":"complete","bytesRead":11}\n\n'
-      ]);
-
-      const result = await collectFile(stream);
-
-      expect(result.content).toBe('Hello World');
-      expect(result.metadata).toEqual({
-        mimeType: 'text/plain',
-        size: 11,
-        isBinary: false,
-        encoding: 'utf-8'
-      });
-    });
-
-    it('should collect entire binary file into Uint8Array', async () => {
-      // Base64 encoded "test" = "dGVzdA=="
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"image/png","size":4,"isBinary":true,"encoding":"base64"}\n\n',
-        'data: {"type":"chunk","data":"dGVzdA=="}\n\n',
-        'data: {"type":"complete","bytesRead":4}\n\n'
-      ]);
-
-      const result = await collectFile(stream);
-
-      expect(result.content).toBeInstanceOf(Uint8Array);
-      expect(result.metadata.isBinary).toBe(true);
-
-      // Decode to verify content
-      const decoded = new TextDecoder().decode(result.content as Uint8Array);
-      expect(decoded).toBe('test');
-    });
-
-    it('should handle empty files', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":0,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {"type":"complete","bytesRead":0}\n\n'
-      ]);
-
-      const result = await collectFile(stream);
-
-      expect(result.content).toBe('');
-      expect(result.metadata.size).toBe(0);
-    });
-
-    it('should propagate errors from stream', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":100,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {"type":"chunk","data":"Hello"}\n\n',
-        'data: {"type":"error","error":"File not found"}\n\n'
-      ]);
-
-      await expect(collectFile(stream)).rejects.toThrow('File not found');
-    });
-
-    it('should handle large text files efficiently', async () => {
-      // Create a stream with many chunks
-      const chunkCount = 100;
-      const events = [
-        'data: {"type":"metadata","mimeType":"text/plain","size":500,"isBinary":false,"encoding":"utf-8"}\n\n'
-      ];
-
-      for (let i = 0; i < chunkCount; i++) {
-        events.push(`data: {"type":"chunk","data":"chunk${i}"}\n\n`);
-      }
-
-      events.push('data: {"type":"complete","bytesRead":500}\n\n');
-
-      const stream = createMockSSEStream(events);
-      const result = await collectFile(stream);
-
-      expect(typeof result.content).toBe('string');
-      expect(result.content).toContain('chunk0');
-      expect(result.content).toContain('chunk99');
-      expect(result.metadata.encoding).toBe('utf-8');
-    });
-
-    it('should handle large binary files efficiently', async () => {
-      // Create a stream with many base64 chunks
-      const chunkCount = 100;
-      const events = [
-        'data: {"type":"metadata","mimeType":"application/octet-stream","size":400,"isBinary":true,"encoding":"base64"}\n\n'
-      ];
-
-      for (let i = 0; i < chunkCount; i++) {
-        // Each "AAAA" base64 chunk decodes to 3 bytes (0x00, 0x00, 0x00)
-        events.push('data: {"type":"chunk","data":"AAAA"}\n\n');
-      }
-
-      events.push('data: {"type":"complete","bytesRead":400}\n\n');
-
-      const stream = createMockSSEStream(events);
-      const result = await collectFile(stream);
-
-      expect(result.content).toBeInstanceOf(Uint8Array);
-      expect((result.content as Uint8Array).length).toBeGreaterThan(0);
-      expect(result.metadata.isBinary).toBe(true);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle streams with no metadata event', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"chunk","data":"Hello"}\n\n',
-        'data: {"type":"complete","bytesRead":5}\n\n'
-      ]);
-
-      // Without metadata, we don't know if it's binary or text
-      // The implementation should throw
-      const generator = streamFile(stream);
-
-      try {
-        let result = await generator.next();
-        while (!result.done) {
-          result = await generator.next();
-        }
-        // Should have thrown
-        expect(true).toBe(false);
-      } catch (error) {
-        expect((error as Error).message).toContain(
-          'Received chunk before metadata'
-        );
-      }
-    });
-
-    it('should handle malformed JSON in SSE events', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"metadata","mimeType":"text/plain","size":5,"isBinary":false,"encoding":"utf-8"}\n\n',
-        'data: {invalid json\n\n',
-        'data: {"type":"complete","bytesRead":5}\n\n'
-      ]);
-
-      // Malformed JSON is logged but doesn't break the stream
-      // It should complete successfully but with no chunks
-      const result = await collectFile(stream);
-      expect(result.content).toBe('');
-    });
-
-    it('should handle base64 padding correctly', async () => {
-      // Test various base64 strings with different padding
-      const testCases = [
-        { input: 'YQ==', expected: 'a' }, // 1 byte, 2 padding
-        { input: 'YWI=', expected: 'ab' }, // 2 bytes, 1 padding
-        { input: 'YWJj', expected: 'abc' } // 3 bytes, no padding
-      ];
-
-      for (const testCase of testCases) {
-        const stream = createMockSSEStream([
-          `data: {"type":"metadata","mimeType":"application/octet-stream","size":${testCase.expected.length},"isBinary":true,"encoding":"base64"}\n\n`,
-          `data: {"type":"chunk","data":"${testCase.input}"}\n\n`,
-          `data: {"type":"complete","bytesRead":${testCase.expected.length}}\n\n`
-        ]);
-
-        const result = await collectFile(stream);
-        const decoded = new TextDecoder().decode(result.content as Uint8Array);
-        expect(decoded).toBe(testCase.expected);
-      }
-    });
-  });
-});

package/tests/get-sandbox.test.ts

@@ -1,172 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getSandbox } from '../src/sandbox';
-
-// Mock the Container module
-vi.mock('@cloudflare/containers', () => ({
-  Container: class Container {
-    ctx: any;
-    env: any;
-    sleepAfter: string | number = '10m';
-    constructor(ctx: any, env: any) {
-      this.ctx = ctx;
-      this.env = env;
-    }
-  },
-  getContainer: vi.fn()
-}));
-
-describe('getSandbox', () => {
-  let mockStub: any;
-  let mockGetContainer: any;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-
-    // Create a fresh mock stub for each test
-    mockStub = {
-      sleepAfter: '10m',
-      setSandboxName: vi.fn(),
-      setBaseUrl: vi.fn(),
-      setSleepAfter: vi.fn((value: string | number) => {
-        mockStub.sleepAfter = value;
-      }),
-      setKeepAlive: vi.fn()
-    };
-
-    // Mock getContainer to return our stub
-    const containers = await import('@cloudflare/containers');
-    mockGetContainer = vi.mocked(containers.getContainer);
-    mockGetContainer.mockReturnValue(mockStub);
-  });
-
-  it('should create a sandbox instance with default sleepAfter', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox');
-
-    expect(sandbox).toBeDefined();
-    expect(sandbox.setSandboxName).toHaveBeenCalledWith(
-      'test-sandbox',
-      undefined
-    );
-  });
-
-  it('should apply sleepAfter option when provided as string', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      sleepAfter: '5m'
-    });
-
-    expect(sandbox.sleepAfter).toBe('5m');
-  });
-
-  it('should apply sleepAfter option when provided as number', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      sleepAfter: 300 // 5 minutes in seconds
-    });
-
-    expect(sandbox.sleepAfter).toBe(300);
-  });
-
-  it('should apply baseUrl option when provided', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      baseUrl: 'https://example.com'
-    });
-
-    expect(sandbox.setBaseUrl).toHaveBeenCalledWith('https://example.com');
-  });
-
-  it('should apply both sleepAfter and baseUrl options together', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      sleepAfter: '10m',
-      baseUrl: 'https://example.com'
-    });
-
-    expect(sandbox.sleepAfter).toBe('10m');
-    expect(sandbox.setBaseUrl).toHaveBeenCalledWith('https://example.com');
-  });
-
-  it('should not apply sleepAfter when not provided', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox');
-
-    // Should remain default value from Container
-    expect(sandbox.sleepAfter).toBe('10m');
-  });
-
-  it('should accept various time string formats for sleepAfter', () => {
-    const mockNamespace = {} as any;
-    const testCases = ['30s', '1m', '10m', '1h', '2h'];
-
-    for (const timeString of testCases) {
-      // Reset the mock stub for each iteration
-      mockStub.sleepAfter = '3m';
-
-      const sandbox = getSandbox(mockNamespace, `test-sandbox-${timeString}`, {
-        sleepAfter: timeString
-      });
-
-      expect(sandbox.sleepAfter).toBe(timeString);
-    }
-  });
-
-  it('should apply keepAlive option when provided as true', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      keepAlive: true
-    });
-
-    expect(sandbox.setKeepAlive).toHaveBeenCalledWith(true);
-  });
-
-  it('should apply keepAlive option when provided as false', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      keepAlive: false
-    });
-
-    expect(sandbox.setKeepAlive).toHaveBeenCalledWith(false);
-  });
-
-  it('should not call setKeepAlive when keepAlive option not provided', () => {
-    const mockNamespace = {} as any;
-    getSandbox(mockNamespace, 'test-sandbox');
-
-    expect(mockStub.setKeepAlive).not.toHaveBeenCalled();
-  });
-
-  it('should apply keepAlive alongside other options', () => {
-    const mockNamespace = {} as any;
-    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
-      sleepAfter: '5m',
-      baseUrl: 'https://example.com',
-      keepAlive: true
-    });
-
-    expect(sandbox.sleepAfter).toBe('5m');
-    expect(sandbox.setBaseUrl).toHaveBeenCalledWith('https://example.com');
-    expect(sandbox.setKeepAlive).toHaveBeenCalledWith(true);
-  });
-
-  it('should preserve sandbox ID case by default', () => {
-    const mockNamespace = {} as any;
-    getSandbox(mockNamespace, 'MyProject-ABC123');
-
-    expect(mockGetContainer).toHaveBeenCalledWith(
-      mockNamespace,
-      'MyProject-ABC123'
-    );
-  });
-
-  it('should normalize sandbox ID to lowercase when normalizeId option is true', () => {
-    const mockNamespace = {} as any;
-    getSandbox(mockNamespace, 'MyProject-ABC123', { normalizeId: true });
-
-    expect(mockGetContainer).toHaveBeenCalledWith(
-      mockNamespace,
-      'myproject-abc123'
-    );
-  });
-});