@uploadista/server 0.0.13-beta.4 → 0.0.13

package/tests/core/http-handlers/upload-handlers.test.ts

@@ -0,0 +1,657 @@
+/**
+ * Tests for HTTP Upload Handlers
+ *
+ * Covers:
+ * - Chunked upload processing
+ * - Multipart upload handling
+ * - Upload progress tracking
+ * - HTTP request/response handling
+ * - Error handling and status codes
+ * - Upload metadata validation
+ */
+
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { describe, expect } from "vitest";
+
+describe("HTTP Upload Handlers", () => {
+  describe("Chunked Upload Processing", () => {
+    it.effect("should process single chunk upload", () =>
+      Effect.gen(function* () {
+        // Mock upload service
+        const mockUploadService = {
+          processChunk: (
+            uploadId: string,
+            chunkData: Uint8Array,
+            chunkIndex: number,
+          ) =>
+            Effect.succeed({
+              uploadId,
+              chunkIndex,
+              bytesReceived: chunkData.length,
+              status: "in-progress" as const,
+            }),
+        };
+
+        const chunkData = new Uint8Array([1, 2, 3, 4, 5]);
+        const result = yield* mockUploadService.processChunk(
+          "upload-123",
+          chunkData,
+          0,
+        );
+
+        expect(result.uploadId).toBe("upload-123");
+        expect(result.chunkIndex).toBe(0);
+        expect(result.bytesReceived).toBe(5);
+        expect(result.status).toBe("in-progress");
+      }),
+    );
+
+    it.effect("should process multiple chunks in sequence", () =>
+      Effect.gen(function* () {
+        const chunks: Array<{ index: number; size: number }> = [];
+
+        const mockUploadService = {
+          processChunk: (
+            uploadId: string,
+            chunkData: Uint8Array,
+            chunkIndex: number,
+          ) =>
+            Effect.sync(() => {
+              chunks.push({ index: chunkIndex, size: chunkData.length });
+              return {
+                uploadId,
+                chunkIndex,
+                bytesReceived: chunkData.length,
+                status:
+                  chunkIndex === 2
+                    ? ("completed" as const)
+                    : ("in-progress" as const),
+              };
+            }),
+        };
+
+        // Process 3 chunks
+        yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(1024),
+          0,
+        );
+        yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(1024),
+          1,
+        );
+        const finalResult = yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(512),
+          2,
+        );
+
+        expect(chunks).toHaveLength(3);
+        expect(chunks[0]?.index).toBe(0);
+        expect(chunks[1]?.index).toBe(1);
+        expect(chunks[2]?.index).toBe(2);
+        expect(finalResult.status).toBe("completed");
+      }),
+    );
+
+    it.effect("should handle chunk upload errors", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          processChunk: (
+            uploadId: string,
+            chunkData: Uint8Array,
+            chunkIndex: number,
+          ) =>
+            Effect.gen(function* () {
+              if (chunkIndex === 1) {
+                return yield* Effect.fail(new Error("Chunk processing failed"));
+              }
+              return {
+                uploadId,
+                chunkIndex,
+                bytesReceived: chunkData.length,
+                status: "in-progress" as const,
+              };
+            }),
+        };
+
+        // First chunk succeeds
+        const result1 = yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(1024),
+          0,
+        );
+        expect(result1.status).toBe("in-progress");
+
+        // Second chunk fails
+        const result2 = yield* Effect.either(
+          mockUploadService.processChunk("upload-123", new Uint8Array(1024), 1),
+        );
+        expect(result2._tag).toBe("Left");
+      }),
+    );
+
+    it.effect("should validate chunk size limits", () =>
+      Effect.gen(function* () {
+        const MAX_CHUNK_SIZE = 5 * 1024 * 1024; // 5MB
+
+        const mockUploadService = {
+          processChunk: (
+            uploadId: string,
+            chunkData: Uint8Array,
+            chunkIndex: number,
+          ) =>
+            Effect.gen(function* () {
+              if (chunkData.length > MAX_CHUNK_SIZE) {
+                return yield* Effect.fail(
+                  new Error("Chunk size exceeds maximum"),
+                );
+              }
+              return {
+                uploadId,
+                chunkIndex,
+                bytesReceived: chunkData.length,
+                status: "in-progress" as const,
+              };
+            }),
+        };
+
+        // Valid chunk size
+        const result1 = yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(1024 * 1024),
+          0,
+        );
+        expect(result1.status).toBe("in-progress");
+
+        // Oversized chunk
+        const result2 = yield* Effect.either(
+          mockUploadService.processChunk(
+            "upload-123",
+            new Uint8Array(6 * 1024 * 1024),
+            1,
+          ),
+        );
+        expect(result2._tag).toBe("Left");
+      }),
+    );
+
+    it.effect("should track total bytes received across chunks", () =>
+      Effect.gen(function* () {
+        let totalBytesReceived = 0;
+
+        const mockUploadService = {
+          processChunk: (
+            uploadId: string,
+            chunkData: Uint8Array,
+            chunkIndex: number,
+          ) =>
+            Effect.sync(() => {
+              totalBytesReceived += chunkData.length;
+              return {
+                uploadId,
+                chunkIndex,
+                bytesReceived: chunkData.length,
+                totalBytesReceived,
+                status: "in-progress" as const,
+              };
+            }),
+        };
+
+        yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(1024),
+          0,
+        );
+        yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(2048),
+          1,
+        );
+        yield* mockUploadService.processChunk(
+          "upload-123",
+          new Uint8Array(512),
+          2,
+        );
+
+        expect(totalBytesReceived).toBe(3584); // 1024 + 2048 + 512
+      }),
+    );
+  });
+
+  describe("Multipart Upload Handling", () => {
+    it.effect("should initiate multipart upload", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          initiateMultipartUpload: (
+            fileName: string,
+            fileSize: number,
+            contentType: string,
+          ) =>
+            Effect.succeed({
+              uploadId: "multipart-123",
+              fileName,
+              fileSize,
+              contentType,
+              status: "initiated" as const,
+              parts: [] as Array<{ partNumber: number; etag: string }>,
+            }),
+        };
+
+        const result = yield* mockUploadService.initiateMultipartUpload(
+          "large-file.bin",
+          100 * 1024 * 1024, // 100MB
+          "application/octet-stream",
+        );
+
+        expect(result.uploadId).toBe("multipart-123");
+        expect(result.fileName).toBe("large-file.bin");
+        expect(result.fileSize).toBe(100 * 1024 * 1024);
+        expect(result.status).toBe("initiated");
+      }),
+    );
+
+    it.effect("should upload multipart parts", () =>
+      Effect.gen(function* () {
+        const uploadedParts: Array<{ partNumber: number; size: number }> = [];
+
+        const mockUploadService = {
+          uploadPart: (
+            uploadId: string,
+            partNumber: number,
+            data: Uint8Array,
+          ) =>
+            Effect.sync(() => {
+              uploadedParts.push({ partNumber, size: data.length });
+              return {
+                uploadId,
+                partNumber,
+                etag: `etag-${partNumber}`,
+                size: data.length,
+              };
+            }),
+        };
+
+        // Upload 3 parts
+        yield* mockUploadService.uploadPart(
+          "multipart-123",
+          1,
+          new Uint8Array(5 * 1024 * 1024),
+        );
+        yield* mockUploadService.uploadPart(
+          "multipart-123",
+          2,
+          new Uint8Array(5 * 1024 * 1024),
+        );
+        yield* mockUploadService.uploadPart(
+          "multipart-123",
+          3,
+          new Uint8Array(2 * 1024 * 1024),
+        );
+
+        expect(uploadedParts).toHaveLength(3);
+        expect(uploadedParts[0]?.partNumber).toBe(1);
+        expect(uploadedParts[1]?.partNumber).toBe(2);
+        expect(uploadedParts[2]?.partNumber).toBe(3);
+      }),
+    );
+
+    it.effect("should complete multipart upload", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          completeMultipartUpload: (
+            uploadId: string,
+            parts: Array<{ partNumber: number; etag: string }>,
+          ) =>
+            Effect.succeed({
+              uploadId,
+              status: "completed" as const,
+              totalParts: parts.length,
+              location: `https://storage.example.com/files/${uploadId}`,
+            }),
+        };
+
+        const parts = [
+          { partNumber: 1, etag: "etag-1" },
+          { partNumber: 2, etag: "etag-2" },
+          { partNumber: 3, etag: "etag-3" },
+        ];
+
+        const result = yield* mockUploadService.completeMultipartUpload(
+          "multipart-123",
+          parts,
+        );
+
+        expect(result.uploadId).toBe("multipart-123");
+        expect(result.status).toBe("completed");
+        expect(result.totalParts).toBe(3);
+        expect(result.location).toContain("multipart-123");
+      }),
+    );
+
+    it.effect("should abort multipart upload", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          abortMultipartUpload: (uploadId: string, reason: string) =>
+            Effect.succeed({
+              uploadId,
+              status: "aborted" as const,
+              reason,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockUploadService.abortMultipartUpload(
+          "multipart-123",
+          "User cancelled upload",
+        );
+
+        expect(result.uploadId).toBe("multipart-123");
+        expect(result.status).toBe("aborted");
+        expect(result.reason).toBe("User cancelled upload");
+      }),
+    );
+
+    it.effect("should handle multipart upload errors", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          uploadPart: (
+            uploadId: string,
+            partNumber: number,
+            data: Uint8Array,
+          ) =>
+            Effect.gen(function* () {
+              if (partNumber === 2) {
+                return yield* Effect.fail(new Error("Part 2 upload failed"));
+              }
+              return {
+                uploadId,
+                partNumber,
+                etag: `etag-${partNumber}`,
+                size: data.length,
+              };
+            }),
+        };
+
+        // Part 1 succeeds
+        const result1 = yield* mockUploadService.uploadPart(
+          "multipart-123",
+          1,
+          new Uint8Array(5 * 1024 * 1024),
+        );
+        expect(result1.partNumber).toBe(1);
+
+        // Part 2 fails
+        const result2 = yield* Effect.either(
+          mockUploadService.uploadPart(
+            "multipart-123",
+            2,
+            new Uint8Array(5 * 1024 * 1024),
+          ),
+        );
+        expect(result2._tag).toBe("Left");
+      }),
+    );
+  });
+
+  describe("Upload Progress Tracking", () => {
+    it.effect("should report upload progress", () =>
+      Effect.gen(function* () {
+        const progressEvents: Array<{
+          bytesUploaded: number;
+          percentage: number;
+        }> = [];
+
+        const mockUploadService = {
+          trackProgress: (
+            uploadId: string,
+            bytesUploaded: number,
+            totalBytes: number,
+          ) =>
+            Effect.sync(() => {
+              const percentage = Math.round((bytesUploaded / totalBytes) * 100);
+              progressEvents.push({ bytesUploaded, percentage });
+              return {
+                uploadId,
+                bytesUploaded,
+                totalBytes,
+                percentage,
+              };
+            }),
+        };
+
+        const totalBytes = 10 * 1024 * 1024; // 10MB
+
+        yield* mockUploadService.trackProgress(
+          "upload-123",
+          2 * 1024 * 1024,
+          totalBytes,
+        ); // 20%
+        yield* mockUploadService.trackProgress(
+          "upload-123",
+          5 * 1024 * 1024,
+          totalBytes,
+        ); // 50%
+        yield* mockUploadService.trackProgress(
+          "upload-123",
+          8 * 1024 * 1024,
+          totalBytes,
+        ); // 80%
+        yield* mockUploadService.trackProgress(
+          "upload-123",
+          10 * 1024 * 1024,
+          totalBytes,
+        ); // 100%
+
+        expect(progressEvents).toHaveLength(4);
+        expect(progressEvents[0]?.percentage).toBe(20);
+        expect(progressEvents[1]?.percentage).toBe(50);
+        expect(progressEvents[2]?.percentage).toBe(80);
+        expect(progressEvents[3]?.percentage).toBe(100);
+      }),
+    );
+
+    it.effect("should calculate upload speed", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          calculateSpeed: (bytesUploaded: number, elapsedSeconds: number) =>
+            Effect.succeed({
+              bytesPerSecond: Math.floor(bytesUploaded / elapsedSeconds),
+              mbps: parseFloat(
+                ((bytesUploaded / elapsedSeconds / 1024 / 1024) * 8).toFixed(2),
+              ),
+            }),
+        };
+
+        // 5MB in 2 seconds
+        const result = yield* mockUploadService.calculateSpeed(
+          5 * 1024 * 1024,
+          2,
+        );
+
+        expect(result.bytesPerSecond).toBeGreaterThan(0);
+        expect(result.mbps).toBeGreaterThan(0);
+      }),
+    );
+
+    it.effect("should estimate time remaining", () =>
+      Effect.gen(function* () {
+        const mockUploadService = {
+          estimateTimeRemaining: (
+            bytesUploaded: number,
+            totalBytes: number,
+            bytesPerSecond: number,
+          ) =>
+            Effect.succeed({
+              bytesRemaining: totalBytes - bytesUploaded,
+              secondsRemaining: Math.ceil(
+                (totalBytes - bytesUploaded) / bytesPerSecond,
+              ),
+            }),
+        };
+
+        // 3MB uploaded out of 10MB, at 1MB/s
+        const result = yield* mockUploadService.estimateTimeRemaining(
+          3 * 1024 * 1024,
+          10 * 1024 * 1024,
+          1024 * 1024,
+        );
+
+        expect(result.bytesRemaining).toBe(7 * 1024 * 1024);
+        expect(result.secondsRemaining).toBe(7);
+      }),
+    );
+  });
+
+  describe("HTTP Status Codes", () => {
+    it.effect("should return 200 OK for successful upload", () =>
+      Effect.gen(function* () {
+        const mockHandler = {
+          handleUpload: () =>
+            Effect.succeed({
+              statusCode: 200,
+              body: { success: true, uploadId: "upload-123" },
+            }),
+        };
+
+        const result = yield* mockHandler.handleUpload();
+        expect(result.statusCode).toBe(200);
+        expect(result.body.success).toBe(true);
+      }),
+    );
+
+    it.effect("should return 400 Bad Request for invalid input", () =>
+      Effect.gen(function* () {
+        const mockHandler = {
+          handleUpload: (fileSize: number) =>
+            Effect.succeed(
+              fileSize <= 0
+                ? {
+                    statusCode: 400,
+                    body: { error: "Invalid file size" },
+                  }
+                : {
+                    statusCode: 200,
+                    body: { success: true },
+                  },
+            ),
+        };
+
+        const result = yield* mockHandler.handleUpload(0);
+        expect(result.statusCode).toBe(400);
+        expect(result.body.error).toBe("Invalid file size");
+      }),
+    );
+
+    it.effect("should return 413 Payload Too Large for oversized uploads", () =>
+      Effect.gen(function* () {
+        const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
+
+        const mockHandler = {
+          handleUpload: (fileSize: number) =>
+            Effect.succeed(
+              fileSize > MAX_FILE_SIZE
+                ? {
+                    statusCode: 413,
+                    body: { error: "File too large" },
+                  }
+                : {
+                    statusCode: 200,
+                    body: { success: true },
+                  },
+            ),
+        };
+
+        const result = yield* mockHandler.handleUpload(200 * 1024 * 1024);
+        expect(result.statusCode).toBe(413);
+      }),
+    );
+
+    it.effect(
+      "should return 500 Internal Server Error for server failures",
+      () =>
+        Effect.gen(function* () {
+          const mockHandler = {
+            handleUpload: () =>
+              Effect.succeed({
+                statusCode: 500,
+                body: { error: "Internal server error" },
+              }),
+          };
+
+          const result = yield* mockHandler.handleUpload();
+          expect(result.statusCode).toBe(500);
+        }),
+    );
+  });
+
+  describe("Upload Metadata Validation", () => {
+    it.effect("should validate required metadata fields", () =>
+      Effect.gen(function* () {
+        const mockValidator = {
+          validateMetadata: (metadata: Record<string, unknown>) =>
+            Effect.gen(function* () {
+              const requiredFields = ["fileName", "fileSize", "contentType"];
+              const missingFields = requiredFields.filter(
+                (field) => !(field in metadata),
+              );
+
+              if (missingFields.length > 0) {
+                return yield* Effect.fail(
+                  new Error(
+                    `Missing required fields: ${missingFields.join(", ")}`,
+                  ),
+                );
+              }
+
+              return { valid: true };
+            }),
+        };
+
+        // Valid metadata
+        const result1 = yield* mockValidator.validateMetadata({
+          fileName: "test.txt",
+          fileSize: 1024,
+          contentType: "text/plain",
+        });
+        expect(result1.valid).toBe(true);
+
+        // Missing fields
+        const result2 = yield* Effect.either(
+          mockValidator.validateMetadata({
+            fileName: "test.txt",
+          }),
+        );
+        expect(result2._tag).toBe("Left");
+      }),
+    );
+
+    it.effect("should validate file type restrictions", () =>
+      Effect.gen(function* () {
+        const allowedTypes = ["image/jpeg", "image/png", "image/gif"];
+
+        const mockValidator = {
+          validateFileType: (contentType: string) =>
+            Effect.gen(function* () {
+              if (!allowedTypes.includes(contentType)) {
+                return yield* Effect.fail(new Error("File type not allowed"));
+              }
+              return { valid: true };
+            }),
+        };
+
+        // Allowed type
+        const result1 = yield* mockValidator.validateFileType("image/jpeg");
+        expect(result1.valid).toBe(true);
+
+        // Disallowed type
+        const result2 = yield* Effect.either(
+          mockValidator.validateFileType("application/pdf"),
+        );
+        expect(result2._tag).toBe("Left");
+      }),
+    );
+  });
+});