@oneuptime/common 11.6.2 → 11.7.1

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

@@ -0,0 +1,465 @@
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * MonitorCriteriaInstance is a DatabaseProperty that carries the "if these
+ * filters match, then change status / open incidents / fire alerts" rule for a
+ * single monitor status. The contract these tests lock in:
+ *
+ *   1. Factory defaults (getNewMonitorCriteriaInstanceAsJSON, and the
+ *      per-monitor-type online/offline builders) produce well-formed criteria.
+ *   2. getValidationError catches every missing-required-field case, and
+ *      returns null only for a fully valid instance.
+ *   3. toJSON <-> fromJSON is a lossless round-trip, fromJSON rejects malformed
+ *      payloads, and clone() is a deep copy built on that round-trip.
+ */
+
+// A minimal, valid criteria instance for validation / serialization tests.
+const buildValidInstance: () => MonitorCriteriaInstance =
+  (): MonitorCriteriaInstance => {
+    const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+    instance.data = {
+      id: ObjectID.generate().toString(),
+      monitorStatusId: new ObjectID("statusid1234567890abcdef"),
+      filterCondition: FilterCondition.All,
+      filters: [
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      ],
+      incidents: [],
+      alerts: [],
+      createIncidents: false,
+      createAlerts: false,
+      changeMonitorStatus: true,
+      isEnabled: true,
+      name: "Online check",
+      description: "Checks whether the monitor is online",
+    };
+    return instance;
+  };
+
+describe("MonitorCriteriaInstance", () => {
+  describe("constructor", () => {
+    test("seeds a default IsOnline filter and a fresh id", () => {
+      const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+      expect(instance.data).toBeDefined();
+      expect(instance.data?.filterCondition).toBe(FilterCondition.All);
+      expect(instance.data?.filters).toHaveLength(1);
+      expect(instance.data?.filters[0]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(instance.data?.isEnabled).toBe(true);
+      // id should be a valid, non-empty ObjectID string.
+      expect(typeof instance.data?.id).toBe("string");
+      expect(instance.data?.id.length).toBeGreaterThan(0);
+    });
+
+    test("two instances get distinct ids", () => {
+      const a: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+      const b: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+      expect(a.data?.id).not.toBe(b.data?.id);
+    });
+  });
+
+  describe("getNewMonitorCriteriaInstanceAsJSON", () => {
+    test("returns default JSON with an IsOnline/True filter", () => {
+      const json: JSONObject =
+        MonitorCriteriaInstance.getNewMonitorCriteriaInstanceAsJSON();
+      expect(json["filterCondition"]).toBe(FilterCondition.All);
+      expect(json["name"]).toBe("");
+      expect(json["description"]).toBe("");
+      expect(json["createIncidents"]).toBe(false);
+      expect(json["changeMonitorStatus"]).toBe(false);
+      expect(Array.isArray(json["filters"])).toBe(true);
+      const filters: Array<CriteriaFilter> = json[
+        "filters"
+      ] as unknown as Array<CriteriaFilter>;
+      expect(filters[0]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(filters[0]?.filterType).toBe(FilterType.True);
+    });
+  });
+
+  describe("getDefaultOnlineMonitorCriteriaInstance", () => {
+    const monitorStatusId: ObjectID = new ObjectID("aaaaaaaaaaaaaaaaaaaaaaaa");
+
+    test("Ping monitor produces an IsOnline online criteria", () => {
+      const instance: MonitorCriteriaInstance | null =
+        MonitorCriteriaInstance.getDefaultOnlineMonitorCriteriaInstance({
+          monitorType: MonitorType.Ping,
+          monitorStatusId,
+          monitorName: "My Server",
+        });
+      expect(instance).not.toBeNull();
+      expect(instance?.data?.changeMonitorStatus).toBe(true);
+      expect(instance?.data?.filters[0]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(instance?.data?.name).toContain("My Server");
+      expect(instance?.data?.monitorStatusId?.toString()).toBe(
+        monitorStatusId.toString(),
+      );
+    });
+
+    test("IncomingRequest monitor uses a RecievedInMinutes filter", () => {
+      const instance: MonitorCriteriaInstance | null =
+        MonitorCriteriaInstance.getDefaultOnlineMonitorCriteriaInstance({
+          monitorType: MonitorType.IncomingRequest,
+          monitorStatusId,
+          monitorName: "Heartbeat",
+        });
+      expect(instance).not.toBeNull();
+      expect(instance?.data?.filters[0]?.checkOn).toBe(CheckOn.IncomingRequest);
+      expect(instance?.data?.filters[0]?.filterType).toBe(
+        FilterType.RecievedInMinutes,
+      );
+      expect(instance?.data?.filters[0]?.value).toBe(30);
+    });
+
+    test("Metrics monitor threads the first metric alias into options", () => {
+      const instance: MonitorCriteriaInstance | null =
+        MonitorCriteriaInstance.getDefaultOnlineMonitorCriteriaInstance({
+          monitorType: MonitorType.Metrics,
+          monitorStatusId,
+          monitorName: "CPU",
+          metricOptions: { metricAliases: ["cpu_usage", "mem_usage"] },
+        });
+      expect(instance).not.toBeNull();
+      expect(
+        instance?.data?.filters[0]?.metricMonitorOptions?.metricAlias,
+      ).toBe("cpu_usage");
+    });
+
+    test("Manual monitor type has no online criteria (returns null)", () => {
+      const instance: MonitorCriteriaInstance | null =
+        MonitorCriteriaInstance.getDefaultOnlineMonitorCriteriaInstance({
+          monitorType: MonitorType.Manual,
+          monitorStatusId,
+          monitorName: "Manual",
+        });
+      expect(instance).toBeNull();
+    });
+  });
+
+  describe("getDefaultOfflineMonitorCriteriaInstance", () => {
+    test("Ping offline criteria populates incident and alert with severities", () => {
+      const monitorStatusId: ObjectID = new ObjectID(
+        "bbbbbbbbbbbbbbbbbbbbbbbb",
+      );
+      const incidentSeverityId: ObjectID = new ObjectID(
+        "cccccccccccccccccccccccc",
+      );
+      const alertSeverityId: ObjectID = new ObjectID(
+        "dddddddddddddddddddddddd",
+      );
+
+      const instance: MonitorCriteriaInstance =
+        MonitorCriteriaInstance.getDefaultOfflineMonitorCriteriaInstance({
+          monitorType: MonitorType.Ping,
+          monitorStatusId,
+          incidentSeverityId,
+          alertSeverityId,
+          monitorName: "Edge",
+        });
+
+      expect(instance.data?.createIncidents).toBe(true);
+      expect(instance.data?.changeMonitorStatus).toBe(true);
+      expect(instance.data?.filters[0]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(instance.data?.filters[0]?.filterType).toBe(FilterType.False);
+      expect(instance.data?.incidents[0]?.incidentSeverityId?.toString()).toBe(
+        incidentSeverityId.toString(),
+      );
+      expect(instance.data?.alerts[0]?.alertSeverityId?.toString()).toBe(
+        alertSeverityId.toString(),
+      );
+      expect(instance.data?.incidents[0]?.title).toContain("Edge");
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("returns error when data is missing", () => {
+      const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+      instance.data = undefined;
+      expect(
+        MonitorCriteriaInstance.getValidationError(instance, MonitorType.Ping),
+      ).toBe("Monitor Step is required.");
+    });
+
+    test("returns error when there are no filters", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.filters = [];
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Filter is required");
+    });
+
+    test("returns error when name is empty", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.name = "";
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Name is required");
+    });
+
+    test("returns error when description is empty", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.description = "";
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Description is required");
+    });
+
+    test("returns error when an incident is missing its severity", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.incidents = [
+        {
+          title: "Down",
+          description: "It is down",
+          incidentSeverityId: undefined,
+          id: ObjectID.generate().toString(),
+          onCallPolicyIds: [],
+        },
+      ];
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Incident severity is required");
+    });
+
+    test("returns error when an alert is missing its title", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.alerts = [
+        {
+          title: "",
+          description: "It is down",
+          alertSeverityId: new ObjectID("eeeeeeeeeeeeeeeeeeeeeeee"),
+          id: ObjectID.generate().toString(),
+          onCallPolicyIds: [],
+        },
+      ];
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Alert title is required");
+    });
+
+    test("rejects a filter type that a Ping monitor cannot support", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.filters = [
+        {
+          checkOn: CheckOn.DiskUsagePercent,
+          filterType: FilterType.GreaterThan,
+          value: 90,
+        },
+      ];
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Ping Monitor cannot have filter type");
+    });
+
+    test("requires a disk path for Disk Usage Percent filters", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.filters = [
+        {
+          checkOn: CheckOn.DiskUsagePercent,
+          filterType: FilterType.GreaterThan,
+          value: 90,
+        },
+      ];
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Server,
+      );
+      expect(error).toBe("Disk Path is required for Disk Usage Percent");
+    });
+
+    test("requires a value for filters that carry a threshold", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.filters = [
+        {
+          checkOn: CheckOn.ResponseTime,
+          filterType: FilterType.GreaterThan,
+          value: undefined,
+        },
+      ];
+      const error: string | null = MonitorCriteriaInstance.getValidationError(
+        instance,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Value is required");
+    });
+
+    test("returns null for a fully valid instance", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      expect(
+        MonitorCriteriaInstance.getValidationError(instance, MonitorType.Ping),
+      ).toBeNull();
+    });
+  });
+
+  describe("toJSON / fromJSON round-trip", () => {
+    test("serializes with the MonitorCriteriaInstance object type wrapper", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      const json: JSONObject = instance.toJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorCriteriaInstance);
+      expect(json["value"]).toBeDefined();
+    });
+
+    test("round-trips core fields losslessly", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.name = "Round Trip";
+      instance.data!.description = "A description";
+      instance.data!.changeMonitorStatus = true;
+      instance.data!.createIncidents = false;
+
+      const restored: MonitorCriteriaInstance =
+        MonitorCriteriaInstance.fromJSON(instance.toJSON());
+
+      expect(restored.data?.name).toBe("Round Trip");
+      expect(restored.data?.description).toBe("A description");
+      expect(restored.data?.filterCondition).toBe(FilterCondition.All);
+      expect(restored.data?.filters[0]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(restored.data?.changeMonitorStatus).toBe(true);
+      expect(restored.data?.monitorStatusId?.toString()).toBe(
+        instance.data?.monitorStatusId?.toString(),
+      );
+    });
+
+    test("fromJSON defaults isEnabled to true when absent", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      const json: JSONObject = instance.toJSON();
+      // Simulate a legacy payload that predates the isEnabled field.
+      delete (json["value"] as JSONObject)["isEnabled"];
+      const restored: MonitorCriteriaInstance =
+        MonitorCriteriaInstance.fromJSON(json);
+      expect(restored.data?.isEnabled).toBe(true);
+    });
+
+    test("fromJSON is idempotent when given an existing instance", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      const same: MonitorCriteriaInstance = MonitorCriteriaInstance.fromJSON(
+        instance as unknown as JSONObject,
+      );
+      expect(same).toBe(instance);
+    });
+  });
+
+  describe("fromJSON validation", () => {
+    test("throws when _type is missing", () => {
+      expect(() => {
+        return MonitorCriteriaInstance.fromJSON({ value: {} });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when _type is wrong", () => {
+      expect(() => {
+        return MonitorCriteriaInstance.fromJSON({
+          _type: "SomethingElse",
+          value: {},
+        });
+      }).toThrow("json._type should be MonitorCriteriaInstance");
+    });
+
+    test("throws when value is missing", () => {
+      expect(() => {
+        return MonitorCriteriaInstance.fromJSON({
+          _type: ObjectType.MonitorCriteriaInstance,
+        });
+      }).toThrow("json.value is null");
+    });
+
+    test("throws when filterCondition is missing", () => {
+      expect(() => {
+        return MonitorCriteriaInstance.fromJSON({
+          _type: ObjectType.MonitorCriteriaInstance,
+          value: { filters: [] },
+        });
+      }).toThrow("json.filterCondition is null");
+    });
+
+    test("throws when filters is missing", () => {
+      expect(() => {
+        return MonitorCriteriaInstance.fromJSON({
+          _type: ObjectType.MonitorCriteriaInstance,
+          value: { filterCondition: FilterCondition.All },
+        });
+      }).toThrow("json.filters is null");
+    });
+
+    test("throws when filters is not an array", () => {
+      expect(() => {
+        return MonitorCriteriaInstance.fromJSON({
+          _type: ObjectType.MonitorCriteriaInstance,
+          value: {
+            filterCondition: FilterCondition.All,
+            filters: "not-an-array",
+          },
+        });
+      }).toThrow("json.filters should be an array");
+    });
+  });
+
+  describe("clone", () => {
+    test("produces a deep, independent copy that carries equal data", () => {
+      const instance: MonitorCriteriaInstance = buildValidInstance();
+      instance.data!.name = "Original";
+
+      const cloned: MonitorCriteriaInstance =
+        MonitorCriteriaInstance.clone(instance);
+
+      expect(cloned).not.toBe(instance);
+      expect(cloned.data?.name).toBe("Original");
+
+      // Mutating the clone must not affect the original.
+      cloned.data!.name = "Mutated";
+      expect(instance.data?.name).toBe("Original");
+    });
+  });
+
+  describe("setters", () => {
+    test("chain and mutate the underlying data", () => {
+      const statusId: ObjectID = new ObjectID("ffffffffffffffffffffffff");
+      const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance()
+        .setName("Chained")
+        .setDescription("Chained description")
+        .setChangeMonitorStatus(true)
+        .setCreateIncidents(true)
+        .setCreateAlerts(false)
+        .setIsEnabled(false)
+        .setMonitorStatusId(statusId);
+
+      expect(instance.data?.name).toBe("Chained");
+      expect(instance.data?.description).toBe("Chained description");
+      expect(instance.data?.changeMonitorStatus).toBe(true);
+      expect(instance.data?.createIncidents).toBe(true);
+      expect(instance.data?.createAlerts).toBe(false);
+      expect(instance.data?.isEnabled).toBe(false);
+      expect(instance.data?.monitorStatusId?.toString()).toBe(
+        statusId.toString(),
+      );
+    });
+  });
+
+  describe("isValid", () => {
+    test("returns true (permissive by contract)", () => {
+      expect(MonitorCriteriaInstance.isValid({})).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,183 @@
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import HTTPMethod from "../../../Types/API/HTTPMethod";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+
+/*
+ * MonitorStep is the per-step config of a monitor (destination, request shape,
+ * TLS material, per-protocol sub-configs and the nested MonitorCriteria).
+ * These tests focus on the parts with real branching logic: getValidationError
+ * (which is monitor-type dependent), the factory defaults, clone, the id
+ * accessor, the fluent request setters and the toJSON/fromJSON round-trip.
+ */
+
+const DEFAULT_ARG: {
+  monitorName: string;
+  monitorType: MonitorType;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+} = {
+  monitorName: "Web",
+  monitorType: MonitorType.Manual,
+  onlineMonitorStatusId: new ObjectID("100000000000000000000021"),
+  offlineMonitorStatusId: new ObjectID("100000000000000000000022"),
+  defaultIncidentSeverityId: new ObjectID("100000000000000000000023"),
+  defaultAlertSeverityId: new ObjectID("100000000000000000000024"),
+};
+
+describe("MonitorStep", () => {
+  describe("getNewMonitorStepAsJSON", () => {
+    test("carries a fresh id, GET request type and nested criteria", () => {
+      const json: JSONObject = MonitorStep.getNewMonitorStepAsJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorStep);
+      const value: JSONObject = json["value"] as JSONObject;
+      expect(typeof value["id"]).toBe("string");
+      expect(value["requestType"]).toBe(HTTPMethod.GET);
+      expect(value["monitorCriteria"]).toBeDefined();
+    });
+  });
+
+  describe("getDefaultMonitorStep", () => {
+    test("populates a fresh id, GET request type and nested criteria", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(DEFAULT_ARG);
+      expect(typeof step.data?.id).toBe("string");
+      expect(step.data?.id?.length).toBeGreaterThan(0);
+      expect(step.data?.requestType).toBe(HTTPMethod.GET);
+      expect(step.data?.monitorCriteria).toBeDefined();
+      // The default destination is left for the user to fill in.
+      expect(step.data?.monitorDestination).toBeUndefined();
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("errors when data is missing", () => {
+      const step: MonitorStep = new MonitorStep();
+      step.data = undefined;
+      expect(MonitorStep.getValidationError(step, MonitorType.Ping)).toBe(
+        "Monitor Step is required.",
+      );
+    });
+
+    test("requires a destination for a Ping monitor", () => {
+      // A default Ping step leaves monitorDestination undefined.
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep({
+        ...DEFAULT_ARG,
+        monitorType: MonitorType.Ping,
+      });
+      expect(MonitorStep.getValidationError(step, MonitorType.Ping)).toBe(
+        "Monitor Destination is required.",
+      );
+    });
+
+    test("requires a port for a Port monitor that has a destination", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep({
+        ...DEFAULT_ARG,
+        monitorType: MonitorType.Port,
+      });
+      /*
+       * Give it a destination so we exercise the missing-port branch, not the
+       * missing-destination branch that precedes it.
+       */
+      step.data!.monitorDestination = {
+        toJSON: () => {
+          return "1.2.3.4";
+        },
+      } as never;
+      expect(MonitorStep.getValidationError(step, MonitorType.Port)).toBe(
+        "Port is required",
+      );
+    });
+
+    test("rejects a client certificate without its key on an API monitor", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep({
+        ...DEFAULT_ARG,
+        monitorType: MonitorType.API,
+      });
+      step.data!.monitorDestination = {
+        toJSON: () => {
+          return "https://x";
+        },
+      } as never;
+      step.data!.requestType = HTTPMethod.GET;
+      step.data!.tlsClientCertificate = "----CERT----";
+      step.data!.tlsClientKey = undefined;
+      expect(MonitorStep.getValidationError(step, MonitorType.API)).toBe(
+        "Client private key is required when a client certificate is provided",
+      );
+    });
+
+    test("rejects a client key without its certificate on an API monitor", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep({
+        ...DEFAULT_ARG,
+        monitorType: MonitorType.API,
+      });
+      step.data!.monitorDestination = {
+        toJSON: () => {
+          return "https://x";
+        },
+      } as never;
+      step.data!.requestType = HTTPMethod.GET;
+      step.data!.tlsClientCertificate = undefined;
+      step.data!.tlsClientKey = "----KEY----";
+      expect(MonitorStep.getValidationError(step, MonitorType.API)).toBe(
+        "Client certificate is required when a client private key is provided",
+      );
+    });
+  });
+
+  describe("id accessor", () => {
+    test("get/set round-trips through the underlying string", () => {
+      const step: MonitorStep = new MonitorStep();
+      const newId: ObjectID = new ObjectID("100000000000000000000099");
+      step.id = newId;
+      expect(step.data?.id).toBe("100000000000000000000099");
+      expect(step.id.toString()).toBe("100000000000000000000099");
+    });
+  });
+
+  describe("request setters", () => {
+    test("chain and mutate the request config", () => {
+      const step: MonitorStep = new MonitorStep()
+        .setRequestType(HTTPMethod.POST)
+        .setRequestHeaders({ "x-test": "1" })
+        .setRequestBody('{"a":1}');
+      expect(step.data?.requestType).toBe(HTTPMethod.POST);
+      expect(step.data?.requestHeaders).toEqual({ "x-test": "1" });
+      expect(step.data?.requestBody).toBe('{"a":1}');
+    });
+  });
+
+  describe("toJSON / fromJSON / clone", () => {
+    test("serializes with the MonitorStep type wrapper", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(DEFAULT_ARG);
+      expect(step.toJSON()["_type"]).toBe(ObjectType.MonitorStep);
+    });
+
+    test("round-trips the step id", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(DEFAULT_ARG);
+      const originalId: string | undefined = step.data?.id;
+      const restored: MonitorStep = MonitorStep.fromJSON(step.toJSON());
+      expect(restored.data?.id).toBe(originalId);
+    });
+
+    test("clone is an independent copy", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(DEFAULT_ARG);
+      const cloned: MonitorStep = MonitorStep.clone(step);
+      expect(cloned).not.toBe(step);
+      expect(cloned.data?.id).toBe(step.data?.id);
+
+      cloned.setRequestType(HTTPMethod.DELETE);
+      // Mutating the clone must not touch the original.
+      expect(step.data?.requestType).not.toBe(HTTPMethod.DELETE);
+    });
+
+    test("toString produces JSON that parses back to a MonitorStep wrapper", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(DEFAULT_ARG);
+      const parsed: JSONObject = JSON.parse(step.toString()) as JSONObject;
+      expect(parsed["_type"]).toBe(ObjectType.MonitorStep);
+    });
+  });
+});