@oneuptime/common 11.5.3 → 11.5.5

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();
+  });
+});

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

@@ -0,0 +1,167 @@
+import {
+  ServiceRepoLinkSuggestion,
+  SuggestableRepository,
+  SuggestableService,
+  computeLinkSuggestions,
+} from "../../../Server/Utils/CodeRepository/ServiceRepoLinkSuggester";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The link suggester powers the service ↔ repository auto-mapping the AI fix
+ * pipeline depends on. It must be deterministic and explainable: exact
+ * normalized match (3) > containment (2) > token overlap (1), never
+ * suggesting services that already have a link, capped and sorted.
+ */
+
+function service(id: string, name: string): SuggestableService {
+  return { id, name };
+}
+
+function repo(
+  id: string,
+  repositoryName: string,
+  data?: { name?: string; organizationName?: string },
+): SuggestableRepository {
+  return {
+    id,
+    name: data?.name || repositoryName,
+    repositoryName,
+    organizationName: data?.organizationName || "acme",
+  };
+}
+
+describe("computeLinkSuggestions", () => {
+  test("exact match wins regardless of case and separators", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "Checkout Service")],
+        repositories: [repo("r1", "checkout-service")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(1);
+    expect(suggestions[0]!.score).toBe(3);
+    expect(suggestions[0]!.serviceId).toBe("s1");
+    expect(suggestions[0]!.codeRepositoryId).toBe("r1");
+    expect(suggestions[0]!.repositoryFullName).toBe("acme/checkout-service");
+  });
+
+  test("containment matches when one name contains the other", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "billing")],
+        repositories: [repo("r1", "acme-billing-monorepo")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(1);
+    expect(suggestions[0]!.score).toBe(2);
+  });
+
+  test("token overlap catches suffix/prefix variants like checkout-service vs checkout", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "payments-service-v2")],
+        repositories: [repo("r1", "payments-service")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(1);
+    expect(suggestions[0]!.score).toBeGreaterThanOrEqual(1);
+    expect(suggestions[0]!.reason).toBeTruthy();
+  });
+
+  test("unrelated names produce no suggestion", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "checkout")],
+        repositories: [repo("r1", "infra-terraform")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(0);
+  });
+
+  test("sharing only a generic short token is not enough", () => {
+    // {payments, service} vs {billing, service}: Jaccard 1/3 < 0.5.
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "payments-service")],
+        repositories: [repo("r1", "billing-service")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(0);
+  });
+
+  test("already-linked services are never suggested again", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "checkout"), service("s2", "billing")],
+        repositories: [repo("r1", "checkout"), repo("r2", "billing")],
+        existingLinks: [{ serviceId: "s1", codeRepositoryId: "r1" }],
+      });
+
+    expect(suggestions).toHaveLength(1);
+    expect(suggestions[0]!.serviceId).toBe("s2");
+  });
+
+  test("a repository can be suggested for several services (monorepo)", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [
+          service("s1", "acme-platform-api"),
+          service("s2", "acme-platform-worker"),
+        ],
+        repositories: [repo("r1", "acme-platform")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(2);
+  });
+
+  test("results are sorted by score descending", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [
+          service("s1", "checkout-service-v2"),
+          service("s2", "checkout"),
+        ],
+        repositories: [repo("r1", "checkout")],
+        existingLinks: [],
+      });
+
+    expect(suggestions.length).toBeGreaterThanOrEqual(2);
+    expect(suggestions[0]!.serviceId).toBe("s2"); // exact
+    expect(suggestions[0]!.score).toBe(3);
+    expect(suggestions[0]!.score).toBeGreaterThanOrEqual(suggestions[1]!.score);
+  });
+
+  test("camelCase display names tokenize across boundaries", () => {
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services: [service("s1", "CheckoutApi")],
+        repositories: [repo("r1", "checkout-api")],
+        existingLinks: [],
+      });
+
+    expect(suggestions).toHaveLength(1);
+    expect(suggestions[0]!.score).toBe(3); // normalized: checkoutapi === checkoutapi
+  });
+
+  test("caps output at 50 suggestions", () => {
+    const services: Array<SuggestableService> = [];
+    for (let i: number = 0; i < 80; i++) {
+      services.push(service(`s${i}`, `svc-${i}-common-name`));
+    }
+
+    const suggestions: Array<ServiceRepoLinkSuggestion> =
+      computeLinkSuggestions({
+        services,
+        repositories: [repo("r1", "common-name")],
+        existingLinks: [],
+      });
+
+    expect(suggestions.length).toBeLessThanOrEqual(50);
+  });
+});