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

package/src/http-client.test.ts

@@ -0,0 +1,402 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createHttpClient } from "./http-client";
+
+describe("createHttpClient", () => {
+  // Mock fetch globally
+  const mockFetch = vi.fn();
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    globalThis.fetch = mockFetch;
+    mockFetch.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+  });
+
+  it("should create an HTTP client with default config", () => {
+    const client = createHttpClient();
+    expect(client).toBeDefined();
+    expect(client.request).toBeDefined();
+    expect(client.getMetrics).toBeDefined();
+    expect(client.getDetailedMetrics).toBeDefined();
+    expect(client.warmupConnections).toBeDefined();
+    expect(client.reset).toBeDefined();
+    expect(client.close).toBeDefined();
+  });
+
+  it("should create an HTTP client with custom config", () => {
+    const client = createHttpClient({
+      maxConnectionsPerHost: 10,
+      connectionTimeout: 60000,
+      keepAliveTimeout: 120000,
+      enableHttp2: true,
+      retryOnConnectionError: true,
+    });
+    expect(client).toBeDefined();
+  });
+
+  describe("request", () => {
+    it("should make a GET request", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({ data: "test" }),
+        text: vi.fn().mockResolvedValue("test"),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+      const response = await client.request("https://api.example.com/data");
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/data",
+        expect.objectContaining({
+          method: "GET",
+          headers: expect.objectContaining({
+            Connection: "keep-alive",
+          }),
+        })
+      );
+      expect(response.status).toBe(200);
+      expect(response.ok).toBe(true);
+    });
+
+    it("should make a POST request with body", async () => {
+      const mockResponse = {
+        status: 201,
+        statusText: "Created",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({ id: 1 }),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+      const body = JSON.stringify({ name: "test" });
+      const response = await client.request("https://api.example.com/data", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/data",
+        expect.objectContaining({
+          method: "POST",
+          body,
+        })
+      );
+      expect(response.status).toBe(201);
+    });
+
+    it("should handle request timeout", async () => {
+      // Use real timers for this test since we need actual timing
+      vi.useRealTimers();
+
+      mockFetch.mockImplementation(
+        (_url: string, options?: RequestInit) =>
+          new Promise((resolve, reject) => {
+            const signal = options?.signal;
+            const timeoutId = setTimeout(() => {
+              resolve({
+                status: 200,
+                statusText: "OK",
+                ok: true,
+                headers: new Headers(),
+                json: vi.fn().mockResolvedValue({}),
+                text: vi.fn().mockResolvedValue(""),
+                arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+              });
+            }, 1000);
+
+            // Listen for abort signal
+            signal?.addEventListener("abort", () => {
+              clearTimeout(timeoutId);
+              reject(new DOMException("Aborted", "AbortError"));
+            });
+          })
+      );
+
+      const client = createHttpClient();
+
+      await expect(
+        client.request("https://api.example.com/slow", {
+          timeout: 50,
+        })
+      ).rejects.toThrow();
+
+      // Restore fake timers for other tests
+      vi.useFakeTimers({ shouldAdvanceTime: true });
+    });
+
+    it("should pass abort signal", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+      const controller = new AbortController();
+
+      await client.request("https://api.example.com/data", {
+        signal: controller.signal,
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/data",
+        expect.objectContaining({
+          signal: expect.any(AbortSignal),
+        })
+      );
+    });
+
+    it("should include credentials by default", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+      await client.request("https://api.example.com/data");
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/data",
+        expect.objectContaining({
+          credentials: "include",
+        })
+      );
+    });
+
+    it("should throw on fetch error", async () => {
+      mockFetch.mockRejectedValue(new Error("Network error"));
+
+      const client = createHttpClient();
+
+      await expect(
+        client.request("https://api.example.com/data")
+      ).rejects.toThrow("Network error");
+    });
+  });
+
+  describe("getMetrics", () => {
+    it("should return initial metrics", () => {
+      const client = createHttpClient();
+      const metrics = client.getMetrics();
+
+      expect(metrics).toEqual({
+        activeConnections: 0,
+        totalConnections: 0,
+        reuseRate: 0,
+        averageConnectionTime: 0,
+      });
+    });
+
+    it("should update metrics after requests", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+
+      await client.request("https://api.example.com/data");
+
+      const metrics = client.getMetrics();
+      expect(metrics.totalConnections).toBe(1);
+      expect(metrics.averageConnectionTime).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("getDetailedMetrics", () => {
+    it("should return detailed metrics", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+      await client.request("https://api.example.com/data");
+
+      const detailed = client.getDetailedMetrics();
+
+      expect(detailed.health).toBeDefined();
+      expect(detailed.health.status).toBeDefined();
+      expect(detailed.health.score).toBeDefined();
+      expect(detailed.health.issues).toBeDefined();
+      expect(detailed.health.recommendations).toBeDefined();
+      expect(detailed.requestsPerSecond).toBeDefined();
+      expect(detailed.errorRate).toBeDefined();
+      expect(detailed.http2Info).toBeDefined();
+    });
+
+    it("should calculate health based on metrics", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+
+      // Make several requests
+      for (let i = 0; i < 5; i++) {
+        await client.request("https://api.example.com/data");
+      }
+
+      const detailed = client.getDetailedMetrics();
+      expect(["healthy", "degraded", "poor"]).toContain(detailed.health.status);
+      expect(detailed.health.score).toBeGreaterThanOrEqual(0);
+      expect(detailed.health.score).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe("warmupConnections", () => {
+    it("should make HEAD requests to warm up connections", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+      await client.warmupConnections([
+        "https://api1.example.com",
+        "https://api2.example.com",
+      ]);
+
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api1.example.com",
+        expect.objectContaining({
+          method: "HEAD",
+        })
+      );
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api2.example.com",
+        expect.objectContaining({
+          method: "HEAD",
+        })
+      );
+    });
+
+    it("should handle warmup failures gracefully", async () => {
+      mockFetch.mockRejectedValue(new Error("Connection failed"));
+
+      const client = createHttpClient();
+
+      // Should not throw
+      await expect(
+        client.warmupConnections(["https://api.example.com"])
+      ).resolves.not.toThrow();
+    });
+
+    it("should handle empty URL list", async () => {
+      const client = createHttpClient();
+
+      await expect(client.warmupConnections([])).resolves.not.toThrow();
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("reset", () => {
+    it("should reset all metrics", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+
+      // Make some requests
+      await client.request("https://api.example.com/data");
+      await client.request("https://api.example.com/data");
+
+      // Verify metrics are populated
+      let metrics = client.getMetrics();
+      expect(metrics.totalConnections).toBe(2);
+
+      // Reset
+      client.reset();
+
+      // Verify metrics are cleared
+      metrics = client.getMetrics();
+      expect(metrics.totalConnections).toBe(0);
+      expect(metrics.reuseRate).toBe(0);
+      expect(metrics.averageConnectionTime).toBe(0);
+    });
+  });
+
+  describe("close", () => {
+    it("should close gracefully", async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: "OK",
+        ok: true,
+        headers: new Headers(),
+        json: vi.fn().mockResolvedValue({}),
+        text: vi.fn().mockResolvedValue(""),
+        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+      };
+      mockFetch.mockResolvedValue(mockResponse);
+
+      const client = createHttpClient();
+
+      await client.request("https://api.example.com/data");
+
+      await expect(client.close()).resolves.not.toThrow();
+
+      // Metrics should be reset after close
+      const metrics = client.getMetrics();
+      expect(metrics.totalConnections).toBe(0);
+    });
+  });
+});

package/src/http-client.ts

@@ -134,6 +134,17 @@ class BrowserHttpClient implements HttpClient {
    * @private
    */
   private detectHttp2Support(): Http2Info {
+    // Check if we're in a browser environment
+    if (typeof window === "undefined" || typeof navigator === "undefined") {
+      // SSR/Node.js environment - return safe defaults
+      return {
+        supported: false,
+        detected: false,
+        version: "h1.1",
+        multiplexingActive: false,
+      };
+    }
+
     // Check if the browser supports HTTP/2
     const supported = "serviceWorker" in navigator && "fetch" in window;
 

package/src/services/abort-controller-factory.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it, vi } from "vitest";
+import { createBrowserAbortControllerFactory } from "./abort-controller-factory";
+
+describe("createBrowserAbortControllerFactory", () => {
+  it("should create an AbortController factory", () => {
+    const factory = createBrowserAbortControllerFactory();
+    expect(factory).toBeDefined();
+    expect(factory.create).toBeDefined();
+    expect(typeof factory.create).toBe("function");
+  });
+
+  describe("create", () => {
+    it("should create an AbortController instance", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      expect(controller).toBeDefined();
+      expect(controller.signal).toBeDefined();
+      expect(controller.abort).toBeDefined();
+      expect(typeof controller.abort).toBe("function");
+    });
+
+    it("should create independent controllers", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller1 = factory.create();
+      const controller2 = factory.create();
+
+      expect(controller1).not.toBe(controller2);
+      expect(controller1.signal).not.toBe(controller2.signal);
+    });
+  });
+
+  describe("signal", () => {
+    it("should have aborted property set to false initially", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      expect(controller.signal.aborted).toBe(false);
+    });
+
+    it("should support addEventListener", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      const listener = vi.fn();
+      controller.signal.addEventListener("abort", listener);
+
+      controller.abort();
+
+      expect(listener).toHaveBeenCalled();
+    });
+  });
+
+  describe("abort", () => {
+    it("should set aborted to true on signal", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      controller.abort();
+
+      expect(controller.signal.aborted).toBe(true);
+    });
+
+    it("should abort with reason", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      const reason = new Error("User cancelled");
+      controller.abort(reason);
+
+      expect(controller.signal.aborted).toBe(true);
+      expect(controller.signal.reason).toBe(reason);
+    });
+
+    it("should not throw when aborting multiple times", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      expect(() => {
+        controller.abort();
+        controller.abort();
+        controller.abort();
+      }).not.toThrow();
+
+      expect(controller.signal.aborted).toBe(true);
+    });
+
+    it("should trigger abort event", () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      const abortHandler = vi.fn();
+      controller.signal.addEventListener("abort", abortHandler);
+
+      controller.abort();
+
+      expect(abortHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it("should work with fetch-like API", async () => {
+      const factory = createBrowserAbortControllerFactory();
+      const controller = factory.create();
+
+      // Simulate an abortable operation
+      const operation = new Promise((resolve, reject) => {
+        const checkAbort = () => {
+          if (controller.signal.aborted) {
+            reject(new DOMException("Aborted", "AbortError"));
+            return true;
+          }
+          return false;
+        };
+
+        if (checkAbort()) return;
+
+        controller.signal.addEventListener("abort", () => {
+          reject(new DOMException("Aborted", "AbortError"));
+        });
+
+        // Simulate async work
+        setTimeout(() => {
+          if (!checkAbort()) {
+            resolve("completed");
+          }
+        }, 100);
+      });
+
+      // Abort immediately
+      controller.abort();
+
+      await expect(operation).rejects.toThrow("Aborted");
+    });
+  });
+
+  describe("integration", () => {
+    it("should work with multiple independent operations", () => {
+      const factory = createBrowserAbortControllerFactory();
+
+      const controller1 = factory.create();
+      const controller2 = factory.create();
+      const controller3 = factory.create();
+
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      const handler3 = vi.fn();
+
+      controller1.signal.addEventListener("abort", handler1);
+      controller2.signal.addEventListener("abort", handler2);
+      controller3.signal.addEventListener("abort", handler3);
+
+      // Abort only controller2
+      controller2.abort();
+
+      expect(controller1.signal.aborted).toBe(false);
+      expect(controller2.signal.aborted).toBe(true);
+      expect(controller3.signal.aborted).toBe(false);
+
+      expect(handler1).not.toHaveBeenCalled();
+      expect(handler2).toHaveBeenCalled();
+      expect(handler3).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/services/checksum-service.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { createChecksumService } from "./checksum-service";
+
+describe("createChecksumService", () => {
+  it("should create a checksum service", () => {
+    const service = createChecksumService();
+    expect(service).toBeDefined();
+    expect(service.computeChecksum).toBeDefined();
+    expect(typeof service.computeChecksum).toBe("function");
+  });
+
+  describe("computeChecksum", () => {
+    it("should compute checksum for Uint8Array data", async () => {
+      const service = createChecksumService();
+      const data = new Uint8Array([1, 2, 3, 4, 5]);
+
+      const checksum = await service.computeChecksum(data);
+
+      // Should return a 64-character hex string (SHA-256)
+      expect(checksum).toHaveLength(64);
+      expect(checksum).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it("should return same checksum for identical data", async () => {
+      const service = createChecksumService();
+      const data1 = new Uint8Array([1, 2, 3, 4, 5]);
+      const data2 = new Uint8Array([1, 2, 3, 4, 5]);
+
+      const checksum1 = await service.computeChecksum(data1);
+      const checksum2 = await service.computeChecksum(data2);
+
+      expect(checksum1).toBe(checksum2);
+    });
+
+    it("should return different checksum for different data", async () => {
+      const service = createChecksumService();
+      const data1 = new Uint8Array([1, 2, 3, 4, 5]);
+      const data2 = new Uint8Array([5, 4, 3, 2, 1]);
+
+      const checksum1 = await service.computeChecksum(data1);
+      const checksum2 = await service.computeChecksum(data2);
+
+      expect(checksum1).not.toBe(checksum2);
+    });
+
+    it("should handle empty data", async () => {
+      const service = createChecksumService();
+      const data = new Uint8Array([]);
+
+      const checksum = await service.computeChecksum(data);
+
+      expect(checksum).toHaveLength(64);
+      expect(checksum).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it("should handle large data", async () => {
+      const service = createChecksumService();
+      // Create 1KB of data
+      const data = new Uint8Array(1024);
+      for (let i = 0; i < data.length; i++) {
+        data[i] = i % 256;
+      }
+
+      const checksum = await service.computeChecksum(data);
+
+      expect(checksum).toHaveLength(64);
+      expect(checksum).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+});