@uploadista/server 0.0.13-beta.4 → 0.0.13

package/tests/core/websocket-handlers/websocket-handlers.test.ts

@@ -0,0 +1,659 @@
+/**
+ * Tests for WebSocket Handlers
+ *
+ * Covers:
+ * - WebSocket connection authentication
+ * - Real-time upload progress updates
+ * - Flow execution event streaming
+ * - Connection lifecycle management
+ * - Error handling and reconnection
+ * - Message broadcasting
+ */
+
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { describe, expect } from "vitest";
+
+describe("WebSocket Handlers", () => {
+  describe("Connection Authentication", () => {
+    it.effect("should authenticate valid connection with token", () =>
+      Effect.gen(function* () {
+        const mockAuthService = {
+          authenticateConnection: (token: string) =>
+            Effect.gen(function* () {
+              if (token === "valid-token") {
+                return {
+                  authenticated: true,
+                  clientId: "client-123",
+                  permissions: ["upload", "read"],
+                };
+              }
+              return yield* Effect.fail(new Error("Invalid token"));
+            }),
+        };
+
+        const result =
+          yield* mockAuthService.authenticateConnection("valid-token");
+
+        expect(result.authenticated).toBe(true);
+        expect(result.clientId).toBe("client-123");
+        expect(result.permissions).toContain("upload");
+      }),
+    );
+
+    it.effect("should reject invalid authentication tokens", () =>
+      Effect.gen(function* () {
+        const mockAuthService = {
+          authenticateConnection: (token: string) =>
+            Effect.gen(function* () {
+              if (token !== "valid-token") {
+                return yield* Effect.fail(new Error("Invalid token"));
+              }
+              return {
+                authenticated: true,
+                clientId: "client-123",
+              };
+            }),
+        };
+
+        const result = yield* Effect.either(
+          mockAuthService.authenticateConnection("invalid-token"),
+        );
+
+        expect(result._tag).toBe("Left");
+      }),
+    );
+
+    it.effect("should handle anonymous connections when allowed", () =>
+      Effect.gen(function* () {
+        const mockAuthService = {
+          authenticateConnection: (
+            token: string | null,
+            allowAnonymous: boolean,
+          ) =>
+            Effect.gen(function* () {
+              if (token === null && allowAnonymous) {
+                return {
+                  authenticated: true,
+                  clientId: null,
+                  anonymous: true,
+                };
+              }
+              if (token === null) {
+                return yield* Effect.fail(new Error("Authentication required"));
+              }
+              return {
+                authenticated: true,
+                clientId: "client-123",
+                anonymous: false,
+              };
+            }),
+        };
+
+        const result = yield* mockAuthService.authenticateConnection(
+          null,
+          true,
+        );
+
+        expect(result.authenticated).toBe(true);
+        expect(result.anonymous).toBe(true);
+        expect(result.clientId).toBeNull();
+      }),
+    );
+
+    it.effect("should validate connection permissions", () =>
+      Effect.gen(function* () {
+        const mockAuthService = {
+          validatePermission: (clientId: string, requiredPermission: string) =>
+            Effect.gen(function* () {
+              const clientPermissions: Record<string, string[]> = {
+                "client-123": ["upload", "read"],
+                "client-456": ["read"],
+              };
+
+              const permissions = clientPermissions[clientId] || [];
+              if (!permissions.includes(requiredPermission)) {
+                return yield* Effect.fail(new Error("Permission denied"));
+              }
+
+              return { hasPermission: true };
+            }),
+        };
+
+        // Client with upload permission
+        const result1 = yield* mockAuthService.validatePermission(
+          "client-123",
+          "upload",
+        );
+        expect(result1.hasPermission).toBe(true);
+
+        // Client without upload permission
+        const result2 = yield* Effect.either(
+          mockAuthService.validatePermission("client-456", "upload"),
+        );
+        expect(result2._tag).toBe("Left");
+      }),
+    );
+  });
+
+  describe("Real-Time Upload Progress", () => {
+    it.effect("should stream upload progress events", () =>
+      Effect.gen(function* () {
+        const progressEvents: Array<{ uploadId: string; progress: number }> =
+          [];
+
+        const mockProgressService = {
+          streamProgress: (uploadId: string, progress: number) =>
+            Effect.sync(() => {
+              progressEvents.push({ uploadId, progress });
+              return {
+                type: "progress" as const,
+                uploadId,
+                progress,
+                timestamp: Date.now(),
+              };
+            }),
+        };
+
+        yield* mockProgressService.streamProgress("upload-123", 25);
+        yield* mockProgressService.streamProgress("upload-123", 50);
+        yield* mockProgressService.streamProgress("upload-123", 75);
+        yield* mockProgressService.streamProgress("upload-123", 100);
+
+        expect(progressEvents).toHaveLength(4);
+        expect(progressEvents[0]?.progress).toBe(25);
+        expect(progressEvents[3]?.progress).toBe(100);
+      }),
+    );
+
+    it.effect("should broadcast progress to multiple clients", () =>
+      Effect.gen(function* () {
+        const clientUpdates: Record<string, number[]> = {};
+
+        const mockBroadcastService = {
+          broadcastProgress: (
+            _uploadId: string,
+            progress: number,
+            clientIds: string[],
+          ) =>
+            Effect.sync(() => {
+              for (const clientId of clientIds) {
+                if (!clientUpdates[clientId]) {
+                  clientUpdates[clientId] = [];
+                }
+                clientUpdates[clientId].push(progress);
+              }
+              return { sent: clientIds.length };
+            }),
+        };
+
+        yield* mockBroadcastService.broadcastProgress("upload-123", 50, [
+          "client-1",
+          "client-2",
+          "client-3",
+        ]);
+
+        expect(Object.keys(clientUpdates)).toHaveLength(3);
+        expect(clientUpdates["client-1"]).toContain(50);
+        expect(clientUpdates["client-2"]).toContain(50);
+        expect(clientUpdates["client-3"]).toContain(50);
+      }),
+    );
+
+    it.effect("should handle upload completion events", () =>
+      Effect.gen(function* () {
+        const mockProgressService = {
+          sendCompletionEvent: (uploadId: string, fileUrl: string) =>
+            Effect.succeed({
+              type: "completed" as const,
+              uploadId,
+              fileUrl,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockProgressService.sendCompletionEvent(
+          "upload-123",
+          "https://storage.example.com/files/upload-123",
+        );
+
+        expect(result.type).toBe("completed");
+        expect(result.uploadId).toBe("upload-123");
+        expect(result.fileUrl).toContain("upload-123");
+      }),
+    );
+
+    it.effect("should handle upload error events", () =>
+      Effect.gen(function* () {
+        const mockProgressService = {
+          sendErrorEvent: (uploadId: string, error: string) =>
+            Effect.succeed({
+              type: "error" as const,
+              uploadId,
+              error,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockProgressService.sendErrorEvent(
+          "upload-123",
+          "Upload failed: Network error",
+        );
+
+        expect(result.type).toBe("error");
+        expect(result.uploadId).toBe("upload-123");
+        expect(result.error).toContain("Network error");
+      }),
+    );
+  });
+
+  describe("Flow Execution Events", () => {
+    it.effect("should stream flow execution start events", () =>
+      Effect.gen(function* () {
+        const mockFlowService = {
+          sendFlowStartEvent: (flowId: string, jobId: string) =>
+            Effect.succeed({
+              type: "flow-started" as const,
+              flowId,
+              jobId,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockFlowService.sendFlowStartEvent(
+          "flow-123",
+          "job-456",
+        );
+
+        expect(result.type).toBe("flow-started");
+        expect(result.flowId).toBe("flow-123");
+        expect(result.jobId).toBe("job-456");
+      }),
+    );
+
+    it.effect("should stream node execution events", () =>
+      Effect.gen(function* () {
+        const nodeEvents: Array<{ nodeId: string; status: string }> = [];
+
+        const mockFlowService = {
+          sendNodeEvent: (
+            nodeId: string,
+            status: "started" | "completed" | "failed",
+          ) =>
+            Effect.sync(() => {
+              nodeEvents.push({ nodeId, status });
+              return {
+                type: "node-event" as const,
+                nodeId,
+                status,
+                timestamp: Date.now(),
+              };
+            }),
+        };
+
+        yield* mockFlowService.sendNodeEvent("node-1", "started");
+        yield* mockFlowService.sendNodeEvent("node-1", "completed");
+        yield* mockFlowService.sendNodeEvent("node-2", "started");
+        yield* mockFlowService.sendNodeEvent("node-2", "completed");
+
+        expect(nodeEvents).toHaveLength(4);
+        expect(nodeEvents[0]?.status).toBe("started");
+        expect(nodeEvents[1]?.status).toBe("completed");
+      }),
+    );
+
+    it.effect("should stream flow completion events", () =>
+      Effect.gen(function* () {
+        const mockFlowService = {
+          sendFlowCompletionEvent: (
+            flowId: string,
+            jobId: string,
+            result: unknown,
+          ) =>
+            Effect.succeed({
+              type: "flow-completed" as const,
+              flowId,
+              jobId,
+              result,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockFlowService.sendFlowCompletionEvent(
+          "flow-123",
+          "job-456",
+          {
+            outputFile: "processed-file.jpg",
+          },
+        );
+
+        expect(result.type).toBe("flow-completed");
+        expect(result.flowId).toBe("flow-123");
+      }),
+    );
+
+    it.effect("should stream flow error events", () =>
+      Effect.gen(function* () {
+        const mockFlowService = {
+          sendFlowErrorEvent: (flowId: string, jobId: string, error: string) =>
+            Effect.succeed({
+              type: "flow-error" as const,
+              flowId,
+              jobId,
+              error,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockFlowService.sendFlowErrorEvent(
+          "flow-123",
+          "job-456",
+          "Node execution failed",
+        );
+
+        expect(result.type).toBe("flow-error");
+        expect(result.error).toContain("failed");
+      }),
+    );
+  });
+
+  describe("Connection Lifecycle", () => {
+    it.effect("should handle connection open event", () =>
+      Effect.gen(function* () {
+        const mockConnectionService = {
+          handleOpen: (connectionId: string, clientId: string) =>
+            Effect.succeed({
+              event: "connection-open" as const,
+              connectionId,
+              clientId,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockConnectionService.handleOpen(
+          "conn-123",
+          "client-456",
+        );
+
+        expect(result.event).toBe("connection-open");
+        expect(result.connectionId).toBe("conn-123");
+        expect(result.clientId).toBe("client-456");
+      }),
+    );
+
+    it.effect("should handle connection close event", () =>
+      Effect.gen(function* () {
+        const mockConnectionService = {
+          handleClose: (connectionId: string, code: number, reason: string) =>
+            Effect.succeed({
+              event: "connection-close" as const,
+              connectionId,
+              code,
+              reason,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockConnectionService.handleClose(
+          "conn-123",
+          1000,
+          "Normal closure",
+        );
+
+        expect(result.event).toBe("connection-close");
+        expect(result.code).toBe(1000);
+        expect(result.reason).toBe("Normal closure");
+      }),
+    );
+
+    it.effect("should track active connections", () =>
+      Effect.gen(function* () {
+        const activeConnections = new Set<string>();
+
+        const mockConnectionService = {
+          addConnection: (connectionId: string) =>
+            Effect.sync(() => {
+              activeConnections.add(connectionId);
+              return { count: activeConnections.size };
+            }),
+          removeConnection: (connectionId: string) =>
+            Effect.sync(() => {
+              activeConnections.delete(connectionId);
+              return { count: activeConnections.size };
+            }),
+        };
+
+        yield* mockConnectionService.addConnection("conn-1");
+        yield* mockConnectionService.addConnection("conn-2");
+        const result1 = yield* mockConnectionService.addConnection("conn-3");
+        expect(result1.count).toBe(3);
+
+        const result2 = yield* mockConnectionService.removeConnection("conn-2");
+        expect(result2.count).toBe(2);
+      }),
+    );
+
+    it.effect("should handle connection heartbeat/ping", () =>
+      Effect.gen(function* () {
+        const mockConnectionService = {
+          handlePing: (connectionId: string) =>
+            Effect.succeed({
+              type: "pong" as const,
+              connectionId,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockConnectionService.handlePing("conn-123");
+
+        expect(result.type).toBe("pong");
+        expect(result.connectionId).toBe("conn-123");
+      }),
+    );
+  });
+
+  describe("Error Handling and Reconnection", () => {
+    it.effect("should handle connection errors gracefully", () =>
+      Effect.gen(function* () {
+        const mockErrorHandler = {
+          handleConnectionError: (connectionId: string, error: string) =>
+            Effect.succeed({
+              event: "connection-error" as const,
+              connectionId,
+              error,
+              shouldReconnect: true,
+              timestamp: Date.now(),
+            }),
+        };
+
+        const result = yield* mockErrorHandler.handleConnectionError(
+          "conn-123",
+          "Network timeout",
+        );
+
+        expect(result.event).toBe("connection-error");
+        expect(result.shouldReconnect).toBe(true);
+      }),
+    );
+
+    it.effect("should implement reconnection logic with backoff", () =>
+      Effect.gen(function* () {
+        let reconnectAttempts = 0;
+        const delays: number[] = [];
+
+        const mockReconnectService = {
+          attemptReconnect: (connectionId: string, attemptNumber: number) =>
+            Effect.gen(function* () {
+              reconnectAttempts++;
+              const delay = Math.min(1000 * 2 ** attemptNumber, 30000);
+              delays.push(delay);
+
+              if (attemptNumber < 3) {
+                return yield* Effect.fail(new Error("Reconnection failed"));
+              }
+
+              return {
+                success: true,
+                connectionId,
+                attempts: reconnectAttempts,
+              };
+            }),
+        };
+
+        // Simulate reconnection attempts
+        yield* Effect.either(
+          mockReconnectService.attemptReconnect("conn-123", 0),
+        );
+        yield* Effect.either(
+          mockReconnectService.attemptReconnect("conn-123", 1),
+        );
+        yield* Effect.either(
+          mockReconnectService.attemptReconnect("conn-123", 2),
+        );
+        const result = yield* mockReconnectService.attemptReconnect(
+          "conn-123",
+          3,
+        );
+
+        expect(result.success).toBe(true);
+        expect(reconnectAttempts).toBe(4);
+        // Delays should be: 1s, 2s, 4s, 8s
+        expect(delays[0]).toBe(1000);
+        expect(delays[1]).toBe(2000);
+        expect(delays[2]).toBe(4000);
+      }),
+    );
+
+    it.effect("should limit maximum reconnection attempts", () =>
+      Effect.gen(function* () {
+        const MAX_ATTEMPTS = 5;
+        let attempts = 0;
+
+        const mockReconnectService = {
+          attemptReconnect: (_connectionId: string) =>
+            Effect.gen(function* () {
+              attempts++;
+              if (attempts >= MAX_ATTEMPTS) {
+                return {
+                  success: false,
+                  reason: "Max reconnection attempts reached",
+                };
+              }
+              return yield* Effect.fail(new Error("Reconnection failed"));
+            }),
+        };
+
+        // Attempt reconnections until max attempts
+        for (let i = 0; i < MAX_ATTEMPTS; i++) {
+          yield* Effect.either(
+            mockReconnectService.attemptReconnect("conn-123"),
+          );
+        }
+
+        const finalResult =
+          yield* mockReconnectService.attemptReconnect("conn-123");
+        expect(finalResult.success).toBe(false);
+        expect(finalResult.reason).toContain("Max reconnection attempts");
+      }),
+    );
+  });
+
+  describe("Message Broadcasting", () => {
+    it.effect("should broadcast message to all connected clients", () =>
+      Effect.gen(function* () {
+        const deliveredTo: string[] = [];
+
+        const mockBroadcastService = {
+          broadcastToAll: (_message: unknown, excludeConnectionId?: string) =>
+            Effect.sync(() => {
+              const connections = ["conn-1", "conn-2", "conn-3"];
+              for (const connId of connections) {
+                if (connId !== excludeConnectionId) {
+                  deliveredTo.push(connId);
+                }
+              }
+              return { delivered: deliveredTo.length };
+            }),
+        };
+
+        const result = yield* mockBroadcastService.broadcastToAll({
+          type: "announcement",
+        });
+
+        expect(result.delivered).toBe(3);
+        expect(deliveredTo).toHaveLength(3);
+      }),
+    );
+
+    it.effect("should broadcast to specific channel/room", () =>
+      Effect.gen(function* () {
+        const channels: Record<string, string[]> = {
+          "upload-123": ["conn-1", "conn-2"],
+          "upload-456": ["conn-3"],
+        };
+
+        const mockBroadcastService = {
+          broadcastToChannel: (channelId: string, _message: unknown) =>
+            Effect.succeed({
+              delivered: (channels[channelId] || []).length,
+              connectionIds: channels[channelId] || [],
+            }),
+        };
+
+        const result = yield* mockBroadcastService.broadcastToChannel(
+          "upload-123",
+          {
+            progress: 50,
+          },
+        );
+
+        expect(result.delivered).toBe(2);
+        expect(result.connectionIds).toContain("conn-1");
+        expect(result.connectionIds).toContain("conn-2");
+      }),
+    );
+
+    it.effect("should handle subscription to channels", () =>
+      Effect.gen(function* () {
+        const subscriptions: Record<string, Set<string>> = {};
+
+        const mockSubscriptionService = {
+          subscribe: (connectionId: string, channelId: string) =>
+            Effect.sync(() => {
+              if (!subscriptions[channelId]) {
+                subscriptions[channelId] = new Set();
+              }
+              subscriptions[channelId].add(connectionId);
+              return {
+                success: true,
+                channelId,
+                subscriberCount: subscriptions[channelId].size,
+              };
+            }),
+          unsubscribe: (connectionId: string, channelId: string) =>
+            Effect.sync(() => {
+              subscriptions[channelId]?.delete(connectionId);
+              return {
+                success: true,
+                channelId,
+                subscriberCount: subscriptions[channelId]?.size || 0,
+              };
+            }),
+        };
+
+        yield* mockSubscriptionService.subscribe("conn-1", "upload-123");
+        const result1 = yield* mockSubscriptionService.subscribe(
+          "conn-2",
+          "upload-123",
+        );
+        expect(result1.subscriberCount).toBe(2);
+
+        const result2 = yield* mockSubscriptionService.unsubscribe(
+          "conn-1",
+          "upload-123",
+        );
+        expect(result2.subscriberCount).toBe(1);
+      }),
+    );
+  });
+});

package/{src → tests}/service.test.ts

@@ -4,8 +4,8 @@ import {
   AuthContextService,
   AuthContextServiceLive,
   NoAuthContextServiceLive,
-} from "./service";
-import type { AuthContext } from "./types";
+} from "../src/service";
+import type { AuthContext } from "../src/types";
 
 describe("AuthContextService", () => {
   describe("AuthContextServiceLive", () => {