@cloudflare/sandbox 0.5.4 → 0.6.0

package/tests/sse-parser.test.ts

@@ -1,291 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  asyncIterableToSSEStream,
-  parseSSEStream,
-  responseToAsyncIterable
-} from '../src/sse-parser';
-
-function createMockSSEStream(events: string[]): ReadableStream<Uint8Array> {
-  return new ReadableStream({
-    start(controller) {
-      const encoder = new TextEncoder();
-      for (const event of events) {
-        controller.enqueue(encoder.encode(event));
-      }
-      controller.close();
-    }
-  });
-}
-
-describe('SSE Parser', () => {
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
-  });
-
-  describe('parseSSEStream', () => {
-    it('should parse valid SSE events', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"start","command":"echo test"}\n\n',
-        'data: {"type":"stdout","data":"test\\n"}\n\n',
-        'data: {"type":"complete","exitCode":0}\n\n'
-      ]);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(3);
-      expect(events[0]).toEqual({ type: 'start', command: 'echo test' });
-      expect(events[1]).toEqual({ type: 'stdout', data: 'test\n' });
-      expect(events[2]).toEqual({ type: 'complete', exitCode: 0 });
-    });
-
-    it('should handle empty data lines', async () => {
-      const stream = createMockSSEStream([
-        'data: \n\n',
-        'data: {"type":"stdout","data":"valid"}\n\n'
-      ]);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: 'stdout', data: 'valid' });
-    });
-
-    it('should skip [DONE] markers', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"start"}\n\n',
-        'data: [DONE]\n\n',
-        'data: {"type":"complete"}\n\n'
-      ]);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(2);
-      expect(events[0]).toEqual({ type: 'start' });
-      expect(events[1]).toEqual({ type: 'complete' });
-    });
-
-    it('should handle malformed JSON gracefully', async () => {
-      const stream = createMockSSEStream([
-        'data: invalid json\n\n',
-        'data: {"type":"stdout","data":"valid"}\n\n',
-        'data: {incomplete\n\n'
-      ]);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: 'stdout', data: 'valid' });
-    });
-
-    it('should handle empty lines and comments', async () => {
-      const stream = createMockSSEStream([
-        '\n',
-        '   \n',
-        ': this is a comment\n',
-        'data: {"type":"test"}\n\n',
-        '\n'
-      ]);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: 'test' });
-    });
-
-    it('should handle chunked data properly', async () => {
-      // Simulate chunked delivery where data arrives in parts
-      const stream = new ReadableStream({
-        start(controller) {
-          const encoder = new TextEncoder();
-          // Send partial data
-          controller.enqueue(encoder.encode('data: {"typ'));
-          controller.enqueue(encoder.encode('e":"start"}\n\n'));
-          controller.enqueue(encoder.encode('data: {"type":"end"}\n\n'));
-          controller.close();
-        }
-      });
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(2);
-      expect(events[0]).toEqual({ type: 'start' });
-      expect(events[1]).toEqual({ type: 'end' });
-    });
-
-    it('should handle remaining buffer data after stream ends', async () => {
-      const stream = createMockSSEStream(['data: {"type":"complete"}']);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: 'complete' });
-    });
-
-    it('should support cancellation via AbortSignal', async () => {
-      const controller = new AbortController();
-      const stream = createMockSSEStream(['data: {"type":"start"}\n\n']);
-      controller.abort();
-
-      await expect(async () => {
-        for await (const event of parseSSEStream(stream, controller.signal)) {
-        }
-      }).rejects.toThrow('Operation was aborted');
-    });
-
-    it('should handle non-data SSE lines', async () => {
-      const stream = createMockSSEStream([
-        'event: message\n',
-        'id: 123\n',
-        'retry: 3000\n',
-        'data: {"type":"test"}\n\n'
-      ]);
-
-      const events: any[] = [];
-      for await (const event of parseSSEStream(stream)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: 'test' });
-    });
-  });
-
-  describe('responseToAsyncIterable', () => {
-    it('should convert Response with SSE stream to AsyncIterable', async () => {
-      const mockBody = createMockSSEStream([
-        'data: {"type":"start"}\n\n',
-        'data: {"type":"end"}\n\n'
-      ]);
-
-      const mockResponse = {
-        ok: true,
-        body: mockBody
-      } as Response;
-
-      const events: any[] = [];
-      for await (const event of responseToAsyncIterable(mockResponse)) {
-        events.push(event);
-      }
-
-      expect(events).toHaveLength(2);
-      expect(events[0]).toEqual({ type: 'start' });
-      expect(events[1]).toEqual({ type: 'end' });
-    });
-
-    it('should throw error for non-ok response', async () => {
-      const mockResponse = {
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error'
-      } as Response;
-
-      await expect(async () => {
-        for await (const event of responseToAsyncIterable(mockResponse)) {
-          // Should not reach here
-        }
-      }).rejects.toThrow('Response not ok: 500 Internal Server Error');
-    });
-
-    it('should throw error for response without body', async () => {
-      const mockResponse = {
-        ok: true,
-        body: null
-      } as Response;
-
-      await expect(async () => {
-        for await (const event of responseToAsyncIterable(mockResponse)) {
-          // Should not reach here
-        }
-      }).rejects.toThrow('No response body');
-    });
-  });
-
-  describe('asyncIterableToSSEStream', () => {
-    it('should convert AsyncIterable to SSE-formatted ReadableStream', async () => {
-      async function* mockEvents() {
-        yield { type: 'start', command: 'test' };
-        yield { type: 'stdout', data: 'output' };
-        yield { type: 'complete', exitCode: 0 };
-      }
-
-      const stream = asyncIterableToSSEStream(mockEvents());
-      const reader = stream.getReader();
-      const decoder = new TextDecoder();
-
-      const chunks: string[] = [];
-      let done = false;
-
-      while (!done) {
-        const { value, done: readerDone } = await reader.read();
-        done = readerDone;
-        if (value) {
-          chunks.push(decoder.decode(value));
-        }
-      }
-
-      const fullOutput = chunks.join('');
-      expect(fullOutput).toBe(
-        'data: {"type":"start","command":"test"}\n\n' +
-          'data: {"type":"stdout","data":"output"}\n\n' +
-          'data: {"type":"complete","exitCode":0}\n\n' +
-          'data: [DONE]\n\n'
-      );
-    });
-
-    it('should use custom serializer when provided', async () => {
-      async function* mockEvents() {
-        yield { name: 'test', value: 123 };
-      }
-
-      const stream = asyncIterableToSSEStream(mockEvents(), {
-        serialize: (event) => `custom:${event.name}=${event.value}`
-      });
-
-      const reader = stream.getReader();
-      const decoder = new TextDecoder();
-      const { value } = await reader.read();
-
-      expect(decoder.decode(value!)).toBe('data: custom:test=123\n\n');
-    });
-
-    it('should handle errors in async iterable', async () => {
-      async function* mockEvents() {
-        yield { type: 'start' };
-        throw new Error('Async iterable error');
-      }
-
-      const stream = asyncIterableToSSEStream(mockEvents());
-      const reader = stream.getReader();
-
-      await reader.read();
-      await expect(reader.read()).rejects.toThrow('Async iterable error');
-    });
-  });
-});

package/tests/storage-mount/credential-detection.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { detectCredentials } from '../../src/storage-mount/credential-detection';
-
-describe('Credential Detection', () => {
-  it('should use explicit credentials from options', () => {
-    const envVars = {};
-    const options = {
-      endpoint: 'https://test.r2.cloudflarestorage.com',
-      credentials: {
-        accessKeyId: 'explicit-key',
-        secretAccessKey: 'explicit-secret'
-      }
-    };
-
-    const credentials = detectCredentials(options, envVars);
-
-    expect(credentials.accessKeyId).toBe('explicit-key');
-    expect(credentials.secretAccessKey).toBe('explicit-secret');
-  });
-
-  it('should detect standard AWS env vars', () => {
-    const envVars = {
-      AWS_ACCESS_KEY_ID: 'aws-key',
-      AWS_SECRET_ACCESS_KEY: 'aws-secret'
-    };
-    const options = { endpoint: 'https://s3.us-west-2.amazonaws.com' };
-
-    const credentials = detectCredentials(options, envVars);
-
-    expect(credentials.accessKeyId).toBe('aws-key');
-    expect(credentials.secretAccessKey).toBe('aws-secret');
-  });
-
-  it('should ignore session token in environment', () => {
-    const envVars = {
-      AWS_ACCESS_KEY_ID: 'aws-key',
-      AWS_SECRET_ACCESS_KEY: 'aws-secret',
-      AWS_SESSION_TOKEN: 'session-token'
-    };
-    const options = { endpoint: 'https://s3.us-west-2.amazonaws.com' };
-
-    const credentials = detectCredentials(options, envVars);
-
-    expect(credentials.accessKeyId).toBe('aws-key');
-    expect(credentials.secretAccessKey).toBe('aws-secret');
-  });
-
-  it('should prioritize explicit credentials over env vars', () => {
-    const envVars = {
-      AWS_ACCESS_KEY_ID: 'env-key',
-      AWS_SECRET_ACCESS_KEY: 'env-secret'
-    };
-    const options = {
-      endpoint: 'https://test.r2.cloudflarestorage.com',
-      credentials: {
-        accessKeyId: 'explicit-key',
-        secretAccessKey: 'explicit-secret'
-      }
-    };
-
-    const credentials = detectCredentials(options, envVars);
-
-    expect(credentials.accessKeyId).toBe('explicit-key');
-    expect(credentials.secretAccessKey).toBe('explicit-secret');
-  });
-
-  it('should throw error when no credentials found', () => {
-    const envVars = {};
-    const options = { endpoint: 'https://test.r2.cloudflarestorage.com' };
-
-    expect(() => detectCredentials(options, envVars)).toThrow(
-      'No credentials found'
-    );
-  });
-
-  it('should include helpful error message with env var hints', () => {
-    const envVars = {};
-    const options = { endpoint: 'https://test.r2.cloudflarestorage.com' };
-
-    let thrownError: Error | null = null;
-    try {
-      detectCredentials(options, envVars);
-    } catch (error) {
-      thrownError = error as Error;
-    }
-
-    expect(thrownError).toBeTruthy();
-    if (thrownError) {
-      const message = thrownError.message;
-      expect(message).toContain('AWS_ACCESS_KEY_ID');
-      expect(message).toContain('AWS_SECRET_ACCESS_KEY');
-      expect(message).toContain('explicit credentials');
-    }
-  });
-
-  it('should throw error when only access key is present', () => {
-    const envVars = {
-      AWS_ACCESS_KEY_ID: 'aws-key'
-      // Missing AWS_SECRET_ACCESS_KEY
-    };
-    const options = { endpoint: 'https://test.r2.cloudflarestorage.com' };
-
-    expect(() => detectCredentials(options, envVars)).toThrow(
-      'No credentials found'
-    );
-  });
-
-  it('should throw error when only secret key is present', () => {
-    const envVars = {
-      AWS_SECRET_ACCESS_KEY: 'aws-secret'
-      // Missing AWS_ACCESS_KEY_ID
-    };
-    const options = { endpoint: 'https://test.r2.cloudflarestorage.com' };
-
-    expect(() => detectCredentials(options, envVars)).toThrow(
-      'No credentials found'
-    );
-  });
-});

package/tests/storage-mount/provider-detection.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  detectProviderFromUrl,
-  getProviderFlags,
-  resolveS3fsOptions
-} from '../../src/storage-mount/provider-detection';
-
-describe('Provider Detection', () => {
-  describe('detectProviderFromUrl', () => {
-    it.each([
-      ['https://abc123.r2.cloudflarestorage.com', 'r2'],
-      ['https://s3.us-west-2.amazonaws.com', 's3'],
-      ['https://storage.googleapis.com', 'gcs']
-    ])('should detect %s as %s', (url, expectedProvider) => {
-      expect(detectProviderFromUrl(url)).toBe(expectedProvider);
-    });
-
-    it.each([['https://custom.storage.example.com'], ['not-a-url'], ['']])(
-      'should return null for unknown/invalid: %s',
-      (url) => {
-        expect(detectProviderFromUrl(url)).toBe(null);
-      }
-    );
-  });
-
-  describe('getProviderFlags', () => {
-    it.each([
-      ['r2', ['nomixupload']],
-      ['s3', []],
-      ['gcs', []]
-    ])('should return correct flags for %s', (provider, expected) => {
-      expect(getProviderFlags(provider as any)).toEqual(expected);
-    });
-
-    it('should return safe defaults for unknown providers', () => {
-      expect(getProviderFlags(null)).toEqual(['use_path_request_style']);
-    });
-  });
-
-  describe('resolveS3fsOptions', () => {
-    it('should use provider defaults when no user options', () => {
-      const options = resolveS3fsOptions('r2');
-      expect(options).toEqual(['nomixupload']);
-    });
-
-    it('should merge provider flags with user options', () => {
-      const options = resolveS3fsOptions('r2', ['custom_flag']);
-      expect(options).toContain('nomixupload');
-      expect(options).toContain('custom_flag');
-    });
-
-    it('should allow user options to override provider defaults', () => {
-      const options = resolveS3fsOptions('r2', ['endpoint=us-east']);
-      expect(options).toContain('nomixupload');
-      expect(options).toContain('endpoint=us-east');
-      expect(options).not.toContain('endpoint=auto');
-    });
-
-    it('should deduplicate flags keeping last occurrence', () => {
-      const options = resolveS3fsOptions(null, [
-        'use_path_request_style',
-        'custom_flag'
-      ]);
-      const count = options.filter(
-        (o) => o === 'use_path_request_style'
-      ).length;
-      expect(count).toBe(1);
-      expect(options).toContain('custom_flag');
-    });
-
-    it('should use safe defaults for unknown providers', () => {
-      const options = resolveS3fsOptions(null, ['nomixupload']);
-      expect(options).toContain('use_path_request_style');
-      expect(options).toContain('nomixupload');
-    });
-  });
-});