@checkstack/healthcheck-http-backend 0.0.3 → 0.1.1

package/src/strategy.test.ts

@@ -1,398 +1,246 @@
 import { describe, expect, it, spyOn, afterEach } from "bun:test";
-import { HttpHealthCheckStrategy, HttpHealthCheckConfig } from "./strategy";
+import { HttpHealthCheckStrategy } from "./strategy";
 
 describe("HttpHealthCheckStrategy", () => {
   const strategy = new HttpHealthCheckStrategy();
-  const defaultConfig: HttpHealthCheckConfig = {
-    url: "https://example.com/api",
-    method: "GET",
-    timeout: 5000,
-  };
 
   afterEach(() => {
     spyOn(globalThis, "fetch").mockRestore();
   });
 
-  describe("basic execution", () => {
-    it("should return healthy for successful response without assertions", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 200 })
-      );
-      const result = await strategy.execute(defaultConfig);
-      expect(result.status).toBe("healthy");
-      expect(result.metadata?.statusCode).toBe(200);
-    });
-
-    it("should return healthy for any status without status assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 404 })
-      );
-      const result = await strategy.execute(defaultConfig);
-      // Without assertions, any response is "healthy" if reachable
-      expect(result.status).toBe("healthy");
-      expect(result.metadata?.statusCode).toBe(404);
-    });
-  });
-
-  describe("statusCode assertions", () => {
-    it("should pass statusCode equals assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 200 })
-      );
-
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [{ field: "statusCode", operator: "equals", value: 200 }],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-    });
-
-    it("should fail statusCode equals assertion when mismatch", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 404 })
-      );
-
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [{ field: "statusCode", operator: "equals", value: 200 }],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("unhealthy");
-      expect(result.message).toContain("statusCode");
-    });
-
-    it("should pass statusCode lessThan assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 201 })
-      );
-
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [{ field: "statusCode", operator: "lessThan", value: 300 }],
-      };
+  describe("createClient", () => {
+    it("should return a connected client", async () => {
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
+      expect(connectedClient.client).toBeDefined();
+      expect(connectedClient.client.exec).toBeDefined();
+      expect(connectedClient.close).toBeDefined();
     });
-  });
-
-  describe("responseTime assertions", () => {
-    it("should pass responseTime assertion when fast", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 200 })
-      );
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "responseTime", operator: "lessThan", value: 10000 },
-        ],
-      };
+    it("should allow closing the client", async () => {
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
+      expect(() => connectedClient.close()).not.toThrow();
     });
   });
 
-  describe("contentType assertions", () => {
-    it("should pass contentType contains assertion", async () => {
+  describe("client.exec", () => {
+    it("should return successful response for valid request", async () => {
       spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({}), {
+        new Response(JSON.stringify({ status: "ok" }), {
           status: 200,
-          headers: { "Content-Type": "application/json; charset=utf-8" },
+          statusText: "OK",
+          headers: { "Content-Type": "application/json" },
         })
       );
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "contentType", operator: "contains", value: "json" },
-        ],
-      };
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      const result = await connectedClient.client.exec({
+        url: "https://example.com/api",
+        method: "GET",
+        timeout: 5000,
+      });
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-    });
-  });
+      expect(result.statusCode).toBe(200);
+      expect(result.statusText).toBe("OK");
+      expect(result.contentType).toContain("application/json");
 
-  describe("header assertions", () => {
-    it("should pass header exists assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, {
-          status: 200,
-          headers: { "X-Request-Id": "abc123" },
-        })
-      );
-
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "header", headerName: "X-Request-Id", operator: "exists" },
-        ],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
+      connectedClient.close();
     });
 
-    it("should fail header exists assertion when missing", async () => {
+    it("should return 404 status for not found", async () => {
       spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, { status: 200 })
+        new Response(null, { status: 404, statusText: "Not Found" })
       );
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "header", headerName: "X-Missing", operator: "exists" },
-        ],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("unhealthy");
-      expect(result.message).toContain("X-Missing");
-    });
-
-    it("should pass header equals assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(null, {
-          status: 200,
-          headers: { "Cache-Control": "no-cache" },
-        })
-      );
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      const result = await connectedClient.client.exec({
+        url: "https://example.com/notfound",
+        method: "GET",
+        timeout: 5000,
+      });
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          {
-            field: "header",
-            headerName: "Cache-Control",
-            operator: "equals",
-            value: "no-cache",
-          },
-        ],
-      };
+      expect(result.statusCode).toBe(404);
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
+      connectedClient.close();
     });
-  });
 
-  describe("jsonPath assertions", () => {
-    it("should pass jsonPath equals assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ status: "UP" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        })
-      );
-
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          {
-            field: "jsonPath",
-            path: "$.status",
-            operator: "equals",
-            value: "UP",
-          },
-        ],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-    });
+    it("should send custom headers with request", async () => {
+      let capturedHeaders: Record<string, string> | undefined;
+      spyOn(globalThis, "fetch").mockImplementation((async (
+        _url: RequestInfo | URL,
+        options?: RequestInit
+      ) => {
+        capturedHeaders = options?.headers as Record<string, string>;
+        return new Response(null, { status: 200 });
+      }) as unknown as typeof fetch);
 
-    it("should fail jsonPath equals assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ status: "DOWN" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        })
-      );
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      await connectedClient.client.exec({
+        url: "https://example.com/api",
+        method: "GET",
+        headers: {
+          Authorization: "Bearer my-token",
+          "X-Custom-Header": "custom-value",
+        },
+        timeout: 5000,
+      });
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          {
-            field: "jsonPath",
-            path: "$.status",
-            operator: "equals",
-            value: "UP",
-          },
-        ],
-      };
+      expect(capturedHeaders).toBeDefined();
+      expect(capturedHeaders?.["Authorization"]).toBe("Bearer my-token");
+      expect(capturedHeaders?.["X-Custom-Header"]).toBe("custom-value");
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("unhealthy");
-      expect(result.message).toContain("Actual");
+      connectedClient.close();
     });
 
-    it("should pass jsonPath exists assertion", async () => {
+    it("should return JSON body as string", async () => {
+      const responseBody = { foo: "bar", count: 42 };
       spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ version: "1.0.0" }), {
+        new Response(JSON.stringify(responseBody), {
           status: 200,
           headers: { "Content-Type": "application/json" },
         })
       );
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "jsonPath", path: "$.version", operator: "exists" },
-        ],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-    });
-
-    it("should fail jsonPath exists assertion when path not found", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ other: "data" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        })
-      );
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      const result = await connectedClient.client.exec({
+        url: "https://example.com/api",
+        method: "GET",
+        timeout: 5000,
+      });
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "jsonPath", path: "$.missing", operator: "exists" },
-        ],
-      };
+      expect(result.body).toBe(JSON.stringify(responseBody));
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("unhealthy");
+      connectedClient.close();
     });
 
-    it("should pass jsonPath contains assertion", async () => {
+    it("should handle text body", async () => {
       spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ message: "Hello World" }), {
+        new Response("Hello World", {
           status: 200,
-          headers: { "Content-Type": "application/json" },
+          headers: { "Content-Type": "text/plain" },
         })
       );
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          {
-            field: "jsonPath",
-            path: "$.message",
-            operator: "contains",
-            value: "Hello",
-          },
-        ],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-    });
-
-    it("should pass jsonPath matches (regex) assertion", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ id: "abc-123" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        })
-      );
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      const result = await connectedClient.client.exec({
+        url: "https://example.com/api",
+        method: "GET",
+        timeout: 5000,
+      });
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          {
-            field: "jsonPath",
-            path: "$.id",
-            operator: "matches",
-            value: "^[a-z]{3}-\\d{3}$",
-          },
-        ],
-      };
+      expect(result.body).toBe("Hello World");
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
+      connectedClient.close();
     });
 
-    it("should fail when response is not JSON but jsonPath assertions exist", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response("Not JSON", {
-          status: 200,
-          headers: { "Content-Type": "text/plain" },
-        })
-      );
-
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [{ field: "jsonPath", path: "$.id", operator: "exists" }],
-      };
+    it("should send POST body", async () => {
+      let capturedBody: string | undefined;
+      spyOn(globalThis, "fetch").mockImplementation((async (
+        _url: RequestInfo | URL,
+        options?: RequestInit
+      ) => {
+        capturedBody = options?.body as string;
+        return new Response(null, { status: 201 });
+      }) as unknown as typeof fetch);
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("unhealthy");
-      expect(result.message).toContain("not valid JSON");
-    });
-  });
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      await connectedClient.client.exec({
+        url: "https://example.com/api",
+        method: "POST",
+        body: JSON.stringify({ name: "test" }),
+        timeout: 5000,
+      });
 
-  describe("combined assertions", () => {
-    it("should pass multiple assertion types", async () => {
-      spyOn(globalThis, "fetch").mockResolvedValue(
-        new Response(JSON.stringify({ healthy: true }), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json",
-            "X-Request-Id": "test-123",
-          },
-        })
-      );
+      expect(capturedBody).toBe('{"name":"test"}');
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        assertions: [
-          { field: "statusCode", operator: "equals", value: 200 },
-          { field: "responseTime", operator: "lessThan", value: 10000 },
-          { field: "contentType", operator: "contains", value: "json" },
-          { field: "header", headerName: "X-Request-Id", operator: "exists" },
-          {
-            field: "jsonPath",
-            path: "$.healthy",
-            operator: "equals",
-            value: "true",
-          },
-        ],
-      };
-
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-      expect(result.message).toContain("5 assertion");
+      connectedClient.close();
     });
-  });
 
-  describe("custom request options", () => {
-    it("should send custom headers with request", async () => {
-      let capturedHeaders: Record<string, string> | undefined;
+    it("should use correct HTTP method", async () => {
+      let capturedMethod: string | undefined;
       spyOn(globalThis, "fetch").mockImplementation((async (
         _url: RequestInfo | URL,
         options?: RequestInit
       ) => {
-        capturedHeaders = options?.headers as Record<string, string>;
+        capturedMethod = options?.method;
         return new Response(null, { status: 200 });
       }) as unknown as typeof fetch);
 
-      const config: HttpHealthCheckConfig = {
-        ...defaultConfig,
-        headers: [
-          { name: "Authorization", value: "Bearer my-token" },
-          { name: "X-Custom-Header", value: "custom-value" },
-        ],
-      };
+      const connectedClient = await strategy.createClient({ timeout: 5000 });
+      await connectedClient.client.exec({
+        url: "https://example.com/api",
+        method: "DELETE",
+        timeout: 5000,
+      });
 
-      const result = await strategy.execute(config);
-      expect(result.status).toBe("healthy");
-      expect(capturedHeaders).toBeDefined();
-      expect(capturedHeaders?.["Authorization"]).toBe("Bearer my-token");
-      expect(capturedHeaders?.["X-Custom-Header"]).toBe("custom-value");
+      expect(capturedMethod).toBe("DELETE");
+
+      connectedClient.close();
+    });
+  });
+
+  describe("aggregateResult", () => {
+    it("should count errors correctly", () => {
+      const runs = [
+        {
+          id: "1",
+          status: "unhealthy" as const,
+          latencyMs: 100,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {
+            error: "Connection refused",
+          },
+        },
+        {
+          id: "2",
+          status: "healthy" as const,
+          latencyMs: 150,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {},
+        },
+        {
+          id: "3",
+          status: "unhealthy" as const,
+          latencyMs: 120,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {
+            error: "Timeout",
+          },
+        },
+      ];
+
+      const aggregated = strategy.aggregateResult(runs);
+
+      expect(aggregated.errorCount).toBe(2);
+    });
+
+    it("should return zero errors when all runs succeed", () => {
+      const runs = [
+        {
+          id: "1",
+          status: "healthy" as const,
+          latencyMs: 100,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {},
+        },
+        {
+          id: "2",
+          status: "healthy" as const,
+          latencyMs: 150,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {},
+        },
+      ];
+
+      const aggregated = strategy.aggregateResult(runs);
+
+      expect(aggregated.errorCount).toBe(0);
     });
   });
 });