@oneuptime/common 11.5.4 → 11.5.6

package/Tests/Types/AI/AIChatPermissionMode.test.ts

@@ -0,0 +1,112 @@
+import AIChatPermissionMode, {
+  AIChatPermissionModeHelper,
+  AIChatPermissionModeOption,
+} from "../../../Types/AI/AIChatPermissionMode";
+
+describe("AIChatPermissionModeHelper", () => {
+  describe("getDefault", () => {
+    test("defaults to AskForApproval", () => {
+      expect(AIChatPermissionModeHelper.getDefault()).toBe(
+        AIChatPermissionMode.AskForApproval,
+      );
+    });
+
+    test("never defaults to the permissive AutoRun mode", () => {
+      // This mode gates every MUTATING tool, so the default must be the safe one.
+      expect(AIChatPermissionModeHelper.getDefault()).not.toBe(
+        AIChatPermissionMode.AutoRun,
+      );
+    });
+  });
+
+  describe("isValid", () => {
+    test("accepts every permission mode", () => {
+      for (const mode of Object.values(AIChatPermissionMode)) {
+        expect(AIChatPermissionModeHelper.isValid(mode)).toBe(true);
+      }
+    });
+
+    test.each([
+      undefined,
+      "",
+      "autorun", // wrong case
+      "AutoRun ", // trailing whitespace
+      "NotAMode",
+    ])("rejects %p", (value: string | undefined) => {
+      expect(AIChatPermissionModeHelper.isValid(value)).toBe(false);
+    });
+  });
+
+  describe("parse", () => {
+    test("round-trips every valid permission mode", () => {
+      for (const mode of Object.values(AIChatPermissionMode)) {
+        expect(AIChatPermissionModeHelper.parse(mode)).toBe(mode);
+      }
+    });
+
+    test.each([undefined, "", "NotAMode", "autorun"])(
+      "falls back to the default for the unrecognized value %p",
+      (value: string | undefined) => {
+        expect(AIChatPermissionModeHelper.parse(value)).toBe(
+          AIChatPermissionModeHelper.getDefault(),
+        );
+      },
+    );
+
+    test("never fails open to AutoRun for unrecognized input", () => {
+      /*
+       * A malformed or missing persisted value must not silently grant the
+       * agent permission to run mutating tools without approval.
+       */
+      const unrecognized: Array<string | undefined> = [
+        undefined,
+        "",
+        "autorun",
+        "AUTO_RUN",
+        "NotAMode",
+      ];
+
+      for (const value of unrecognized) {
+        expect(AIChatPermissionModeHelper.parse(value)).not.toBe(
+          AIChatPermissionMode.AutoRun,
+        );
+      }
+    });
+  });
+
+  describe("getOptions", () => {
+    test("exposes one option per permission mode, exactly once", () => {
+      const options: Array<AIChatPermissionModeOption> =
+        AIChatPermissionModeHelper.getOptions();
+
+      const values: Array<AIChatPermissionMode> = options.map(
+        (o: AIChatPermissionModeOption): AIChatPermissionMode => {
+          return o.value;
+        },
+      );
+
+      expect(values.length).toBe(Object.values(AIChatPermissionMode).length);
+      expect(new Set(values).size).toBe(values.length); // no duplicates
+
+      for (const mode of Object.values(AIChatPermissionMode)) {
+        expect(values).toContain(mode);
+      }
+    });
+
+    test("every option has a title and a description", () => {
+      for (const option of AIChatPermissionModeHelper.getOptions()) {
+        expect(option.title.length).toBeGreaterThan(0);
+        expect(option.description.length).toBeGreaterThan(0);
+      }
+    });
+
+    test("every offered option is a parseable mode", () => {
+      for (const option of AIChatPermissionModeHelper.getOptions()) {
+        expect(AIChatPermissionModeHelper.isValid(option.value)).toBe(true);
+        expect(AIChatPermissionModeHelper.parse(option.value)).toBe(
+          option.value,
+        );
+      }
+    });
+  });
+});

package/Tests/Types/AI/CodeFixTaskType.test.ts

@@ -0,0 +1,152 @@
+import CodeFixTaskType, {
+  CodeFixContextKind,
+  CodeFixTaskTypeHelper,
+} from "../../../Types/AI/CodeFixTaskType";
+
+describe("CodeFixTaskTypeHelper", () => {
+  describe("getUserTriggerableTaskTypes", () => {
+    test("only exception-page recipes are user triggerable", () => {
+      expect(CodeFixTaskTypeHelper.getUserTriggerableTaskTypes()).toEqual([
+        CodeFixTaskType.FixException,
+        CodeFixTaskType.WriteRegressionTest,
+      ]);
+    });
+  });
+
+  describe("isUserTriggerable", () => {
+    test.each([
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.WriteRegressionTest,
+    ])("returns true for %s", (taskType: CodeFixTaskType) => {
+      expect(CodeFixTaskTypeHelper.isUserTriggerable(taskType)).toBe(true);
+    });
+
+    test.each([
+      CodeFixTaskType.ImproveInstrumentation,
+      CodeFixTaskType.FixPerformance,
+      CodeFixTaskType.FixFromIncident,
+    ])(
+      "returns false for %s (not exception-page triggered)",
+      (taskType: CodeFixTaskType) => {
+        expect(CodeFixTaskTypeHelper.isUserTriggerable(taskType)).toBe(false);
+      },
+    );
+  });
+
+  describe("getContextKind", () => {
+    test.each([
+      [CodeFixTaskType.FixException, CodeFixContextKind.TelemetryException],
+      [
+        CodeFixTaskType.WriteRegressionTest,
+        CodeFixContextKind.TelemetryException,
+      ],
+      [
+        CodeFixTaskType.ImproveInstrumentation,
+        CodeFixContextKind.IncidentOrAlertSubject,
+      ],
+      [
+        CodeFixTaskType.FixFromIncident,
+        CodeFixContextKind.IncidentOrAlertSubject,
+      ],
+      [CodeFixTaskType.FixPerformance, CodeFixContextKind.TaskContext],
+    ])(
+      "maps %s to %s",
+      (taskType: CodeFixTaskType, expected: CodeFixContextKind) => {
+        expect(CodeFixTaskTypeHelper.getContextKind(taskType)).toBe(expected);
+      },
+    );
+
+    test("every task type resolves to a known context kind", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(Object.values(CodeFixContextKind)).toContain(
+          CodeFixTaskTypeHelper.getContextKind(taskType),
+        );
+      }
+    });
+  });
+
+  describe("requiresTelemetryException", () => {
+    test.each([
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.WriteRegressionTest,
+    ])("returns true for %s", (taskType: CodeFixTaskType) => {
+      expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+        true,
+      );
+    });
+
+    test.each([
+      CodeFixTaskType.ImproveInstrumentation,
+      CodeFixTaskType.FixPerformance,
+      CodeFixTaskType.FixFromIncident,
+    ])("returns false for %s", (taskType: CodeFixTaskType) => {
+      expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+        false,
+      );
+    });
+
+    test("stays in sync with getContextKind", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+          CodeFixTaskTypeHelper.getContextKind(taskType) ===
+            CodeFixContextKind.TelemetryException,
+        );
+      }
+    });
+
+    test("every user-triggerable recipe is exception-based", () => {
+      for (const taskType of CodeFixTaskTypeHelper.getUserTriggerableTaskTypes()) {
+        expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+          true,
+        );
+      }
+    });
+  });
+
+  describe("isValidTaskType", () => {
+    test("accepts every enum value", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(CodeFixTaskTypeHelper.isValidTaskType(taskType)).toBe(true);
+      }
+    });
+
+    test.each(["", "NotATaskType", "fixexception"])(
+      "rejects %p",
+      (value: string) => {
+        expect(CodeFixTaskTypeHelper.isValidTaskType(value)).toBe(false);
+      },
+    );
+  });
+
+  describe("fromDatabaseValue", () => {
+    test("normalizes a legacy null/undefined column to FixException", () => {
+      expect(CodeFixTaskTypeHelper.fromDatabaseValue(null)).toBe(
+        CodeFixTaskType.FixException,
+      );
+      expect(CodeFixTaskTypeHelper.fromDatabaseValue(undefined)).toBe(
+        CodeFixTaskType.FixException,
+      );
+    });
+
+    test.each(["", "NotATaskType"])(
+      "falls back to FixException for the unrecognized value %p",
+      (value: string) => {
+        expect(CodeFixTaskTypeHelper.fromDatabaseValue(value)).toBe(
+          CodeFixTaskType.FixException,
+        );
+      },
+    );
+
+    test("round-trips every valid task type", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(CodeFixTaskTypeHelper.fromDatabaseValue(taskType)).toBe(
+          taskType,
+        );
+        // Also accepts the raw wire string.
+        expect(
+          CodeFixTaskTypeHelper.fromDatabaseValue(taskType.toString()),
+        ).toBe(taskType);
+      }
+    });
+  });
+});

package/Tests/Types/AI/FixPullRequestCiStatus.test.ts

@@ -0,0 +1,181 @@
+import FixPullRequestCiStatus, {
+  FixPullRequestCiStatusHelper,
+} from "../../../Types/AI/FixPullRequestCiStatus";
+import CodeFixTaskType, {
+  CodeFixTaskTypeHelper,
+} from "../../../Types/AI/CodeFixTaskType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * B4 Tier 1: the CI-conclusion roll-up and the SHOULD-FAIL rule. These pin
+ * the honesty contract: a repo without CI is NoCiConfigured (unverified,
+ * never verified — G9), conclusions are only final once every check
+ * completed, and a RED conclusion on a should-fail regression-test PR is the
+ * desired signal.
+ */
+
+describe("FixPullRequestCiStatusHelper.rollUpConclusion", () => {
+  test("zero check runs means NoCiConfigured — never Green", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 0,
+        completed: 0,
+        failed: 0,
+        pending: 0,
+      }),
+    ).toBe(FixPullRequestCiStatus.NoCiConfigured);
+  });
+
+  test("any pending run means Pending", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 3,
+        completed: 2,
+        failed: 0,
+        pending: 1,
+      }),
+    ).toBe(FixPullRequestCiStatus.Pending);
+  });
+
+  test("pending wins over failed — a conclusion is only final once every check completed", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 3,
+        completed: 1,
+        failed: 1,
+        pending: 2,
+      }),
+    ).toBe(FixPullRequestCiStatus.Pending);
+  });
+
+  test("any failed run (all completed) means Red", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 4,
+        completed: 4,
+        failed: 1,
+        pending: 0,
+      }),
+    ).toBe(FixPullRequestCiStatus.Red);
+  });
+
+  test("all completed and none failed means Green", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 4,
+        completed: 4,
+        failed: 0,
+        pending: 0,
+      }),
+    ).toBe(FixPullRequestCiStatus.Green);
+  });
+});
+
+describe("FixPullRequestCiStatusHelper.applyTaskType (the SHOULD-FAIL rule)", () => {
+  test("WriteRegressionTest + Red maps to ExpectedFailureObserved", () => {
+    expect(
+      FixPullRequestCiStatusHelper.applyTaskType({
+        conclusion: FixPullRequestCiStatus.Red,
+        taskType: CodeFixTaskType.WriteRegressionTest,
+      }),
+    ).toBe(FixPullRequestCiStatus.ExpectedFailureObserved);
+  });
+
+  test("fix-type recipes keep Red as Red", () => {
+    for (const taskType of [
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.ImproveInstrumentation,
+      CodeFixTaskType.FixPerformance,
+      CodeFixTaskType.FixFromIncident,
+    ]) {
+      expect(
+        FixPullRequestCiStatusHelper.applyTaskType({
+          conclusion: FixPullRequestCiStatus.Red,
+          taskType,
+        }),
+      ).toBe(FixPullRequestCiStatus.Red);
+    }
+  });
+
+  test("legacy null task type normalizes to FixException, so Red stays Red", () => {
+    expect(
+      FixPullRequestCiStatusHelper.applyTaskType({
+        conclusion: FixPullRequestCiStatus.Red,
+        taskType: CodeFixTaskTypeHelper.fromDatabaseValue(null),
+      }),
+    ).toBe(FixPullRequestCiStatus.Red);
+  });
+
+  test("non-Red conclusions pass through unchanged even for WriteRegressionTest", () => {
+    for (const conclusion of [
+      FixPullRequestCiStatus.Green,
+      FixPullRequestCiStatus.Pending,
+      FixPullRequestCiStatus.NoCiConfigured,
+    ]) {
+      expect(
+        FixPullRequestCiStatusHelper.applyTaskType({
+          conclusion,
+          taskType: CodeFixTaskType.WriteRegressionTest,
+        }),
+      ).toBe(conclusion);
+    }
+  });
+});
+
+describe("FixPullRequestCiStatusHelper.isVerified (the G9 predicate)", () => {
+  test("only Green and ExpectedFailureObserved are verified", () => {
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(FixPullRequestCiStatus.Green),
+    ).toBe(true);
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(
+        FixPullRequestCiStatus.ExpectedFailureObserved,
+      ),
+    ).toBe(true);
+  });
+
+  test("absence of CI is NEVER verified — nor is pending, red, or unpolled null", () => {
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(
+        FixPullRequestCiStatus.NoCiConfigured,
+      ),
+    ).toBe(false);
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(FixPullRequestCiStatus.Pending),
+    ).toBe(false);
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(FixPullRequestCiStatus.Red),
+    ).toBe(false);
+    expect(FixPullRequestCiStatusHelper.isVerified(null)).toBe(false);
+    expect(FixPullRequestCiStatusHelper.isVerified(undefined)).toBe(false);
+  });
+});
+
+describe("FixPullRequestCiStatusHelper.describeForProgressLog", () => {
+  test("green line carries the check counts", () => {
+    expect(
+      FixPullRequestCiStatusHelper.describeForProgressLog({
+        ciStatus: FixPullRequestCiStatus.Green,
+        counts: { total: 4, completed: 4, failed: 0, pending: 0 },
+      }),
+    ).toBe("CI on the fix PR: Green (4/4 checks passed)");
+  });
+
+  test("expected-failure line says the failure is the desired signal", () => {
+    expect(
+      FixPullRequestCiStatusHelper.describeForProgressLog({
+        ciStatus: FixPullRequestCiStatus.ExpectedFailureObserved,
+        counts: { total: 3, completed: 3, failed: 1, pending: 0 },
+      }),
+    ).toContain("expected failure observed");
+  });
+
+  test("no-CI line says the fix is unverified", () => {
+    expect(
+      FixPullRequestCiStatusHelper.describeForProgressLog({
+        ciStatus: FixPullRequestCiStatus.NoCiConfigured,
+        counts: { total: 0, completed: 0, failed: 0, pending: 0 },
+      }),
+    ).toContain("unverified");
+  });
+});

package/Tests/Types/Monitor/MonitorStepSqlMonitor.test.ts

@@ -0,0 +1,110 @@
+import MonitorStepSqlMonitor, {
+  MonitorStepSqlMonitorUtil,
+  clampSqlConnectionTimeoutInMs,
+  clampSqlMaxRows,
+  clampSqlStatementTimeoutInMs,
+  DEFAULT_SQL_CONNECTION_TIMEOUT_IN_MS,
+  DEFAULT_SQL_MAX_ROWS,
+  DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+  MAX_SQL_CONNECTION_TIMEOUT_IN_MS,
+  MAX_SQL_MAX_ROWS,
+  MAX_SQL_STATEMENT_TIMEOUT_IN_MS,
+} from "../../../Types/Monitor/MonitorStepSqlMonitor";
+import SqlDatabaseType from "../../../Types/Monitor/SqlDatabaseType";
+import { JSONObject } from "../../../Types/JSON";
+
+describe("MonitorStepSqlMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns a PostgreSQL default with safe caps", () => {
+      const def: MonitorStepSqlMonitor = MonitorStepSqlMonitorUtil.getDefault();
+      expect(def.databaseType).toBe(SqlDatabaseType.PostgreSQL);
+      expect(def.port).toBe(5432);
+      expect(def.useSsl).toBe(false);
+      expect(def.rejectUnauthorizedSsl).toBe(true);
+      expect(def.statementTimeoutInMs).toBe(
+        DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(def.connectionTimeoutInMs).toBe(
+        DEFAULT_SQL_CONNECTION_TIMEOUT_IN_MS,
+      );
+      expect(def.maxRows).toBe(DEFAULT_SQL_MAX_ROWS);
+    });
+  });
+
+  describe("clamps", () => {
+    test("statement timeout is clamped to the max and defaulted when invalid", () => {
+      expect(clampSqlStatementTimeoutInMs(999999)).toBe(
+        MAX_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlStatementTimeoutInMs(0)).toBe(
+        DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlStatementTimeoutInMs(-5)).toBe(
+        DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlStatementTimeoutInMs(8000)).toBe(8000);
+    });
+
+    test("connection timeout is clamped to the max", () => {
+      expect(clampSqlConnectionTimeoutInMs(999999)).toBe(
+        MAX_SQL_CONNECTION_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlConnectionTimeoutInMs(5000)).toBe(5000);
+    });
+
+    test("maxRows is clamped, floored, and defaulted", () => {
+      expect(clampSqlMaxRows(999999)).toBe(MAX_SQL_MAX_ROWS);
+      expect(clampSqlMaxRows(0)).toBe(DEFAULT_SQL_MAX_ROWS);
+      expect(clampSqlMaxRows(12.9)).toBe(12);
+    });
+  });
+
+  describe("fromJSON/toJSON round-trip", () => {
+    test("preserves values and clamps out-of-range inputs", () => {
+      const json: JSONObject = {
+        databaseType: SqlDatabaseType.PostgreSQL,
+        host: "db.internal",
+        port: 5433,
+        databaseName: "orders",
+        username: "readonly",
+        password: "{{monitorSecrets.dbPass}}",
+        useSsl: true,
+        rejectUnauthorizedSsl: false,
+        query: "SELECT COUNT(*) FROM orders",
+        connectionTimeoutInMs: 999999,
+        statementTimeoutInMs: 20000,
+        maxRows: 999999,
+      };
+
+      const parsed: MonitorStepSqlMonitor =
+        MonitorStepSqlMonitorUtil.fromJSON(json);
+
+      expect(parsed.host).toBe("db.internal");
+      expect(parsed.port).toBe(5433);
+      expect(parsed.password).toBe("{{monitorSecrets.dbPass}}");
+      expect(parsed.useSsl).toBe(true);
+      expect(parsed.rejectUnauthorizedSsl).toBe(false);
+      // clamped
+      expect(parsed.connectionTimeoutInMs).toBe(
+        MAX_SQL_CONNECTION_TIMEOUT_IN_MS,
+      );
+      expect(parsed.maxRows).toBe(MAX_SQL_MAX_ROWS);
+
+      const roundTripped: MonitorStepSqlMonitor =
+        MonitorStepSqlMonitorUtil.fromJSON(
+          MonitorStepSqlMonitorUtil.toJSON(parsed),
+        );
+      expect(roundTripped).toEqual(parsed);
+    });
+
+    test("defaults rejectUnauthorizedSsl to true when absent", () => {
+      const parsed: MonitorStepSqlMonitor = MonitorStepSqlMonitorUtil.fromJSON({
+        host: "h",
+        databaseName: "d",
+        query: "SELECT 1",
+      });
+      expect(parsed.rejectUnauthorizedSsl).toBe(true);
+      expect(parsed.useSsl).toBe(false);
+    });
+  });
+});

package/Tests/Types/Monitor/SqlDatabaseType.test.ts

@@ -0,0 +1,55 @@
+import SqlDatabaseType, {
+  SqlDatabaseTypeUtil,
+} from "../../../Types/Monitor/SqlDatabaseType";
+
+describe("SqlDatabaseTypeUtil", () => {
+  describe("getSupportedDatabaseTypes", () => {
+    test("supports PostgreSQL, MySQL, and Microsoft SQL Server", () => {
+      const supported: Array<SqlDatabaseType> =
+        SqlDatabaseTypeUtil.getSupportedDatabaseTypes();
+
+      expect(supported).toContain(SqlDatabaseType.PostgreSQL);
+      expect(supported).toContain(SqlDatabaseType.MySQL);
+      expect(supported).toContain(SqlDatabaseType.MicrosoftSqlServer);
+      expect(supported).toHaveLength(3);
+    });
+  });
+
+  describe("isSupported", () => {
+    test("returns true for every enum member (all engines ship an executor)", () => {
+      expect(SqlDatabaseTypeUtil.isSupported(SqlDatabaseType.PostgreSQL)).toBe(
+        true,
+      );
+      expect(SqlDatabaseTypeUtil.isSupported(SqlDatabaseType.MySQL)).toBe(true);
+      expect(
+        SqlDatabaseTypeUtil.isSupported(SqlDatabaseType.MicrosoftSqlServer),
+      ).toBe(true);
+    });
+
+    test("returns false for an engine that is not in the enum", () => {
+      expect(
+        SqlDatabaseTypeUtil.isSupported("OracleDatabase" as SqlDatabaseType),
+      ).toBe(false);
+    });
+  });
+
+  describe("getDefaultPort", () => {
+    test("returns the well-known default port per engine", () => {
+      expect(
+        SqlDatabaseTypeUtil.getDefaultPort(SqlDatabaseType.PostgreSQL),
+      ).toBe(5432);
+      expect(SqlDatabaseTypeUtil.getDefaultPort(SqlDatabaseType.MySQL)).toBe(
+        3306,
+      );
+      expect(
+        SqlDatabaseTypeUtil.getDefaultPort(SqlDatabaseType.MicrosoftSqlServer),
+      ).toBe(1433);
+    });
+
+    test("falls back to the PostgreSQL port for an unknown engine", () => {
+      expect(
+        SqlDatabaseTypeUtil.getDefaultPort("OracleDatabase" as SqlDatabaseType),
+      ).toBe(5432);
+    });
+  });
+});