@positronic/cloudflare 0.0.2

package/test-project/tests/resources-api.test.ts

@@ -0,0 +1,671 @@
+import {
+  env,
+  createExecutionContext,
+  waitOnExecutionContext,
+} from 'cloudflare:test';
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import worker from '../src/index';
+
+interface TestEnv {
+  RESOURCES_BUCKET: R2Bucket;
+  NODE_ENV?: string;
+}
+
+describe('Resources API Tests', () => {
+  const testEnv = env as TestEnv;
+
+  beforeAll(async () => {
+    // Clean up any existing test resources
+    try {
+      const listed = await testEnv.RESOURCES_BUCKET.list();
+      for (const obj of listed.objects) {
+        await testEnv.RESOURCES_BUCKET.delete(obj.key);
+      }
+    } catch (e) {
+      // Ignore errors if bucket is empty
+    }
+  });
+
+  afterAll(async () => {
+    // Clean up after all tests
+    try {
+      const listed = await testEnv.RESOURCES_BUCKET.list();
+      for (const obj of listed.objects) {
+        await testEnv.RESOURCES_BUCKET.delete(obj.key);
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+  });
+
+  it('POST /resources with path only', async () => {
+    const formData = new FormData();
+    formData.append(
+      'file',
+      new Blob(['Hello from test file'], { type: 'text/plain' }),
+      'test.txt'
+    );
+    formData.append('type', 'text');
+    formData.append('path', 'resources/test-files/test.txt');
+    formData.append('local', 'false');
+
+    const request = new Request('http://example.com/resources', {
+      method: 'POST',
+      body: formData,
+    });
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    await waitOnExecutionContext(context);
+
+    expect(response.status).toBe(201);
+    const responseBody = await response.json<{
+      type: string;
+      path: string;
+      key: string;
+      size: number;
+      lastModified: string;
+      local: boolean;
+    }>();
+    expect(responseBody).toEqual({
+      type: 'text',
+      path: 'resources/test-files/test.txt',
+      key: 'resources/test-files/test.txt',
+      size: expect.any(Number),
+      lastModified: expect.any(String),
+      local: false,
+    });
+
+    // Verify the resource was actually stored in R2
+    const storedObject = await testEnv.RESOURCES_BUCKET.get(
+      'resources/test-files/test.txt'
+    );
+    expect(storedObject).not.toBeNull();
+    const storedText = await storedObject!.text();
+    expect(storedText).toBe('Hello from test file');
+    expect(storedObject!.customMetadata).toEqual({
+      type: 'text',
+      path: 'resources/test-files/test.txt',
+      local: 'false',
+    });
+  });
+
+  it('POST /resources with key only (no path)', async () => {
+    const formData = new FormData();
+    const videoContent = new Uint8Array([
+      0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70,
+    ]); // Mock video header
+    formData.append(
+      'file',
+      new Blob([videoContent], { type: 'video/mp4' }),
+      'video.mp4'
+    );
+    formData.append('type', 'binary');
+    formData.append('key', 'videos/large-video.mp4');
+    formData.append('local', 'false');
+
+    const request = new Request('http://example.com/resources', {
+      method: 'POST',
+      body: formData,
+    });
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    await waitOnExecutionContext(context);
+
+    expect(response.status).toBe(201);
+    const responseBody = await response.json<{
+      type: string;
+      path?: string;
+      key: string;
+      size: number;
+      lastModified: string;
+      local: boolean;
+    }>();
+    expect(responseBody).toEqual({
+      type: 'binary',
+      key: 'videos/large-video.mp4',
+      size: expect.any(Number),
+      lastModified: expect.any(String),
+      local: false,
+    });
+    // Should not have path since we didn't provide one
+    expect(responseBody.path).toBeUndefined();
+
+    // Verify the resource was stored without path metadata
+    const storedObject = await testEnv.RESOURCES_BUCKET.get(
+      'videos/large-video.mp4'
+    );
+    expect(storedObject).not.toBeNull();
+    // IMPORTANT: Consume the response body to avoid isolated storage issues
+    await storedObject!.arrayBuffer();
+    expect(storedObject!.customMetadata).toEqual({
+      type: 'binary',
+      local: 'false',
+    });
+  });
+
+  it('POST /resources with both key and path (key takes precedence)', async () => {
+    const formData = new FormData();
+    formData.append(
+      'file',
+      new Blob(['Image data'], { type: 'image/png' }),
+      'logo.png'
+    );
+    formData.append('type', 'binary');
+    formData.append('path', 'resources/images/logo.png');
+    formData.append('key', 'assets/branding/logo.png');
+    formData.append('local', 'true'); // Testing with local=true
+
+    const request = new Request('http://example.com/resources', {
+      method: 'POST',
+      body: formData,
+    });
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    await waitOnExecutionContext(context);
+
+    expect(response.status).toBe(201);
+    const responseBody = await response.json<{
+      type: string;
+      path: string;
+      key: string;
+      size: number;
+      lastModified: string;
+      local: boolean;
+    }>();
+    expect(responseBody).toEqual({
+      type: 'binary',
+      path: 'resources/images/logo.png',
+      key: 'assets/branding/logo.png',
+      size: expect.any(Number),
+      lastModified: expect.any(String),
+      local: true,
+    });
+
+    // Verify stored at key location, not path location
+    const storedAtKey = await testEnv.RESOURCES_BUCKET.get(
+      'assets/branding/logo.png'
+    );
+    expect(storedAtKey).not.toBeNull();
+    // IMPORTANT: Consume the response body
+    await storedAtKey!.arrayBuffer();
+
+    const storedAtPath = await testEnv.RESOURCES_BUCKET.get(
+      'resources/images/logo.png'
+    );
+    expect(storedAtPath).toBeNull();
+  });
+
+  it('GET /resources lists all resources correctly', async () => {
+    // First create a resource to list
+    const formData = new FormData();
+    formData.append(
+      'file',
+      new Blob(['Test content'], { type: 'text/plain' }),
+      'test.txt'
+    );
+    formData.append('type', 'text');
+    formData.append('path', 'resources/list-test.txt');
+    formData.append('local', 'true');
+
+    const createRequest = new Request('http://example.com/resources', {
+      method: 'POST',
+      body: formData,
+    });
+    const createContext = createExecutionContext();
+    await worker.fetch(createRequest, testEnv, createContext);
+    await waitOnExecutionContext(createContext);
+
+    // Now list resources
+    const request = new Request('http://example.com/resources');
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    await waitOnExecutionContext(context);
+
+    expect(response.status).toBe(200);
+    const responseBody = await response.json<{
+      resources: Array<{
+        type: string;
+        path?: string;
+        key: string;
+        size: number;
+        lastModified: string;
+        local: boolean;
+      }>;
+      truncated: boolean;
+      count: number;
+    }>();
+    expect(responseBody.truncated).toBe(false);
+    // Should have 1 resource (the one we just created)
+    expect(responseBody.count).toBe(1);
+    expect(responseBody.resources).toHaveLength(1);
+
+    // Check that the resource has the correct structure
+    const resource = responseBody.resources[0];
+    expect(resource).toEqual({
+      type: 'text',
+      path: 'resources/list-test.txt',
+      key: 'resources/list-test.txt',
+      size: expect.any(Number),
+      lastModified: expect.any(String),
+      local: true,
+    });
+  });
+
+  describe('Error cases', () => {
+    it('POST /resources without file should return 400 error', async () => {
+      const formData = new FormData();
+      formData.append('type', 'text');
+      formData.append('path', 'resources/test.txt');
+
+      const request = new Request('http://example.com/resources', {
+        method: 'POST',
+        body: formData,
+      });
+      const context = createExecutionContext();
+
+      const response = await worker.fetch(request, testEnv, context);
+      expect(response.status).toBe(400);
+
+      await waitOnExecutionContext(context);
+    });
+
+    it('POST /resources without type should return 400 error', async () => {
+      const formData = new FormData();
+      formData.append('file', new Blob(['content']), 'test.txt');
+      formData.append('path', 'resources/test.txt');
+
+      const request = new Request('http://example.com/resources', {
+        method: 'POST',
+        body: formData,
+      });
+      const context = createExecutionContext();
+
+      const response = await worker.fetch(request, testEnv, context);
+      expect(response.status).toBe(400);
+
+      await waitOnExecutionContext(context);
+    });
+
+    it('POST /resources with invalid type should return 400 error', async () => {
+      const formData = new FormData();
+      formData.append('file', new Blob(['content']), 'test.txt');
+      formData.append('type', 'invalid');
+      formData.append('path', 'resources/test.txt');
+
+      const request = new Request('http://example.com/resources', {
+        method: 'POST',
+        body: formData,
+      });
+      const context = createExecutionContext();
+
+      const response = await worker.fetch(request, testEnv, context);
+      expect(response.status).toBe(400);
+
+      await waitOnExecutionContext(context);
+    });
+
+    it('POST /resources without key or path should return 400 error', async () => {
+      const formData = new FormData();
+      formData.append('file', new Blob(['content']), 'test.txt');
+      formData.append('type', 'text');
+
+      const request = new Request('http://example.com/resources', {
+        method: 'POST',
+        body: formData,
+      });
+      const context = createExecutionContext();
+
+      const response = await worker.fetch(request, testEnv, context);
+      expect(response.status).toBe(400);
+
+      await waitOnExecutionContext(context);
+    });
+
+    it('GET /resources with missing type metadata should return 500 error', async () => {
+      // Manually create a resource without type metadata
+      await testEnv.RESOURCES_BUCKET.put('bad-resource.txt', 'content', {
+        customMetadata: {
+          path: 'bad-resource.txt',
+          // Missing type
+        },
+      });
+
+      const request = new Request('http://example.com/resources');
+      const context = createExecutionContext();
+
+      const response = await worker.fetch(request, testEnv, context);
+      expect(response.status).toBe(500);
+
+      await waitOnExecutionContext(context);
+
+      // Clean up
+      await testEnv.RESOURCES_BUCKET.delete('bad-resource.txt');
+    });
+  });
+
+  describe('DELETE /resources/:key', () => {
+    it('should delete an existing resource', async () => {
+      // First create a resource
+      const formData = new FormData();
+      formData.append(
+        'file',
+        new Blob(['Content to delete'], { type: 'text/plain' }),
+        'delete-test.txt'
+      );
+      formData.append('type', 'text');
+      formData.append('key', 'resources/delete-test.txt');
+
+      const createRequest = new Request('http://example.com/resources', {
+        method: 'POST',
+        body: formData,
+      });
+      const createContext = createExecutionContext();
+      const createResponse = await worker.fetch(
+        createRequest,
+        testEnv,
+        createContext
+      );
+      await waitOnExecutionContext(createContext);
+      expect(createResponse.status).toBe(201);
+
+      // Now delete it
+      const deleteRequest = new Request(
+        'http://example.com/resources/' +
+          encodeURIComponent('resources/delete-test.txt'),
+        { method: 'DELETE' }
+      );
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        testEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      expect(deleteResponse.status).toBe(204);
+
+      // Verify it's deleted
+      const deletedObject = await testEnv.RESOURCES_BUCKET.get(
+        'resources/delete-test.txt'
+      );
+      expect(deletedObject).toBeNull();
+    });
+
+    it('should handle URL encoded keys with slashes', async () => {
+      // Create a resource with a path containing subdirectories
+      const formData = new FormData();
+      formData.append(
+        'file',
+        new Blob(['Nested content'], { type: 'text/plain' }),
+        'nested.txt'
+      );
+      formData.append('type', 'text');
+      formData.append('key', 'resources/subfolder/nested.txt');
+
+      const createRequest = new Request('http://example.com/resources', {
+        method: 'POST',
+        body: formData,
+      });
+      const createContext = createExecutionContext();
+      await worker.fetch(createRequest, testEnv, createContext);
+      await waitOnExecutionContext(createContext);
+
+      // Delete with URL encoded key
+      const deleteRequest = new Request(
+        'http://example.com/resources/' +
+          encodeURIComponent('resources/subfolder/nested.txt'),
+        { method: 'DELETE' }
+      );
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        testEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      expect(deleteResponse.status).toBe(204);
+
+      // Verify it's deleted
+      const deletedObject = await testEnv.RESOURCES_BUCKET.get(
+        'resources/subfolder/nested.txt'
+      );
+      expect(deletedObject).toBeNull();
+    });
+
+    it('should return 204 even for non-existent resources (idempotent delete)', async () => {
+      const deleteRequest = new Request(
+        'http://example.com/resources/' +
+          encodeURIComponent('non-existent.txt'),
+        { method: 'DELETE' }
+      );
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        testEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      // Should return 204 No Content even if resource doesn't exist (idempotent)
+      expect(deleteResponse.status).toBe(204);
+    });
+  });
+
+  describe('DELETE /resources (bulk delete)', () => {
+    beforeEach(async () => {
+      // Create some test resources
+      const resources = ['file1.txt', 'file2.txt', 'subfolder/file3.txt'];
+
+      for (const resource of resources) {
+        const formData = new FormData();
+        formData.append(
+          'file',
+          new Blob([`Content of ${resource}`], { type: 'text/plain' }),
+          resource
+        );
+        formData.append('type', 'text');
+        formData.append('key', `resources/${resource}`);
+
+        const request = new Request('http://example.com/resources', {
+          method: 'POST',
+          body: formData,
+        });
+        const context = createExecutionContext();
+        await worker.fetch(request, testEnv, context);
+        await waitOnExecutionContext(context);
+      }
+    });
+
+    it('should delete all resources when in development mode', async () => {
+      // Explicitly set environment to development mode
+      const devEnv = {
+        ...testEnv,
+        NODE_ENV: 'development',
+      };
+
+      const deleteRequest = new Request('http://example.com/resources', {
+        method: 'DELETE',
+      });
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        devEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      expect(deleteResponse.status).toBe(200);
+      const responseBody = await deleteResponse.json<{
+        deletedCount: number;
+      }>();
+      expect(responseBody.deletedCount).toBeGreaterThanOrEqual(3);
+
+      // Verify all resources are deleted
+      const listed = await testEnv.RESOURCES_BUCKET.list();
+      expect(listed.objects.length).toBe(0);
+    });
+
+    it('should return 403 when not in development mode', async () => {
+      // Create an environment without NODE_ENV
+      const envWithoutNodeEnv = {
+        RESOURCES_BUCKET: testEnv.RESOURCES_BUCKET,
+        // Explicitly omit NODE_ENV
+      };
+
+      const deleteRequest = new Request('http://example.com/resources', {
+        method: 'DELETE',
+      });
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        envWithoutNodeEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      expect(deleteResponse.status).toBe(403);
+      const errorBody = await deleteResponse.json<{ error: string }>();
+      expect(errorBody.error).toBe(
+        'Bulk delete is only available in development mode'
+      );
+
+      // Verify resources are not deleted
+      const listed = await testEnv.RESOURCES_BUCKET.list();
+      expect(listed.objects.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('should return 403 when NODE_ENV is production', async () => {
+      const prodEnv = {
+        ...testEnv,
+        NODE_ENV: 'production',
+      };
+
+      const deleteRequest = new Request('http://example.com/resources', {
+        method: 'DELETE',
+      });
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        prodEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      expect(deleteResponse.status).toBe(403);
+      const errorBody = await deleteResponse.json<{ error: string }>();
+      expect(errorBody.error).toBe(
+        'Bulk delete is only available in development mode'
+      );
+    });
+  });
+
+  describe('POST /resources/presigned-link', () => {
+    it('should return 400 when R2 credentials are not configured', async () => {
+      // This test verifies behavior when the backend doesn't have credentials configured
+      const request = new Request(
+        'http://example.com/resources/presigned-link',
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            key: 'test-files/large-video.mp4',
+            type: 'binary',
+            size: 150 * 1024 * 1024, // 150MB
+          }),
+        }
+      );
+      const context = createExecutionContext();
+      const response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+
+      expect(response.status).toBe(400);
+      const responseBody = await response.json<{ error: string }>();
+      expect(responseBody.error).toBeDefined();
+      expect(typeof responseBody.error).toBe('string');
+    });
+
+    it('should validate required fields in request body', async () => {
+      // Missing key
+      let request = new Request('http://example.com/resources/presigned-link', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          type: 'binary',
+          size: 1024,
+        }),
+      });
+      let context = createExecutionContext();
+      let response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+      expect(response.status).toBe(400);
+
+      // Missing type
+      request = new Request('http://example.com/resources/presigned-link', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          key: 'test.txt',
+          size: 1024,
+        }),
+      });
+      context = createExecutionContext();
+      response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+      expect(response.status).toBe(400);
+
+      // Missing size
+      request = new Request('http://example.com/resources/presigned-link', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          key: 'test.txt',
+          type: 'text',
+        }),
+      });
+      context = createExecutionContext();
+      response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+      expect(response.status).toBe(400);
+    });
+
+    it('should validate type field is text or binary', async () => {
+      const request = new Request(
+        'http://example.com/resources/presigned-link',
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            key: 'test.txt',
+            type: 'invalid',
+            size: 1024,
+          }),
+        }
+      );
+      const context = createExecutionContext();
+      const response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+
+      expect(response.status).toBe(400);
+      const responseBody = await response.json<{ error: string }>();
+      expect(responseBody.error).toContain(
+        'type must be either "text" or "binary"'
+      );
+    });
+
+    // Note: We intentionally do not test successful presigned URL generation
+    // as it would require real cloud storage credentials and internet connectivity.
+    // The spec test validates the API contract when credentials are configured.
+  });
+});