@uploadista/client-browser 0.0.20 → 0.1.0-beta.5

package/src/services/websocket-factory.test.ts

@@ -0,0 +1,245 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createBrowserWebSocketFactory } from "./websocket-factory";
+
+// Mock WebSocket
+class MockWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+
+  readyState = MockWebSocket.CONNECTING;
+  url: string;
+  onopen: (() => void) | null = null;
+  onclose: ((event: { code: number; reason: string }) => void) | null = null;
+  onerror: ((event: { message: string }) => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+
+  private sentMessages: (string | Uint8Array)[] = [];
+
+  constructor(url: string) {
+    this.url = url;
+    // Simulate connection opening
+    setTimeout(() => {
+      this.readyState = MockWebSocket.OPEN;
+      this.onopen?.();
+    }, 0);
+  }
+
+  send(data: string | Uint8Array): void {
+    this.sentMessages.push(data);
+  }
+
+  close(code?: number, reason?: string): void {
+    this.readyState = MockWebSocket.CLOSING;
+    setTimeout(() => {
+      this.readyState = MockWebSocket.CLOSED;
+      this.onclose?.({ code: code ?? 1000, reason: reason ?? "" });
+    }, 0);
+  }
+
+  // Test helpers
+  simulateMessage(data: string): void {
+    this.onmessage?.({ data });
+  }
+
+  simulateError(message: string): void {
+    this.onerror?.({ message });
+  }
+
+  getSentMessages(): (string | Uint8Array)[] {
+    return this.sentMessages;
+  }
+}
+
+describe("createBrowserWebSocketFactory", () => {
+  let originalWebSocket: typeof WebSocket;
+
+  beforeEach(() => {
+    originalWebSocket = globalThis.WebSocket;
+    (globalThis as unknown as { WebSocket: typeof MockWebSocket }).WebSocket =
+      MockWebSocket;
+  });
+
+  afterEach(() => {
+    globalThis.WebSocket = originalWebSocket;
+  });
+
+  it("should create a WebSocket factory", () => {
+    const factory = createBrowserWebSocketFactory();
+    expect(factory).toBeDefined();
+    expect(factory.create).toBeDefined();
+    expect(typeof factory.create).toBe("function");
+  });
+
+  describe("create", () => {
+    it("should create a WebSocket connection", () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      expect(ws).toBeDefined();
+      expect(ws.readyState).toBe(0); // CONNECTING
+    });
+
+    it("should have CONNECTING, OPEN, CLOSING, CLOSED constants", () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      expect(ws.CONNECTING).toBe(0);
+      expect(ws.OPEN).toBe(1);
+      expect(ws.CLOSING).toBe(2);
+      expect(ws.CLOSED).toBe(3);
+    });
+  });
+
+  describe("WebSocket events", () => {
+    it("should call onopen when connection opens", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      const onopen = vi.fn();
+      ws.onopen = onopen;
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(onopen).toHaveBeenCalled();
+      expect(ws.readyState).toBe(1); // OPEN
+    });
+
+    it("should call onclose when connection closes", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      const onclose = vi.fn();
+      ws.onclose = onclose;
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // Close the connection
+      ws.close(1000, "Normal closure");
+
+      // Wait for close event
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(onclose).toHaveBeenCalledWith({
+        code: 1000,
+        reason: "Normal closure",
+      });
+    });
+
+    it("should call onerror when error occurs", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      const onerror = vi.fn();
+      ws.onerror = onerror;
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // Simulate error using the mock helper
+      const nativeWs = (ws as unknown as { native: MockWebSocket }).native;
+      if (nativeWs && "simulateError" in nativeWs) {
+        nativeWs.simulateError("Test error");
+      } else {
+        // Fallback: call onerror directly
+        ws.onerror?.({ message: "WebSocket error" });
+      }
+
+      expect(onerror).toHaveBeenCalled();
+    });
+
+    it("should call onmessage when message received", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      const onmessage = vi.fn();
+      ws.onmessage = onmessage;
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // Simulate message
+      const nativeWs = (ws as unknown as { native: MockWebSocket }).native;
+      if (nativeWs && "simulateMessage" in nativeWs) {
+        nativeWs.simulateMessage('{"type": "test"}');
+      } else {
+        // Fallback
+        ws.onmessage?.({ data: '{"type": "test"}' });
+      }
+
+      expect(onmessage).toHaveBeenCalledWith({ data: '{"type": "test"}' });
+    });
+  });
+
+  describe("send", () => {
+    it("should send string data", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      ws.send('{"type": "subscribe"}');
+
+      // Verify message was sent (would check mock in real scenario)
+      expect(ws.readyState).toBe(1); // OPEN
+    });
+
+    it("should send binary data", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      const binaryData = new Uint8Array([1, 2, 3, 4]);
+      ws.send(binaryData);
+
+      expect(ws.readyState).toBe(1); // OPEN
+    });
+  });
+
+  describe("close", () => {
+    it("should close with default code", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      const onclose = vi.fn();
+      ws.onclose = onclose;
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      ws.close();
+
+      // Wait for close event
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(ws.readyState).toBe(3); // CLOSED
+    });
+
+    it("should close with custom code and reason", async () => {
+      const factory = createBrowserWebSocketFactory();
+      const ws = factory.create("wss://api.example.com/ws");
+
+      const onclose = vi.fn();
+      ws.onclose = onclose;
+
+      // Wait for connection to open
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      ws.close(1001, "Going away");
+
+      // Wait for close event
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(onclose).toHaveBeenCalledWith({
+        code: 1001,
+        reason: "Going away",
+      });
+    });
+  });
+});

package/src/utils/hash-util.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it, vi } from "vitest";
+import { computeblobSha256 } from "./hash-util";
+
+describe("computeblobSha256", () => {
+  it("should compute SHA-256 hash of a blob", async () => {
+    const blob = new Blob(["Hello, World!"], { type: "text/plain" });
+    const hash = await computeblobSha256(blob);
+
+    // Hash should be a 64-character hex string
+    expect(hash).toHaveLength(64);
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it("should compute SHA-256 hash of a File", async () => {
+    const file = new File(["Test content"], "test.txt", { type: "text/plain" });
+    const hash = await computeblobSha256(file);
+
+    expect(hash).toHaveLength(64);
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it("should return same hash for identical content", async () => {
+    const content = "Same content for both";
+    const blob1 = new Blob([content], { type: "text/plain" });
+    const blob2 = new Blob([content], { type: "text/plain" });
+
+    const hash1 = await computeblobSha256(blob1);
+    const hash2 = await computeblobSha256(blob2);
+
+    expect(hash1).toBe(hash2);
+  });
+
+  it("should return different hash for different content", async () => {
+    const blob1 = new Blob(["Content A"], { type: "text/plain" });
+    const blob2 = new Blob(["Content B"], { type: "text/plain" });
+
+    const hash1 = await computeblobSha256(blob1);
+    const hash2 = await computeblobSha256(blob2);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  it("should handle empty blob", async () => {
+    const blob = new Blob([], { type: "text/plain" });
+    const hash = await computeblobSha256(blob);
+
+    expect(hash).toHaveLength(64);
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it("should handle binary content", async () => {
+    const binaryData = new Uint8Array([0, 1, 2, 255, 254, 253]);
+    const blob = new Blob([binaryData], { type: "application/octet-stream" });
+    const hash = await computeblobSha256(blob);
+
+    expect(hash).toHaveLength(64);
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it("should throw error when crypto API fails", async () => {
+    // Save original
+    const originalSubtle = crypto.subtle;
+
+    // Mock crypto.subtle.digest to throw
+    Object.defineProperty(crypto, "subtle", {
+      value: {
+        digest: vi.fn().mockRejectedValue(new Error("Crypto error")),
+      },
+      writable: true,
+    });
+
+    const blob = new Blob(["test"], { type: "text/plain" });
+
+    await expect(computeblobSha256(blob)).rejects.toThrow(
+      "Failed to compute file checksum"
+    );
+
+    // Restore original
+    Object.defineProperty(crypto, "subtle", {
+      value: originalSubtle,
+      writable: true,
+    });
+  });
+});

package/vitest.config.ts

@@ -3,9 +3,10 @@ import { defineConfig } from "vitest/config";
 export default defineConfig({
   test: {
     globals: true,
-    environment: "node",
+    environment: "happy-dom",
     include: ["src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
     exclude: ["node_modules", "dist"],
+    setupFiles: ["./src/__tests__/setup.ts"],
     coverage: {
       provider: "v8",
       reporter: ["text", "json", "html"],
@@ -15,6 +16,7 @@ export default defineConfig({
         "**/*.d.ts",
         "**/*.test.ts",
         "**/*.spec.ts",
+        "**/__tests__/**",
       ],
     },
   },