@oneuptime/common 11.5.4 → 11.5.6

package/Tests/Server/Utils/GitHubCheckRunsConclusion.test.ts

@@ -0,0 +1,100 @@
+import GitHubUtil, {
+  GitHubCheckRunsSummary,
+} from "../../../Server/Utils/CodeRepository/GitHub/GitHub";
+import FixPullRequestCiStatus from "../../../Types/AI/FixPullRequestCiStatus";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Check-run counting for the Tier 1 CI verification sweep. The G9-critical
+ * edges: an empty check-run list is NoCiConfigured (a repo without CI
+ * verifies NOTHING), and any conclusion we do not positively recognize as
+ * passing counts as failed — unknown must fail toward unverified, never
+ * toward verified.
+ */
+
+describe("GitHubUtil.summarizeCheckRuns", () => {
+  test("no check runs at all means NoCiConfigured", () => {
+    const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([]);
+
+    expect(summary).toEqual({
+      total: 0,
+      completed: 0,
+      failed: 0,
+      pending: 0,
+      conclusion: FixPullRequestCiStatus.NoCiConfigured,
+    });
+  });
+
+  test("queued and in_progress runs count as pending and roll up to Pending", () => {
+    const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([
+      { status: "queued", conclusion: null },
+      { status: "in_progress", conclusion: null },
+      { status: "completed", conclusion: "success" },
+    ]);
+
+    expect(summary.total).toBe(3);
+    expect(summary.pending).toBe(2);
+    expect(summary.completed).toBe(1);
+    expect(summary.failed).toBe(0);
+    expect(summary.conclusion).toBe(FixPullRequestCiStatus.Pending);
+  });
+
+  test("a failure while other checks still run stays Pending — conclusions are final only", () => {
+    const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([
+      { status: "completed", conclusion: "failure" },
+      { status: "in_progress", conclusion: null },
+    ]);
+
+    expect(summary.failed).toBe(1);
+    expect(summary.pending).toBe(1);
+    expect(summary.conclusion).toBe(FixPullRequestCiStatus.Pending);
+  });
+
+  test("one failed run among completed runs rolls up to Red", () => {
+    const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([
+      { status: "completed", conclusion: "success" },
+      { status: "completed", conclusion: "failure" },
+      { status: "completed", conclusion: "success" },
+    ]);
+
+    expect(summary.total).toBe(3);
+    expect(summary.failed).toBe(1);
+    expect(summary.conclusion).toBe(FixPullRequestCiStatus.Red);
+  });
+
+  test("success, neutral and skipped all count as passing — rolls up to Green", () => {
+    const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([
+      { status: "completed", conclusion: "success" },
+      { status: "completed", conclusion: "neutral" },
+      { status: "completed", conclusion: "skipped" },
+    ]);
+
+    expect(summary.failed).toBe(0);
+    expect(summary.conclusion).toBe(FixPullRequestCiStatus.Green);
+  });
+
+  test("timed_out, cancelled, action_required and stale count as failed", () => {
+    for (const conclusion of [
+      "timed_out",
+      "cancelled",
+      "action_required",
+      "stale",
+    ]) {
+      const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([
+        { status: "completed", conclusion },
+      ]);
+
+      expect(summary.failed).toBe(1);
+      expect(summary.conclusion).toBe(FixPullRequestCiStatus.Red);
+    }
+  });
+
+  test("an unknown future conclusion fails toward unverified, never verified (G9)", () => {
+    const summary: GitHubCheckRunsSummary = GitHubUtil.summarizeCheckRuns([
+      { status: "completed", conclusion: "some_future_conclusion" },
+    ]);
+
+    expect(summary.failed).toBe(1);
+    expect(summary.conclusion).toBe(FixPullRequestCiStatus.Red);
+  });
+});

package/Tests/Server/Utils/GitHubPullRequestStateMapping.test.ts

@@ -0,0 +1,50 @@
+import GitHubUtil from "../../../Server/Utils/CodeRepository/GitHub/GitHub";
+import PullRequestState from "../../../Types/CodeRepository/PullRequestState";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * State mapping for the AI-agent PR outcome sync (gate G11 instrumentation).
+ * GitHub reports merged PRs as state "closed" with merged_at set — the
+ * mapping must check merged first, or every merge counts as a plain close
+ * and the fix-acceptance baseline undercounts forever.
+ */
+
+describe("GitHubUtil.mapGitHubPullRequestToState", () => {
+  test("merged_at set means Merged even though state is closed", () => {
+    expect(
+      GitHubUtil.mapGitHubPullRequestToState({
+        state: "closed",
+        merged_at: "2026-07-13T10:00:00Z",
+      }),
+    ).toBe(PullRequestState.Merged);
+  });
+
+  test("merged boolean true means Merged", () => {
+    expect(
+      GitHubUtil.mapGitHubPullRequestToState({
+        state: "closed",
+        merged: true,
+        merged_at: null,
+      }),
+    ).toBe(PullRequestState.Merged);
+  });
+
+  test("closed without merged_at means Closed (rejected fix)", () => {
+    expect(
+      GitHubUtil.mapGitHubPullRequestToState({
+        state: "closed",
+        merged_at: null,
+        merged: false,
+      }),
+    ).toBe(PullRequestState.Closed);
+  });
+
+  test("open PR stays Open", () => {
+    expect(
+      GitHubUtil.mapGitHubPullRequestToState({
+        state: "open",
+        merged_at: null,
+      }),
+    ).toBe(PullRequestState.Open);
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/SqlMonitorCriteria.test.ts

@@ -0,0 +1,266 @@
+import SqlMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/SqlMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import SqlMonitorResponse from "../../../../../Types/Monitor/SqlMonitor/SqlMonitorResponse";
+import ProbeMonitorResponse from "../../../../../Types/Probe/ProbeMonitorResponse";
+import ObjectID from "../../../../../Types/ObjectID";
+import { JSONObject } from "../../../../../Types/JSON";
+
+function buildDataToProcess(input: {
+  isOnline?: boolean;
+  responseTimeInMs?: number;
+  rowCount?: number | null;
+  scalarValue?: string | number | boolean | null;
+  firstRow?: JSONObject | null;
+  queryError?: string | null;
+}): ProbeMonitorResponse {
+  const sqlResponse: SqlMonitorResponse = {
+    isOnline: input.isOnline ?? true,
+    responseTimeInMs: input.responseTimeInMs ?? 42,
+    failureCause: "",
+    rowCount: input.rowCount === undefined ? 1 : input.rowCount,
+    scalarValue: input.scalarValue === undefined ? null : input.scalarValue,
+    firstRow: input.firstRow === undefined ? null : input.firstRow,
+    queryError: input.queryError === undefined ? null : input.queryError,
+  };
+
+  return {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    monitorStepId: ObjectID.generate(),
+    probeId: ObjectID.generate(),
+    failureCause: "",
+    isOnline: input.isOnline ?? true,
+    responseTimeInMs: input.responseTimeInMs ?? 42,
+    sqlQueryMonitorResponse: sqlResponse,
+    monitoredAt: new Date(),
+  };
+}
+
+async function evaluate(
+  dataToProcess: ProbeMonitorResponse,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return SqlMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess,
+    criteriaFilter,
+  });
+}
+
+describe("SqlMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  describe("SqlIsOnline", () => {
+    test("online + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true }),
+        {
+          checkOn: CheckOn.SqlIsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("online + False → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true }),
+        {
+          checkOn: CheckOn.SqlIsOnline,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+      expect(result).toBeNull();
+    });
+
+    test("offline + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: false }),
+        {
+          checkOn: CheckOn.SqlIsOnline,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+  });
+
+  describe("SqlQueryRowCount", () => {
+    test("rowCount 120 > 50 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ rowCount: 120 }),
+        {
+          checkOn: CheckOn.SqlQueryRowCount,
+          filterType: FilterType.GreaterThan,
+          value: "50",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("rowCount 10 > 50 → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ rowCount: 10 }),
+        {
+          checkOn: CheckOn.SqlQueryRowCount,
+          filterType: FilterType.GreaterThan,
+          value: "50",
+        },
+      );
+      expect(result).toBeNull();
+    });
+
+    test("rowCount 0 EqualTo 0 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ rowCount: 0 }),
+        {
+          checkOn: CheckOn.SqlQueryRowCount,
+          filterType: FilterType.EqualTo,
+          value: "0",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("rowCount null → not met (no data)", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ rowCount: null }),
+        {
+          checkOn: CheckOn.SqlQueryRowCount,
+          filterType: FilterType.GreaterThan,
+          value: "50",
+        },
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("SqlQueryScalarValue", () => {
+    test("numeric string scalar '150' > 50 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ scalarValue: "150" }),
+        {
+          checkOn: CheckOn.SqlQueryScalarValue,
+          filterType: FilterType.GreaterThan,
+          value: "50",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("numeric scalar 3 EqualTo 3 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ scalarValue: 3 }),
+        {
+          checkOn: CheckOn.SqlQueryScalarValue,
+          filterType: FilterType.EqualTo,
+          value: "3",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("string scalar 'CANCELLED' Contains 'CANCEL' → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ scalarValue: "CANCELLED" }),
+        {
+          checkOn: CheckOn.SqlQueryScalarValue,
+          filterType: FilterType.Contains,
+          value: "CANCEL",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("null scalar → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ scalarValue: null }),
+        {
+          checkOn: CheckOn.SqlQueryScalarValue,
+          filterType: FilterType.GreaterThan,
+          value: "50",
+        },
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("SqlQueryExecutionTime", () => {
+    test("executionTime 8000 > 5000 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ responseTimeInMs: 8000 }),
+        {
+          checkOn: CheckOn.SqlQueryExecutionTime,
+          filterType: FilterType.GreaterThan,
+          value: "5000",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("executionTime 100 > 5000 → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ responseTimeInMs: 100 }),
+        {
+          checkOn: CheckOn.SqlQueryExecutionTime,
+          filterType: FilterType.GreaterThan,
+          value: "5000",
+        },
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("SqlQueryError", () => {
+    test("error present + IsNotEmpty → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ queryError: "connection refused" }),
+        {
+          checkOn: CheckOn.SqlQueryError,
+          filterType: FilterType.IsNotEmpty,
+          value: undefined,
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("error null + IsEmpty → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ queryError: null }),
+        {
+          checkOn: CheckOn.SqlQueryError,
+          filterType: FilterType.IsEmpty,
+          value: undefined,
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+
+    test("error 'timeout' Contains 'timeout' → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          queryError: "canceling statement due to statement timeout",
+        }),
+        {
+          checkOn: CheckOn.SqlQueryError,
+          filterType: FilterType.Contains,
+          value: "timeout",
+        },
+      );
+      expect(result).toBeTruthy();
+    });
+  });
+
+  test("unrelated checkOn → null", async () => {
+    const result: string | null = await evaluate(buildDataToProcess({}), {
+      checkOn: CheckOn.ResponseBody,
+      filterType: FilterType.Contains,
+      value: "x",
+    });
+    expect(result).toBeNull();
+  });
+});