@oneuptime/common 10.8.2 → 11.0.1

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

@@ -0,0 +1,275 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import Log from "../../../Models/AnalyticsModels/Log";
+import Span from "../../../Models/AnalyticsModels/Span";
+import ExceptionInstance from "../../../Models/AnalyticsModels/ExceptionInstance";
+import Profile from "../../../Models/AnalyticsModels/Profile";
+import Metric from "../../../Models/AnalyticsModels/Metric";
+import MonitorStepLogMonitor, {
+  MonitorStepLogMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepLogMonitor";
+import MonitorStepTraceMonitor, {
+  MonitorStepTraceMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepTraceMonitor";
+import MonitorStepExceptionMonitor, {
+  MonitorStepExceptionMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepExceptionMonitor";
+import MonitorStepProfileMonitor, {
+  MonitorStepProfileMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepProfileMonitor";
+import MonitorStepMetricMonitor, {
+  MonitorStepMetricMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * Entity scoping on telemetry monitor steps (entityKeys -> hasAny membership
+ * predicate). The contract these tests lock in:
+ *
+ *   1. Backward compatibility — monitors saved before the field existed
+ *      deserialize with no entityKeys (or an empty array), and the query
+ *      compile treats undefined/empty as a strict no-op (no `entityKeys`
+ *      predicate in the generated Query<Model>).
+ *   2. When 1+ keys are present, the compile emits an Includes on the
+ *      `entityKeys` column, which StatementGenerator turns into
+ *      hasAny(entityKeys, [...]) for Array(String) columns.
+ */
+
+const TWO_KEYS: Array<string> = ["a1b2c3d4e5f60708", "1122334455667788"];
+
+type ExpectIncludesFunction = (
+  value: unknown,
+  expectedKeys: Array<string>,
+) => void;
+
+const expectIncludes: ExpectIncludesFunction = (
+  value: unknown,
+  expectedKeys: Array<string>,
+): void => {
+  expect(value).toBeInstanceOf(Includes);
+  expect((value as Includes).values).toEqual(expectedKeys);
+};
+
+describe("MonitorStepLogMonitorUtil.toQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined (pre-existing saved monitors)", () => {
+    const step: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+    expect(Object.keys(query)).not.toContain("entityKeys");
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON tolerates legacy JSON without entityKeys and round-trips keys", () => {
+    const legacyJson: JSONObject = MonitorStepLogMonitorUtil.toJSON(
+      MonitorStepLogMonitorUtil.getDefault(),
+    );
+    delete legacyJson["entityKeys"];
+
+    const legacyStep: MonitorStepLogMonitor =
+      MonitorStepLogMonitorUtil.fromJSON(legacyJson);
+    expect(legacyStep.entityKeys).toEqual([]);
+
+    const stepWithKeys: MonitorStepLogMonitor =
+      MonitorStepLogMonitorUtil.getDefault();
+    stepWithKeys.entityKeys = TWO_KEYS;
+
+    const roundTripped: MonitorStepLogMonitor =
+      MonitorStepLogMonitorUtil.fromJSON(
+        MonitorStepLogMonitorUtil.toJSON(stepWithKeys),
+      );
+    expect(roundTripped.entityKeys).toEqual(TWO_KEYS);
+  });
+});
+
+describe("MonitorStepTraceMonitorUtil.toQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined", () => {
+    const step: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Span> = MonitorStepTraceMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Span> = MonitorStepTraceMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Span> = MonitorStepTraceMonitorUtil.toQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON tolerates legacy JSON without entityKeys", () => {
+    const legacyJson: JSONObject = MonitorStepTraceMonitorUtil.toJSON(
+      MonitorStepTraceMonitorUtil.getDefault(),
+    );
+    delete legacyJson["entityKeys"];
+
+    const legacyStep: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.fromJSON(legacyJson);
+    expect(legacyStep.entityKeys).toEqual([]);
+  });
+});
+
+describe("MonitorStepExceptionMonitorUtil.toAnalyticsQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined", () => {
+    const step: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<ExceptionInstance> =
+      MonitorStepExceptionMonitorUtil.toAnalyticsQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<ExceptionInstance> =
+      MonitorStepExceptionMonitorUtil.toAnalyticsQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<ExceptionInstance> =
+      MonitorStepExceptionMonitorUtil.toAnalyticsQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON tolerates legacy JSON without entityKeys", () => {
+    const legacyJson: JSONObject = MonitorStepExceptionMonitorUtil.toJSON(
+      MonitorStepExceptionMonitorUtil.getDefault(),
+    );
+    delete legacyJson["entityKeys"];
+
+    const legacyStep: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.fromJSON(legacyJson);
+    expect(legacyStep.entityKeys).toEqual([]);
+  });
+});
+
+describe("MonitorStepProfileMonitorUtil.toQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined", () => {
+    const step: MonitorStepProfileMonitor =
+      MonitorStepProfileMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepProfileMonitor =
+      MonitorStepProfileMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepProfileMonitor =
+      MonitorStepProfileMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+});
+
+describe("MonitorStepMetricMonitorUtil.applyEntityScopeToQuery", () => {
+  test("is a no-op when entityKeys is undefined (pre-existing saved monitors)", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Metric> = {};
+    MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
+
+    expect(query.entityKeys).toBeUndefined();
+    expect(Object.keys(query)).toHaveLength(0);
+  });
+
+  test("is a no-op when entityKeys is an empty array", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Metric> = {};
+    MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("stamps an Includes on entityKeys for two keys and preserves other predicates", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Metric> = { name: "cpu.usage" };
+    const returned: Query<Metric> =
+      MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
+
+    expect(returned).toBe(query);
+    expect(query.name).toBe("cpu.usage");
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON preserves entityKeys (pass-through serialization)", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const roundTripped: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON(
+        MonitorStepMetricMonitorUtil.toJSON(step),
+      );
+
+    expect(roundTripped.entityKeys).toEqual(TWO_KEYS);
+  });
+});

package/Tests/Types/Text.test.ts

@@ -5,4 +5,56 @@ describe("class Text", () => {
     expect(Text.uppercaseFirstLetter("text")).toEqual("Text");
     expect(Text.uppercaseFirstLetter("another test")).toEqual("Another test");
   });
+
+  describe("Text.convertOtlpIdToHex", () => {
+    test("passes 32-char hex trace ids through, normalised to lowercase", () => {
+      const hexTraceId: string = "4BF92F3577B34DA6A3CE929D0E0E4736";
+      expect(Text.convertOtlpIdToHex(hexTraceId)).toEqual(
+        "4bf92f3577b34da6a3ce929d0e0e4736",
+      );
+      expect(
+        Text.convertOtlpIdToHex("4bf92f3577b34da6a3ce929d0e0e4736"),
+      ).toEqual("4bf92f3577b34da6a3ce929d0e0e4736");
+    });
+
+    test("passes 16-char hex span ids through, normalised to lowercase", () => {
+      expect(Text.convertOtlpIdToHex("00F067AA0BA902B7")).toEqual(
+        "00f067aa0ba902b7",
+      );
+    });
+
+    test("decodes base64 ids (the OTLP/protobuf wire form) to hex", () => {
+      // 16-byte trace id -> 24-char base64 -> 32-char hex
+      const traceIdBytes: Buffer = Buffer.from(
+        "4bf92f3577b34da6a3ce929d0e0e4736",
+        "hex",
+      );
+      expect(Text.convertOtlpIdToHex(traceIdBytes.toString("base64"))).toEqual(
+        "4bf92f3577b34da6a3ce929d0e0e4736",
+      );
+
+      // 8-byte span id -> 12-char base64 -> 16-char hex
+      const spanIdBytes: Buffer = Buffer.from("00f067aa0ba902b7", "hex");
+      expect(Text.convertOtlpIdToHex(spanIdBytes.toString("base64"))).toEqual(
+        "00f067aa0ba902b7",
+      );
+    });
+
+    test("returns empty string for missing ids", () => {
+      expect(Text.convertOtlpIdToHex(undefined)).toEqual("");
+      expect(Text.convertOtlpIdToHex("")).toEqual("");
+    });
+
+    test("hex detection requires the exact id lengths — other hex-looking strings still take the base64 path", () => {
+      /*
+       * A 24-char hex-only string is a valid base64 payload and is NOT
+       * an OTLP hex id (ids are exactly 16 or 32 chars), so it must be
+       * treated as base64 — same behaviour as convertBase64ToHex.
+       */
+      const ambiguous: string = "abcdefabcdefabcdefabcdef";
+      expect(Text.convertOtlpIdToHex(ambiguous)).toEqual(
+        Text.convertBase64ToHex(ambiguous),
+      );
+    });
+  });
 });

package/Tests/Utils/ModelImportExport.test.ts

@@ -0,0 +1,366 @@
+import Dashboard from "../../Models/DatabaseModels/Dashboard";
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import ScheduledMaintenanceTemplate from "../../Models/DatabaseModels/ScheduledMaintenanceTemplate";
+import StatusPage from "../../Models/DatabaseModels/StatusPage";
+import EventInterval from "../../Types/Events/EventInterval";
+import Recurring from "../../Types/Events/Recurring";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import ModelImportExport, {
+  MODEL_EXPORT_FILE_TYPE,
+  MODEL_EXPORT_SCHEMA_VERSION,
+} from "../../Utils/ModelImportExport";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ModelImportExport", () => {
+  describe("getImportExportableColumnNames", () => {
+    test("should include user-editable configuration columns for Dashboard", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Dashboard);
+
+      expect(columns).toContain("name");
+      expect(columns).toContain("description");
+      expect(columns).toContain("dashboardViewConfig");
+    });
+
+    test("should exclude server-controlled and system columns", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Dashboard);
+
+      expect(columns).not.toContain("_id");
+      expect(columns).not.toContain("createdAt");
+      expect(columns).not.toContain("updatedAt");
+      expect(columns).not.toContain("deletedAt");
+      expect(columns).not.toContain("version");
+      expect(columns).not.toContain("slug");
+    });
+
+    test("should exclude the tenant column", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Dashboard);
+
+      expect(columns).not.toContain("projectId");
+    });
+
+    test("should exclude entity relations and their foreign key columns", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Dashboard);
+
+      expect(columns).not.toContain("labels");
+      expect(columns).not.toContain("createdByUser");
+      expect(columns).not.toContain("createdByUserId");
+      expect(columns).not.toContain("deletedByUser");
+      expect(columns).not.toContain("deletedByUserId");
+      expect(columns).not.toContain("logoFile");
+      expect(columns).not.toContain("logoFileId");
+    });
+
+    test("should include monitor configuration columns", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Monitor);
+
+      expect(columns).toContain("name");
+      expect(columns).toContain("monitorType");
+      expect(columns).toContain("monitorSteps");
+      expect(columns).not.toContain("currentMonitorStatusId");
+      expect(columns).not.toContain("projectId");
+      expect(columns).not.toContain("slug");
+    });
+
+    test("should exclude status page foreign keys and relations", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(StatusPage);
+
+      expect(columns).toContain("name");
+      expect(columns).not.toContain("projectId");
+      expect(columns).not.toContain("labels");
+      expect(columns).not.toContain("faviconFileId");
+    });
+
+    test("should exclude plain-text credentials via the per-table exclusion list", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(StatusPage);
+
+      expect(columns).not.toContain("embeddedOverallStatusToken");
+    });
+
+    test("should exclude monitor runtime-state columns", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Monitor);
+
+      expect(columns).not.toContain("incomingMonitorRequest");
+      expect(columns).not.toContain("serverMonitorResponse");
+      expect(columns).not.toContain("incomingRequestMonitorHeartbeatCheckedAt");
+      expect(columns).not.toContain("serverMonitorRequestReceivedAt");
+      expect(columns).not.toContain("telemetryMonitorNextMonitorAt");
+      expect(columns).not.toContain("telemetryMonitorLastMonitorAt");
+    });
+  });
+
+  describe("getImportExportSelect", () => {
+    test("should build a select object from exportable columns", () => {
+      const select: JSONObject = ModelImportExport.getImportExportSelect(
+        Dashboard,
+      ) as JSONObject;
+
+      expect(select["name"]).toBe(true);
+      expect(select["dashboardViewConfig"]).toBe(true);
+      expect(select["_id"]).toBeUndefined();
+      expect(select["projectId"]).toBeUndefined();
+    });
+  });
+
+  describe("buildExportEnvelope and toExportJSON", () => {
+    test("should build a valid envelope and strip non-exportable columns", () => {
+      const dashboard: Dashboard = new Dashboard();
+      dashboard.name = "My Dashboard";
+      dashboard.description = "My Description";
+      dashboard._id = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
+      dashboard.projectId = new ObjectID(
+        "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+      );
+
+      const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+        modelType: Dashboard,
+        items: [dashboard],
+        exportedAt: new Date("2026-06-11T00:00:00.000Z"),
+      });
+
+      expect(envelope["fileType"]).toBe(MODEL_EXPORT_FILE_TYPE);
+      expect(envelope["schemaVersion"]).toBe(MODEL_EXPORT_SCHEMA_VERSION);
+      expect(envelope["resourceType"]).toBe(new Dashboard().tableName);
+      expect(envelope["exportedAt"]).toBe("2026-06-11T00:00:00.000Z");
+
+      const items: Array<JSONObject> = envelope["items"] as Array<JSONObject>;
+      expect(items).toHaveLength(1);
+      expect(items[0]!["name"]).toBe("My Dashboard");
+      expect(items[0]!["description"]).toBe("My Description");
+      expect(items[0]!["_id"]).toBeUndefined();
+      expect(items[0]!["projectId"]).toBeUndefined();
+    });
+  });
+
+  describe("parseImportPayload", () => {
+    test("should accept a valid envelope", () => {
+      const items: Array<JSONObject> = ModelImportExport.parseImportPayload({
+        modelType: Dashboard,
+        payload: {
+          fileType: MODEL_EXPORT_FILE_TYPE,
+          schemaVersion: MODEL_EXPORT_SCHEMA_VERSION,
+          resourceType: new Dashboard().tableName!,
+          items: [{ name: "Imported Dashboard" }],
+        },
+      });
+
+      expect(items).toHaveLength(1);
+      expect(items[0]!["name"]).toBe("Imported Dashboard");
+    });
+
+    test("should accept a plain array of items", () => {
+      const items: Array<JSONObject> = ModelImportExport.parseImportPayload({
+        modelType: Dashboard,
+        payload: [{ name: "One" }, { name: "Two" }],
+      });
+
+      expect(items).toHaveLength(2);
+    });
+
+    test("should accept a single bare item object", () => {
+      const items: Array<JSONObject> = ModelImportExport.parseImportPayload({
+        modelType: Dashboard,
+        payload: { name: "Only One" },
+      });
+
+      expect(items).toHaveLength(1);
+    });
+
+    test("should reject an envelope for a different resource type", () => {
+      expect(() => {
+        ModelImportExport.parseImportPayload({
+          modelType: Dashboard,
+          payload: {
+            fileType: MODEL_EXPORT_FILE_TYPE,
+            resourceType: new Monitor().tableName!,
+            items: [{ name: "A Monitor" }],
+          },
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("should reject an envelope with no items", () => {
+      expect(() => {
+        ModelImportExport.parseImportPayload({
+          modelType: Dashboard,
+          payload: {
+            fileType: MODEL_EXPORT_FILE_TYPE,
+            resourceType: new Dashboard().tableName!,
+            items: [],
+          },
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("should reject items that are not objects", () => {
+      expect(() => {
+        ModelImportExport.parseImportPayload({
+          modelType: Dashboard,
+          payload: ["not-an-object"] as any,
+        });
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("fromImportJSON", () => {
+    test("should build a model with only importable columns", () => {
+      const item: Dashboard = ModelImportExport.fromImportJSON({
+        json: {
+          _id: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+          id: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+          slug: "my-dashboard",
+          projectId: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+          createdAt: "2026-01-01T00:00:00.000Z",
+          name: "My Dashboard",
+          description: "My Description",
+          dashboardViewConfig: { components: [], heightInDashboardUnits: 60 },
+          unknownColumn: "should be dropped",
+        },
+        modelType: Dashboard,
+      });
+
+      expect(item.name).toBe("My Dashboard");
+      expect(item.description).toBe("My Description");
+      expect(item.dashboardViewConfig).toBeDefined();
+      expect(item._id).toBeUndefined();
+      expect(item.projectId).toBeUndefined();
+      expect(item.slug).toBeUndefined();
+      expect(item.createdAt).toBeUndefined();
+      expect((item as any)["unknownColumn"]).toBeUndefined();
+    });
+
+    test("should round-trip an exported dashboard back into a creatable model", () => {
+      const original: Dashboard = new Dashboard();
+      original.name = "Round Trip";
+      original.description = "Round trip description";
+
+      const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+        modelType: Dashboard,
+        items: [original],
+        exportedAt: new Date(),
+      });
+
+      const itemJsons: Array<JSONObject> = ModelImportExport.parseImportPayload(
+        {
+          modelType: Dashboard,
+          payload: envelope,
+        },
+      );
+
+      const imported: Dashboard = ModelImportExport.fromImportJSON({
+        json: itemJsons[0]!,
+        modelType: Dashboard,
+      });
+
+      expect(imported.name).toBe("Round Trip");
+      expect(imported.description).toBe("Round trip description");
+      expect(imported._id).toBeUndefined();
+    });
+
+    test("should advance past recurring dates for scheduled maintenance templates", () => {
+      const dayInMs: number = 24 * 60 * 60 * 1000;
+
+      const template: ScheduledMaintenanceTemplate =
+        new ScheduledMaintenanceTemplate();
+      template.templateName = "Weekly Maintenance";
+      template.isRecurringEvent = true;
+
+      const recurring: Recurring = new Recurring();
+      recurring.intervalType = EventInterval.Week;
+      recurring.intervalCount = new PositiveNumber(1);
+      template.recurringInterval = recurring;
+
+      const pastScheduledAt: Date = new Date(Date.now() - 30 * dayInMs);
+      const pastStartsAt: Date = new Date(Date.now() - 29 * dayInMs);
+      const pastEndsAt: Date = new Date(
+        pastStartsAt.getTime() + 2 * 60 * 60 * 1000,
+      );
+
+      template.firstEventScheduledAt = pastScheduledAt;
+      template.firstEventStartsAt = pastStartsAt;
+      template.firstEventEndsAt = pastEndsAt;
+
+      const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+        modelType: ScheduledMaintenanceTemplate,
+        items: [template],
+        exportedAt: new Date(),
+      });
+
+      const itemJsons: Array<JSONObject> = ModelImportExport.parseImportPayload(
+        {
+          modelType: ScheduledMaintenanceTemplate,
+          payload: envelope,
+        },
+      );
+
+      const imported: ScheduledMaintenanceTemplate =
+        ModelImportExport.fromImportJSON({
+          json: itemJsons[0]!,
+          modelType: ScheduledMaintenanceTemplate,
+        });
+
+      expect(imported.firstEventScheduledAt!.getTime()).toBeGreaterThan(
+        Date.now(),
+      );
+      expect(imported.firstEventStartsAt!.getTime()).toBeGreaterThan(
+        Date.now(),
+      );
+      expect(imported.firstEventEndsAt!.getTime()).toBeGreaterThan(Date.now());
+
+      // offsets between the dates are preserved.
+      expect(
+        imported.firstEventStartsAt!.getTime() -
+          imported.firstEventScheduledAt!.getTime(),
+      ).toBe(pastStartsAt.getTime() - pastScheduledAt.getTime());
+      expect(
+        imported.firstEventEndsAt!.getTime() -
+          imported.firstEventStartsAt!.getTime(),
+      ).toBe(pastEndsAt.getTime() - pastStartsAt.getTime());
+    });
+
+    test("should leave future recurring dates unchanged", () => {
+      const dayInMs: number = 24 * 60 * 60 * 1000;
+
+      const template: ScheduledMaintenanceTemplate =
+        new ScheduledMaintenanceTemplate();
+      template.templateName = "Future Maintenance";
+      template.isRecurringEvent = true;
+
+      const recurring: Recurring = new Recurring();
+      recurring.intervalType = EventInterval.Day;
+      recurring.intervalCount = new PositiveNumber(1);
+      template.recurringInterval = recurring;
+
+      const futureScheduledAt: Date = new Date(Date.now() + 10 * dayInMs);
+      template.firstEventScheduledAt = futureScheduledAt;
+      template.firstEventStartsAt = new Date(Date.now() + 11 * dayInMs);
+      template.firstEventEndsAt = new Date(Date.now() + 12 * dayInMs);
+
+      const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+        modelType: ScheduledMaintenanceTemplate,
+        items: [template],
+        exportedAt: new Date(),
+      });
+
+      const imported: ScheduledMaintenanceTemplate =
+        ModelImportExport.fromImportJSON({
+          json: (envelope["items"] as Array<JSONObject>)[0]!,
+          modelType: ScheduledMaintenanceTemplate,
+        });
+
+      expect(imported.firstEventScheduledAt!.getTime()).toBe(
+        futureScheduledAt.getTime(),
+      );
+    });
+  });
+});