@uploadista/client-core 0.0.3

package/src/auth/__tests__/auth-http-client.test.ts

@@ -0,0 +1,327 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { HttpClient } from "../../http-client";
+import { AuthHttpClient } from "../auth-http-client";
+import { DirectAuthManager } from "../direct-auth";
+import { NoAuthManager } from "../no-auth";
+import { SaasAuthManager } from "../saas-auth";
+import type { DirectAuthConfig, SaasAuthConfig } from "../types";
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe("AuthHttpClient", () => {
+  let mockHttpClient: HttpClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create mock HTTP client
+    mockHttpClient = {
+      request: vi.fn(async () => ({
+        status: 200,
+        statusText: "OK",
+        headers: new Headers(),
+        ok: true,
+        json: async () => ({}),
+        text: async () => "",
+        arrayBuffer: async () => new ArrayBuffer(0),
+      })),
+      getMetrics: vi.fn(() => ({
+        activeConnections: 0,
+        totalConnections: 0,
+        reuseRate: 0,
+        averageConnectionTime: 0,
+      })),
+      getDetailedMetrics: vi.fn(() => ({
+        activeConnections: 0,
+        totalConnections: 0,
+        reuseRate: 0,
+        averageConnectionTime: 0,
+        health: {
+          status: "healthy" as const,
+          score: 100,
+          issues: [],
+          recommendations: [],
+        },
+        requestsPerSecond: 0,
+        errorRate: 0,
+        timeouts: 0,
+        retries: 0,
+        fastConnections: 0,
+        slowConnections: 0,
+        http2Info: {
+          supported: true,
+          detected: false,
+          version: "h2",
+          multiplexingActive: false,
+        },
+      })),
+      reset: vi.fn(),
+      close: vi.fn(async () => {}),
+      warmupConnections: vi.fn(async () => {}),
+    };
+  });
+
+  describe("with NoAuthManager", () => {
+    it("should pass through requests unchanged", async () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request("https://api.example.com/upload", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith(
+        "https://api.example.com/upload",
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    });
+  });
+
+  describe("with DirectAuthManager", () => {
+    it("should attach credentials from DirectAuthManager", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => ({
+          headers: { Authorization: "Bearer direct-token" },
+        }),
+      };
+      const authManager = new DirectAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request("https://api.example.com/upload", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith(
+        "https://api.example.com/upload",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer direct-token",
+          },
+        },
+      );
+    });
+
+    it("should handle async credentials", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return { headers: { Authorization: "Bearer async-token" } };
+        },
+      };
+      const authManager = new DirectAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request("https://api.example.com/upload");
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith(
+        "https://api.example.com/upload",
+        {
+          headers: { Authorization: "Bearer async-token" },
+        },
+      );
+    });
+  });
+
+  describe("with SaasAuthManager", () => {
+    it("should attach JWT token from SaasAuthManager", async () => {
+      const config: SaasAuthConfig = {
+        mode: "saas",
+        authServerUrl: "https://auth.example.com/token",
+        getCredentials: () => ({ username: "user", password: "pass" }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ token: "jwt-token-123" }),
+      } as Response);
+
+      const authManager = new SaasAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request("https://api.example.com/upload", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith(
+        "https://api.example.com/upload",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer jwt-token-123",
+          },
+        },
+      );
+    });
+
+    it("should extract job ID from upload URL", async () => {
+      const config: SaasAuthConfig = {
+        mode: "saas",
+        authServerUrl: "https://auth.example.com/token",
+        getCredentials: () => ({ username: "user", password: "pass" }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ token: "jwt-token-for-upload-123" }),
+      } as Response);
+
+      const authManager = new SaasAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request(
+        "https://api.example.com/uploadista/api/upload/upload-123",
+        { method: "PATCH" },
+      );
+
+      // Token should be cached for upload-123
+      const stats = authManager.getCacheStats();
+      expect(stats.cachedJobCount).toBe(1);
+    });
+
+    it("should extract job ID from flow URL", async () => {
+      const config: SaasAuthConfig = {
+        mode: "saas",
+        authServerUrl: "https://auth.example.com/token",
+        getCredentials: () => ({ username: "user", password: "pass" }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ token: "jwt-token-for-flow-456" }),
+      } as Response);
+
+      const authManager = new SaasAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request(
+        "https://api.example.com/uploadista/api/flow/flow-456/storage-id",
+        { method: "POST" },
+      );
+
+      // Token should be cached for flow-456
+      const stats = authManager.getCacheStats();
+      expect(stats.cachedJobCount).toBe(1);
+    });
+
+    it("should extract job ID from jobs URL", async () => {
+      const config: SaasAuthConfig = {
+        mode: "saas",
+        authServerUrl: "https://auth.example.com/token",
+        getCredentials: () => ({ username: "user", password: "pass" }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ token: "jwt-token-for-job-789" }),
+      } as Response);
+
+      const authManager = new SaasAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.request(
+        "https://api.example.com/uploadista/api/jobs/job-789/status",
+        { method: "GET" },
+      );
+
+      // Token should be cached for job-789
+      const stats = authManager.getCacheStats();
+      expect(stats.cachedJobCount).toBe(1);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should propagate auth errors", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => {
+          throw new Error("Failed to get auth credentials");
+        },
+      };
+
+      const authManager = new DirectAuthManager(config);
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await expect(
+        authClient.request("https://api.example.com/upload"),
+      ).rejects.toThrow("Failed to attach auth credentials");
+    });
+
+    it("should propagate HTTP client errors", async () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      vi.mocked(mockHttpClient.request).mockRejectedValueOnce(
+        new Error("Network error"),
+      );
+
+      await expect(
+        authClient.request("https://api.example.com/upload"),
+      ).rejects.toThrow("Network error");
+    });
+  });
+
+  describe("delegation methods", () => {
+    it("should delegate getMetrics", () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      authClient.getMetrics();
+      expect(mockHttpClient.getMetrics).toHaveBeenCalled();
+    });
+
+    it("should delegate getDetailedMetrics", () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      authClient.getDetailedMetrics();
+      expect(mockHttpClient.getDetailedMetrics).toHaveBeenCalled();
+    });
+
+    it("should delegate reset", () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      authClient.reset();
+      expect(mockHttpClient.reset).toHaveBeenCalled();
+    });
+
+    it("should delegate close", async () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.close();
+      expect(mockHttpClient.close).toHaveBeenCalled();
+    });
+
+    it("should delegate warmupConnections", async () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      await authClient.warmupConnections(["https://api.example.com"]);
+      expect(mockHttpClient.warmupConnections).toHaveBeenCalledWith([
+        "https://api.example.com",
+      ]);
+    });
+  });
+
+  describe("getAuthManager", () => {
+    it("should return the auth manager", () => {
+      const authManager = new NoAuthManager();
+      const authClient = new AuthHttpClient(mockHttpClient, authManager);
+
+      expect(authClient.getAuthManager()).toBe(authManager);
+    });
+  });
+});

package/src/auth/__tests__/direct-auth.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { DirectAuthManager } from "../direct-auth";
+import type { DirectAuthConfig } from "../types";
+
+describe("DirectAuthManager", () => {
+  describe("attachCredentials", () => {
+    it("should attach headers from getCredentials", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => ({
+          headers: {
+            Authorization: "Bearer test-token",
+            "X-API-Key": "api-key-123",
+          },
+        }),
+      };
+
+      const manager = new DirectAuthManager(config);
+      const result = await manager.attachCredentials({
+        "Content-Type": "application/json",
+      });
+
+      expect(result).toEqual({
+        "Content-Type": "application/json",
+        Authorization: "Bearer test-token",
+        "X-API-Key": "api-key-123",
+      });
+    });
+
+    it("should support async getCredentials", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: async () => {
+          // Simulate async token fetch
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return {
+            headers: {
+              Authorization: "Bearer async-token",
+            },
+          };
+        },
+      };
+
+      const manager = new DirectAuthManager(config);
+      const result = await manager.attachCredentials();
+
+      expect(result).toEqual({
+        Authorization: "Bearer async-token",
+      });
+    });
+
+    it("should handle empty credentials gracefully", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => ({}),
+      };
+
+      const manager = new DirectAuthManager(config);
+      const result = await manager.attachCredentials({
+        "Content-Type": "application/json",
+      });
+
+      expect(result).toEqual({
+        "Content-Type": "application/json",
+      });
+    });
+
+    it("should override existing headers with credential headers", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => ({
+          headers: {
+            Authorization: "Bearer new-token",
+          },
+        }),
+      };
+
+      const manager = new DirectAuthManager(config);
+      const result = await manager.attachCredentials({
+        Authorization: "Bearer old-token",
+        "Content-Type": "application/json",
+      });
+
+      expect(result).toEqual({
+        Authorization: "Bearer new-token",
+        "Content-Type": "application/json",
+      });
+    });
+
+    it("should throw error if getCredentials returns non-object", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => null as any,
+      };
+
+      const manager = new DirectAuthManager(config);
+
+      await expect(manager.attachCredentials()).rejects.toThrow(
+        "Failed to attach auth credentials",
+      );
+    });
+
+    it("should throw error if getCredentials throws", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => {
+          throw new Error("Token fetch failed");
+        },
+      };
+
+      const manager = new DirectAuthManager(config);
+
+      await expect(manager.attachCredentials()).rejects.toThrow(
+        "Failed to attach auth credentials: Token fetch failed",
+      );
+    });
+
+    it("should validate header types", async () => {
+      const config: DirectAuthConfig = {
+        mode: "direct",
+        getCredentials: () => ({
+          headers: {
+            Authorization: 123 as any, // Invalid: number instead of string
+          },
+        }),
+      };
+
+      const manager = new DirectAuthManager(config);
+
+      await expect(manager.attachCredentials()).rejects.toThrow(
+        "Invalid header",
+      );
+    });
+  });
+});

package/src/auth/__tests__/no-auth.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { NoAuthManager } from "../no-auth";
+
+describe("NoAuthManager", () => {
+  describe("attachCredentials", () => {
+    it("should return headers unchanged", async () => {
+      const manager = new NoAuthManager();
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      };
+
+      const result = await manager.attachCredentials(headers);
+
+      expect(result).toEqual(headers);
+      expect(result).toBe(headers); // Should be same object
+    });
+
+    it("should handle empty headers", async () => {
+      const manager = new NoAuthManager();
+      const result = await manager.attachCredentials();
+
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("clearToken", () => {
+    it("should be a no-op", () => {
+      const manager = new NoAuthManager();
+      expect(() => manager.clearToken("job-1")).not.toThrow();
+    });
+  });
+
+  describe("clearAllTokens", () => {
+    it("should be a no-op", () => {
+      const manager = new NoAuthManager();
+      expect(() => manager.clearAllTokens()).not.toThrow();
+    });
+  });
+});