@oneuptime/common 11.5.13 → 11.6.1

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

@@ -9,6 +9,7 @@ describe("CodeFixTaskTypeHelper", () => {
       expect(CodeFixTaskTypeHelper.getUserTriggerableTaskTypes()).toEqual([
         CodeFixTaskType.FixException,
         CodeFixTaskType.WriteRegressionTest,
+        CodeFixTaskType.ImproveExceptionHandling,
       ]);
     });
   });
@@ -17,6 +18,7 @@ describe("CodeFixTaskTypeHelper", () => {
     test.each([
       CodeFixTaskType.FixException,
       CodeFixTaskType.WriteRegressionTest,
+      CodeFixTaskType.ImproveExceptionHandling,
     ])("returns true for %s", (taskType: CodeFixTaskType) => {
       expect(CodeFixTaskTypeHelper.isUserTriggerable(taskType)).toBe(true);
     });
@@ -69,6 +71,7 @@ describe("CodeFixTaskTypeHelper", () => {
     test.each([
       CodeFixTaskType.FixException,
       CodeFixTaskType.WriteRegressionTest,
+      CodeFixTaskType.ImproveExceptionHandling,
     ])("returns true for %s", (taskType: CodeFixTaskType) => {
       expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
         true,

package/Tests/Types/HashCode.test.ts

@@ -0,0 +1,41 @@
+import HashCode from "../../Types/HashCode";
+
+describe("HashCode", () => {
+  describe("fromString", () => {
+    test("returns 0 for an empty string", () => {
+      expect(HashCode.fromString("")).toBe(0);
+    });
+
+    test("is deterministic for the same input", () => {
+      expect(HashCode.fromString("oneuptime")).toBe(
+        HashCode.fromString("oneuptime"),
+      );
+    });
+
+    test("produces different hashes for different inputs", () => {
+      expect(HashCode.fromString("abc")).not.toBe(HashCode.fromString("abd"));
+    });
+
+    test("is order-sensitive", () => {
+      expect(HashCode.fromString("ab")).not.toBe(HashCode.fromString("ba"));
+    });
+
+    test("returns a 32-bit signed integer", () => {
+      const hash: number = HashCode.fromString(
+        "a fairly long string to exercise the shift/overflow path",
+      );
+      expect(Number.isInteger(hash)).toBe(true);
+      expect(hash).toBeGreaterThanOrEqual(-(2 ** 31));
+      expect(hash).toBeLessThanOrEqual(2 ** 31 - 1);
+    });
+
+    test("matches the known Java-style hashCode value", () => {
+      // "hello".hashCode() in Java is 99162322.
+      expect(HashCode.fromString("hello")).toBe(99162322);
+    });
+
+    test("single character equals its char code", () => {
+      expect(HashCode.fromString("A")).toBe("A".charCodeAt(0));
+    });
+  });
+});

package/Tests/Types/Log/LogQueryParser.test.ts

@@ -0,0 +1,186 @@
+import parseLogQuery, {
+  FilterOperator,
+  ParsedToken,
+  TokenType,
+  tokensToDisplayString,
+} from "../../../Types/Log/LogQueryParser";
+
+describe("LogQueryParser", () => {
+  describe("parseLogQuery - empty and free text", () => {
+    test("returns an empty array for empty / whitespace input", () => {
+      expect(parseLogQuery("")).toEqual([]);
+      expect(parseLogQuery("   ")).toEqual([]);
+    });
+
+    test("combines free text words into a single Contains token", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("connection refused");
+      expect(tokens).toHaveLength(1);
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.FreeText,
+        operator: FilterOperator.Contains,
+        value: "connection refused",
+        negated: false,
+      });
+    });
+
+    test("strips quotes from a quoted phrase", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery('"connection refused"');
+      expect(tokens).toHaveLength(1);
+      expect(tokens[0]!.value).toBe("connection refused");
+      expect(tokens[0]!.type).toBe(TokenType.FreeText);
+    });
+  });
+
+  describe("parseLogQuery - field filters and aliases", () => {
+    test("resolves the severity alias to severityText", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("severity:error");
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.FieldFilter,
+        field: "severityText",
+        operator: FilterOperator.Equals,
+        value: "error",
+        negated: false,
+      });
+    });
+
+    test("resolves the service alias to primaryEntityId", () => {
+      expect(parseLogQuery("service:api")[0]!.field).toBe("primaryEntityId");
+    });
+
+    test("resolves level, message, and trace aliases", () => {
+      expect(parseLogQuery("level:warn")[0]!.field).toBe("severityText");
+      expect(parseLogQuery("message:hello")[0]!.field).toBe("body");
+      expect(parseLogQuery("trace:abc")[0]!.field).toBe("traceId");
+    });
+
+    test("keeps unknown field names as-is", () => {
+      expect(parseLogQuery("customfield:x")[0]!.field).toBe("customfield");
+    });
+  });
+
+  describe("parseLogQuery - attribute filters", () => {
+    test("parses @-prefixed attribute access", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("@http.status_code:500");
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.AttributeFilter,
+        field: "http.status_code",
+        operator: FilterOperator.Equals,
+        value: "500",
+      });
+    });
+
+    test("does not run aliasing on attribute field names", () => {
+      // "service" is an alias for field filters but must stay literal as an attribute.
+      expect(parseLogQuery("@service:api")[0]!.field).toBe("service");
+    });
+  });
+
+  describe("parseLogQuery - negation", () => {
+    test("negated equals becomes NotEquals", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("-severity:debug");
+      expect(tokens[0]).toMatchObject({
+        field: "severityText",
+        operator: FilterOperator.NotEquals,
+        value: "debug",
+        negated: true,
+      });
+    });
+
+    test("negated attribute filter", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("-@http.method:GET");
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.AttributeFilter,
+        field: "http.method",
+        operator: FilterOperator.NotEquals,
+        negated: true,
+      });
+    });
+  });
+
+  describe("parseLogQuery - operators", () => {
+    test("detects wildcard values", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("service:api-*");
+      expect(tokens[0]).toMatchObject({
+        operator: FilterOperator.Wildcard,
+        value: "api-*",
+      });
+    });
+
+    test("detects numeric comparison operators", () => {
+      expect(parseLogQuery("@duration:>1000")[0]).toMatchObject({
+        operator: FilterOperator.GreaterThan,
+        value: "1000",
+      });
+      expect(parseLogQuery("@duration:>=1000")[0]).toMatchObject({
+        operator: FilterOperator.GreaterThanOrEqual,
+        value: "1000",
+      });
+      expect(parseLogQuery("@duration:<50")[0]).toMatchObject({
+        operator: FilterOperator.LessThan,
+        value: "50",
+      });
+      expect(parseLogQuery("@duration:<=50")[0]).toMatchObject({
+        operator: FilterOperator.LessThanOrEqual,
+        value: "50",
+      });
+    });
+  });
+
+  describe("parseLogQuery - boolean keywords and mixed queries", () => {
+    test("skips bare AND/OR/NOT keywords", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        "severity:error AND service:api",
+      );
+      expect(tokens).toHaveLength(2);
+      expect(tokens[0]!.field).toBe("severityText");
+      expect(tokens[1]!.field).toBe("primaryEntityId");
+    });
+
+    test("splits free text around a field filter", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        "connection severity:error refused",
+      );
+      expect(tokens).toHaveLength(3);
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.FreeText,
+        value: "connection",
+      });
+      expect(tokens[1]).toMatchObject({
+        type: TokenType.FieldFilter,
+        field: "severityText",
+      });
+      expect(tokens[2]).toMatchObject({
+        type: TokenType.FreeText,
+        value: "refused",
+      });
+    });
+
+    test("does not split a quoted phrase containing spaces", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        '"connection refused" severity:error',
+      );
+      expect(tokens).toHaveLength(2);
+      expect(tokens[0]!.value).toBe("connection refused");
+      expect(tokens[1]!.field).toBe("severityText");
+    });
+
+    test("strips quotes from field values", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery('message:"a b c"');
+      expect(tokens[0]!.value).toBe("a b c");
+      expect(tokens[0]!.field).toBe("body");
+    });
+  });
+
+  describe("tokensToDisplayString", () => {
+    test("rejoins tokens using their raw representation", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        "severity:error service:api",
+      );
+      expect(tokensToDisplayString(tokens)).toBe("severity:error service:api");
+    });
+
+    test("returns an empty string for no tokens", () => {
+      expect(tokensToDisplayString([])).toBe("");
+    });
+  });
+});

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

@@ -0,0 +1,228 @@
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import { CheckOn, CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
+import { getAllCephAlertTemplates } from "../../../Types/Monitor/CephAlertTemplates";
+import { getAllDockerAlertTemplates } from "../../../Types/Monitor/DockerAlertTemplates";
+import { getAllDockerSwarmAlertTemplates } from "../../../Types/Monitor/DockerSwarmAlertTemplates";
+import {
+  buildHostMonitorConfig,
+  getAllHostAlertTemplates,
+} from "../../../Types/Monitor/HostAlertTemplates";
+import { getAllIoTAlertTemplates } from "../../../Types/Monitor/IotAlertTemplates";
+import { getAllKubernetesAlertTemplates } from "../../../Types/Monitor/KubernetesAlertTemplates";
+import { getAllPodmanAlertTemplates } from "../../../Types/Monitor/PodmanAlertTemplates";
+import { getAllProxmoxAlertTemplates } from "../../../Types/Monitor/ProxmoxAlertTemplates";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorStep, {
+  MonitorStepType,
+} from "../../../Types/Monitor/MonitorStep";
+import MonitorStepHostMonitor from "../../../Types/Monitor/MonitorStepHostMonitor";
+import MonitorStepMetricViewConfigUtil from "../../../Types/Monitor/MonitorStepMetricViewConfigUtil";
+import RollingTime from "../../../Types/RollingTime/RollingTime";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * End-to-end regression guard for the blank "METRIC" dropdown (Issues 1 & 2).
+ *
+ * For EVERY metric-shaped monitor type, a Quick Setup alert template must
+ * produce a monitor step whose metric variables are discoverable through
+ * MonitorStepMetricViewConfigUtil — the same resolver the criteria UI uses to
+ * fill the "Which metric query should this alert rule check?" dropdown. And
+ * every MetricValue criteria the template emits must reference a variable that
+ * the dropdown actually offers, otherwise the alert rule points at a metric the
+ * user can never (re)select.
+ *
+ * Before the fix, Host / Podman / DockerSwarm / IoT would all fail the
+ * "surfaces at least one metric variable" assertion because the criteria UI
+ * never read their metricViewConfig.
+ */
+
+// Superset of every template's Args — excess fields are ignored per type.
+interface UniversalTemplateArgs {
+  hostIdentifier: string;
+  clusterIdentifier: string;
+  fleetIdentifier: string;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+  monitorName: string;
+}
+
+interface AnyAlertTemplate {
+  id: string;
+  name: string;
+  getMonitorStep: (args: UniversalTemplateArgs) => MonitorStep;
+}
+
+interface ResourceDescriptor {
+  name: string;
+  subConfigKey: keyof MonitorStepType;
+  templates: Array<AnyAlertTemplate>;
+}
+
+function buildArgs(): UniversalTemplateArgs {
+  return {
+    hostIdentifier: "host-identifier-1",
+    clusterIdentifier: "cluster-identifier-1",
+    fleetIdentifier: "fleet-identifier-1",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test Monitor",
+  };
+}
+
+const RESOURCES: Array<ResourceDescriptor> = [
+  {
+    name: "Host",
+    subConfigKey: "hostMonitor",
+    templates: getAllHostAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Kubernetes",
+    subConfigKey: "kubernetesMonitor",
+    templates:
+      getAllKubernetesAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Docker",
+    subConfigKey: "dockerMonitor",
+    templates:
+      getAllDockerAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "DockerSwarm",
+    subConfigKey: "dockerSwarmMonitor",
+    templates:
+      getAllDockerSwarmAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Podman",
+    subConfigKey: "podmanMonitor",
+    templates:
+      getAllPodmanAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Proxmox",
+    subConfigKey: "proxmoxMonitor",
+    templates:
+      getAllProxmoxAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Ceph",
+    subConfigKey: "cephMonitor",
+    templates: getAllCephAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "IoT",
+    subConfigKey: "iotMonitor",
+    templates: getAllIoTAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+];
+
+function getCriteriaInstances(
+  step: MonitorStep,
+): Array<MonitorCriteriaInstance> {
+  return step.data?.monitorCriteria?.data?.monitorCriteriaInstanceArray || [];
+}
+
+describe("Monitor criteria metric-variable resolution (all resource types)", () => {
+  test("every resource type exposes at least one alert template", () => {
+    for (const resource of RESOURCES) {
+      expect(resource.templates.length).toBeGreaterThan(0);
+    }
+  });
+
+  describe.each(RESOURCES)(
+    "$name alert templates",
+    (resource: ResourceDescriptor) => {
+      test("the resolver reads this resource's metricViewConfig", () => {
+        const step: MonitorStep =
+          resource.templates[0]!.getMonitorStep(buildArgs());
+
+        const stepRecord: Record<
+          string,
+          { metricViewConfig?: unknown } | undefined
+        > = step.data as unknown as Record<
+          string,
+          { metricViewConfig?: unknown } | undefined
+        >;
+
+        const expectedConfig: unknown =
+          stepRecord[resource.subConfigKey as string]?.metricViewConfig;
+
+        expect(expectedConfig).toBeDefined();
+        expect(
+          MonitorStepMetricViewConfigUtil.getMetricViewConfig(step.data),
+        ).toBe(expectedConfig);
+      });
+
+      test.each(
+        resource.templates.map(
+          (t: AnyAlertTemplate): [string, AnyAlertTemplate] => {
+            return [t.id, t];
+          },
+        ),
+      )(
+        "%s surfaces metric variables and resolves its criteria aliases",
+        (_id: string, template: AnyAlertTemplate) => {
+          const step: MonitorStep = template.getMonitorStep(buildArgs());
+
+          // 1. The dropdown would offer at least one option (the actual bug).
+          const variables: Array<string> =
+            MonitorStepMetricViewConfigUtil.getMetricVariables(step.data);
+          expect(variables.length).toBeGreaterThan(0);
+          // No blank options leak through.
+          expect(variables).not.toContain("");
+
+          // 2. Every MetricValue criteria references an offered variable.
+          const referencedAliases: Set<string> = new Set<string>();
+          for (const instance of getCriteriaInstances(step)) {
+            for (const filter of (instance.data?.filters ||
+              []) as Array<CriteriaFilter>) {
+              if (
+                filter.checkOn === CheckOn.MetricValue &&
+                filter.metricMonitorOptions?.metricAlias
+              ) {
+                referencedAliases.add(filter.metricMonitorOptions.metricAlias);
+              }
+            }
+          }
+
+          // These templates must produce at least one metric criteria.
+          expect(referencedAliases.size).toBeGreaterThan(0);
+
+          for (const alias of referencedAliases) {
+            expect(variables).toContain(alias);
+          }
+        },
+      );
+    },
+  );
+});
+
+describe("Custom Metric flow (buildHostMonitorConfig)", () => {
+  test("a long descriptive alias is surfaced by the resolver", () => {
+    const config: MonitorStepHostMonitor = buildHostMonitorConfig({
+      hostIdentifier: "host-1",
+      metricName: "process.cpu.utilization",
+      metricAlias: "process_cpu_utilization",
+      rollingTime: RollingTime.Past5Minutes,
+      aggregationType: MetricsAggregationType.Max,
+    });
+
+    const stepData: MonitorStepType = {
+      hostMonitor: config,
+    } as unknown as MonitorStepType;
+
+    expect(
+      MonitorStepMetricViewConfigUtil.getMetricVariables(stepData),
+    ).toEqual(["process_cpu_utilization"]);
+
+    // The alias also lands on the query config so the criteria join key holds.
+    expect(
+      config.metricViewConfig.queryConfigs[0]?.metricAliasData?.metricVariable,
+    ).toBe("process_cpu_utilization");
+  });
+});

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

@@ -0,0 +1,169 @@
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { MonitorStepLogMonitorUtil } from "../../../Types/Monitor/MonitorStepLogMonitor";
+import { MonitorStepTraceMonitorUtil } from "../../../Types/Monitor/MonitorStepTraceMonitor";
+import { MonitorStepMetricMonitorUtil } from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import { MonitorStepExceptionMonitorUtil } from "../../../Types/Monitor/MonitorStepExceptionMonitor";
+
+/*
+ * Regression coverage for the "log monitors do not work" bug: a telemetry
+ * monitor step created on defaults must persist its own type's sub-config
+ * (logMonitor / traceMonitor / metricMonitor / exceptionMonitor) rather than
+ * leaving it undefined. When it was left undefined, the worker's
+ * monitorLogs()/monitorTrace()/... threw "<type> query/config is missing" on
+ * every evaluation, so the monitor never ran and its criteria never applied.
+ */
+describe("MonitorStep.getDefaultMonitorStep telemetry sub-config seeding", () => {
+  const buildArgs: (
+    monitorType: MonitorType,
+  ) => Parameters<typeof MonitorStep.getDefaultMonitorStep>[0] = (
+    monitorType: MonitorType,
+  ) => {
+    const id: ObjectID = ObjectID.generate();
+    return {
+      monitorName: `${monitorType} monitor`,
+      monitorType,
+      onlineMonitorStatusId: id,
+      offlineMonitorStatusId: id,
+      defaultIncidentSeverityId: id,
+      defaultAlertSeverityId: id,
+    };
+  };
+
+  describe("seeds exactly the matching type's sub-config", () => {
+    test("Logs monitor seeds logMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Logs),
+      );
+
+      expect(step.data?.logMonitor).toBeDefined();
+      expect(step.data?.logMonitor).toEqual(
+        MonitorStepLogMonitorUtil.getDefault(),
+      );
+      // The default query config must be usable (positive time window).
+      expect(step.data?.logMonitor?.lastXSecondsOfLogs).toBeGreaterThan(0);
+      expect(step.data?.traceMonitor).toBeUndefined();
+      expect(step.data?.metricMonitor).toBeUndefined();
+      expect(step.data?.exceptionMonitor).toBeUndefined();
+    });
+
+    test("Traces monitor seeds traceMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Traces),
+      );
+
+      expect(step.data?.traceMonitor).toBeDefined();
+      expect(step.data?.traceMonitor).toEqual(
+        MonitorStepTraceMonitorUtil.getDefault(),
+      );
+      expect(step.data?.traceMonitor?.lastXSecondsOfSpans).toBeGreaterThan(0);
+      expect(step.data?.logMonitor).toBeUndefined();
+      expect(step.data?.metricMonitor).toBeUndefined();
+      expect(step.data?.exceptionMonitor).toBeUndefined();
+    });
+
+    test("Metrics monitor seeds metricMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Metrics),
+      );
+
+      expect(step.data?.metricMonitor).toBeDefined();
+      expect(step.data?.metricMonitor).toEqual(
+        MonitorStepMetricMonitorUtil.getDefault(),
+      );
+      expect(step.data?.metricMonitor?.metricViewConfig).toBeDefined();
+      expect(step.data?.logMonitor).toBeUndefined();
+      expect(step.data?.traceMonitor).toBeUndefined();
+      expect(step.data?.exceptionMonitor).toBeUndefined();
+    });
+
+    test("Exceptions monitor seeds exceptionMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Exceptions),
+      );
+
+      expect(step.data?.exceptionMonitor).toBeDefined();
+      expect(step.data?.exceptionMonitor).toEqual(
+        MonitorStepExceptionMonitorUtil.getDefault(),
+      );
+      expect(step.data?.logMonitor).toBeUndefined();
+      expect(step.data?.traceMonitor).toBeUndefined();
+      expect(step.data?.metricMonitor).toBeUndefined();
+    });
+  });
+
+  describe("does not seed a telemetry sub-config for other types", () => {
+    /*
+     * Only the four telemetry types offered by the Telemetry picker are
+     * seeded here. Infra metric monitors (Kubernetes/Docker/Host/...) carry
+     * their own sub-config from templates, and non-telemetry monitors have
+     * no telemetry sub-config at all — none must get a logMonitor/traceMonitor
+     * /metricMonitor/exceptionMonitor from the generic default step.
+     */
+    const nonSeededTypes: Array<MonitorType> = [
+      MonitorType.Ping,
+      MonitorType.IP,
+      MonitorType.Port,
+      MonitorType.Website,
+      MonitorType.API,
+      MonitorType.Server,
+      MonitorType.SSLCertificate,
+      MonitorType.IncomingRequest,
+      MonitorType.SyntheticMonitor,
+      MonitorType.CustomJavaScriptCode,
+      MonitorType.SQLQuery,
+      MonitorType.Manual,
+      MonitorType.Profiles,
+      MonitorType.Kubernetes,
+      MonitorType.Docker,
+      MonitorType.Host,
+      MonitorType.Podman,
+      MonitorType.DockerSwarm,
+      MonitorType.Proxmox,
+      MonitorType.Ceph,
+      MonitorType.IoTDevice,
+    ];
+
+    test.each(nonSeededTypes)(
+      "%s seeds no telemetry sub-config",
+      (monitorType: MonitorType) => {
+        const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+          buildArgs(monitorType),
+        );
+
+        expect(step.data?.logMonitor).toBeUndefined();
+        expect(step.data?.traceMonitor).toBeUndefined();
+        expect(step.data?.metricMonitor).toBeUndefined();
+        expect(step.data?.exceptionMonitor).toBeUndefined();
+      },
+    );
+  });
+
+  test("still seeds the default criteria and a step id", () => {
+    const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+      buildArgs(MonitorType.Logs),
+    );
+
+    expect(step.data?.id).toBeDefined();
+    expect(step.data?.monitorCriteria).toBeDefined();
+    expect(
+      step.data?.monitorCriteria.data?.monitorCriteriaInstanceArray.length,
+    ).toBeGreaterThan(0);
+  });
+
+  test("seeds a fresh sub-config object per call (no shared mutable state)", () => {
+    const a: MonitorStep = MonitorStep.getDefaultMonitorStep(
+      buildArgs(MonitorType.Logs),
+    );
+    const b: MonitorStep = MonitorStep.getDefaultMonitorStep(
+      buildArgs(MonitorType.Logs),
+    );
+
+    expect(a.data?.logMonitor).not.toBe(b.data?.logMonitor);
+
+    // Mutating one must not bleed into the other.
+    a.data!.logMonitor!.lastXSecondsOfLogs = 999;
+    expect(b.data?.logMonitor?.lastXSecondsOfLogs).not.toBe(999);
+  });
+});