@checkstack/healthcheck-backend 1.16.0 → 1.18.0

package/src/service-batching.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, mock } from "bun:test";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
+import { HealthCheckService } from "./service";
+
+/**
+ * Regression: `getSystemHealthStatus` batches its 1 (associations) + N
+ * (per-check run window) reads into ONE scoped transaction (see
+ * `withScopedTransaction`), so the whole read fan-out pays a single
+ * BEGIN/SET LOCAL/COMMIT and holds one connection instead of 1+N standalone
+ * scoped queries. This pins that the reads run inside `db.transaction(...)`
+ * (exactly once per call), independent of how many checks a system has.
+ */
+describe("HealthCheckService.getSystemHealthStatus - read batching", () => {
+  function createMockDb(configCount: number) {
+    const associations = Array.from({ length: configCount }, (_, i) => ({
+      configurationId: `config-${i}`,
+      configName: `Check ${i}`,
+      enabled: true,
+      paused: false,
+      stateThresholds: null,
+    }));
+    const assocWhere = mock(() => Promise.resolve(associations));
+    const assocInnerJoin = Object.assign(Promise.resolve([]), {
+      where: assocWhere,
+    });
+    const assocFrom = Object.assign(Promise.resolve([]), {
+      innerJoin: mock(() => assocInnerJoin),
+    });
+
+    // Each per-check run window returns one healthy run.
+    const healthyRun = [
+      { status: "healthy" as const, timestamp: new Date(), environmentId: null },
+    ];
+    const runsLimit = mock(() => Promise.resolve(healthyRun));
+    const runsOrderBy = mock(() => ({ limit: runsLimit }));
+    const runsWhere = mock(() => ({ orderBy: runsOrderBy, limit: runsLimit }));
+    const runsFrom = Object.assign(Promise.resolve(healthyRun), {
+      where: runsWhere,
+      orderBy: runsOrderBy,
+    });
+
+    let selectCallCount = 0;
+    const db = withTransactionMock({
+      select: mock(() => {
+        selectCallCount += 1;
+        if (selectCallCount === 1) return { from: mock(() => assocFrom) };
+        return { from: mock(() => runsFrom) };
+      }),
+      insert: mock(() => ({ values: mock(() => Promise.resolve()) })),
+      update: mock(() => ({
+        set: mock(() => ({ where: mock(() => Promise.resolve()) })),
+      })),
+      delete: mock(() => ({ where: mock(() => Promise.resolve()) })),
+      execute: mock(() => Promise.resolve()),
+    });
+    return db;
+  }
+
+  it("wraps the associations + per-check reads in exactly ONE transaction", async () => {
+    const mockDb = createMockDb(3);
+    const service = new HealthCheckService(
+      mockDb as never,
+      {} as never,
+      {} as never,
+    );
+
+    const result = await service.getSystemHealthStatus("system-1");
+
+    expect(result.status).toBe("healthy");
+    expect(result.checkStatuses).toHaveLength(3);
+    // One transaction covers all 1 + N reads (not one per query).
+    const transaction = (mockDb as unknown as { transaction: ReturnType<typeof mock> })
+      .transaction;
+    expect(transaction).toHaveBeenCalledTimes(1);
+    // 1 associations select + 3 per-check run selects = 4 selects, all inside
+    // the single transaction.
+    const select = (mockDb as unknown as { select: ReturnType<typeof mock> })
+      .select;
+    expect(select).toHaveBeenCalledTimes(4);
+  });
+
+  it("still opens exactly one transaction for a system with no checks", async () => {
+    const mockDb = createMockDb(0);
+    const service = new HealthCheckService(
+      mockDb as never,
+      {} as never,
+      {} as never,
+    );
+
+    const result = await service.getSystemHealthStatus("system-1");
+
+    expect(result.status).toBe("healthy");
+    expect(result.checkStatuses).toHaveLength(0);
+    const transaction = (mockDb as unknown as { transaction: ReturnType<typeof mock> })
+      .transaction;
+    expect(transaction).toHaveBeenCalledTimes(1);
+  });
+});

package/src/service-ordering.test.ts

@@ -64,6 +64,10 @@ describe("HealthCheckService data ordering", () => {
     const whereMock = mock(() => ({
       orderBy: orderByMock,
       limit: mock(createLimitResult),
+      // getSystemHealthOverview's "last successful run" query terminates in
+      // `.where(...).groupBy(environmentId)` (a max-per-env aggregate). These
+      // ordering tests don't assert last-success, so return no groups.
+      groupBy: mock(() => Promise.resolve([])),
     }));
     const innerJoinMock = mock(() => ({
       where: mock(() => Promise.resolve([...mockAssociations])),

package/src/service-paused-filter.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
 import { HealthCheckService } from "./service";
 
 /**
@@ -143,7 +144,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
 
       const mockDb = createMockDb();
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -222,7 +223,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -239,7 +240,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
 
       const mockDb = createMockDb();
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -265,7 +266,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -285,7 +286,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -340,7 +341,13 @@ describe("HealthCheckService - paused configuration filtering", () => {
 
       const runsLimit = mock(() => Promise.resolve(emptyRuns));
       const runsOrderBy = mock(() => ({ limit: runsLimit }));
-      const runsWhere = mock(() => ({ orderBy: runsOrderBy, limit: runsLimit }));
+      // getSystemHealthOverview also runs a `.where(...).groupBy(env)` aggregate
+      // for the last-successful-run stamp; return no groups here.
+      const runsWhere = mock(() => ({
+        orderBy: runsOrderBy,
+        limit: runsLimit,
+        groupBy: mock(() => Promise.resolve([])),
+      }));
       const runsFrom = Object.assign(Promise.resolve(emptyRuns), {
         where: runsWhere,
         orderBy: runsOrderBy,
@@ -370,7 +377,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );

package/src/service-rollup-worst-wins.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, mock } from "bun:test";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
 import { HealthCheckService } from "./service";
 import { evaluateHealthStatus } from "./state-evaluator";
 
@@ -65,7 +66,7 @@ describe("HealthCheckService - system rollup worst-wins across environments", ()
     });
 
     let selectCallCount = 0;
-    return {
+    return withTransactionMock({
       select: mock(() => {
         selectCallCount += 1;
         if (selectCallCount === 1) return { from: mock(() => assocFrom) };
@@ -81,7 +82,7 @@ describe("HealthCheckService - system rollup worst-wins across environments", ()
       update: mock(() => ({ set: mock(() => ({ where: mock(() => Promise.resolve()) })) })),
       delete: mock(() => ({ where: mock(() => Promise.resolve()) })),
       execute: mock(() => Promise.resolve()),
-    };
+    });
   }
 
   it("the rollup reports unhealthy when ONE env is permanently unhealthy, the other healthy", async () => {
@@ -101,6 +102,34 @@ describe("HealthCheckService - system rollup worst-wins across environments", ()
     expect(result.checkStatuses).toHaveLength(1);
     expect(result.checkStatuses[0].status).toBe("unhealthy");
     expect(result.checkStatuses[0].runsConsidered).toBe(pool.length);
+    // Fan-out accounting: two environment slices (prod + staging), one failing.
+    expect(result.checkStatuses[0].sliceCount).toBe(2);
+    expect(result.checkStatuses[0].failingSliceCount).toBe(1);
+  });
+
+  it("counts every failing environment slice for the fan-out denominator (3 envs, 2 failing)", () => {
+    // Three envs of one check: prod + eu unhealthy, staging healthy. The rollup
+    // is unhealthy, and the fan-out accounting must report sliceCount 3 with
+    // failingSliceCount 2 so the dashboard can render "2 of 3 checks failing".
+    const pool: {
+      status: "healthy" | "unhealthy";
+      timestamp: Date;
+      environmentId: string;
+    }[] = [];
+    for (let i = 0; i < 5; i++) {
+      pool.push({ status: "unhealthy", timestamp: new Date(2025, 0, 1, 0, 0, i), environmentId: "prod" });
+      pool.push({ status: "unhealthy", timestamp: new Date(2025, 0, 1, 0, 0, i, 250), environmentId: "eu" });
+      pool.push({ status: "healthy", timestamp: new Date(2025, 0, 1, 0, 0, i, 500), environmentId: "staging" });
+    }
+    const runsDesc = pool.toReversed();
+    const mockDb = createMockDb(runsDesc as never);
+    const service = new HealthCheckService(mockDb as never, {} as never, {} as never);
+
+    return service.getSystemHealthStatus("system-1").then((result) => {
+      expect(result.status).toBe("unhealthy");
+      expect(result.checkStatuses[0].sliceCount).toBe(3);
+      expect(result.checkStatuses[0].failingSliceCount).toBe(2);
+    });
   });
 
   it("flattening the same mixed pool through the evaluator (the pre-fix derivation) would have returned `healthy`", async () => {
@@ -180,7 +209,7 @@ describe("HealthCheckService - system rollup worst-wins across environments", ()
     });
 
     let selectCallCount = 0;
-    const mockDb = {
+    const mockDb = withTransactionMock({
       select: mock(() => {
         selectCallCount += 1;
         if (selectCallCount === 1) return { from: mock(() => assocFrom) };
@@ -196,10 +225,14 @@ describe("HealthCheckService - system rollup worst-wins across environments", ()
       update: mock(() => ({ set: mock(() => ({ where: mock(() => Promise.resolve()) })) })),
       delete: mock(() => ({ where: mock(() => Promise.resolve()) })),
       execute: mock(() => Promise.resolve()),
-    };
+    });
 
     const service = new HealthCheckService(mockDb as never, {} as never, {} as never);
     const result = await service.getSystemHealthStatus("system-1", "prod");
     expect(result.status).toBe("unhealthy");
+    // A single-env evaluation is always one slice; failing here since prod is
+    // unhealthy.
+    expect(result.checkStatuses[0].sliceCount).toBe(1);
+    expect(result.checkStatuses[0].failingSliceCount).toBe(1);
   });
 });