@oneuptime/common 12.0.1 → 12.0.3

package/Tests/Utils/Dashboard/Components/DashboardComponentsUtil.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "@jest/globals";
+import DashboardComponentsUtil from "../../../../Utils/Dashboard/Components/Index";
+import DashboardComponentType from "../../../../Types/Dashboard/DashboardComponentType";
+import {
+  ComponentArgument,
+  ComponentInputType,
+} from "../../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardBaseComponent from "../../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+
+/*
+ * DashboardComponentsUtil.getComponentSettingsArguments is the single dispatch
+ * from a widget's type to the config-form fields the dashboard editor renders
+ * for it. It is a long if/else chain that ends in `throw BadDataException`, so
+ * the failure mode it invites is a real one: add a widget to the
+ * DashboardComponentType enum, ship the component util, and forget the branch
+ * here — every attempt to configure that widget then throws at runtime with no
+ * compiler warning, because the chain has no exhaustiveness check.
+ *
+ * This suite is that missing exhaustiveness check. It also validates the shape
+ * of what every branch returns, so a malformed argument list (a duplicate id
+ * that silently drops a form field, an empty label) fails here instead of in
+ * the editor.
+ */
+
+const ALL_TYPES: Array<DashboardComponentType> = Object.values(
+  DashboardComponentType,
+);
+
+const VALID_INPUT_TYPES: Set<string> = new Set<string>(
+  Object.values(ComponentInputType),
+);
+
+describe("DashboardComponentsUtil.getComponentSettingsArguments", () => {
+  // Sanity: the enum is non-trivial, so an empty loop can't vacuously pass.
+  test("there is more than one dashboard component type to cover", () => {
+    expect(ALL_TYPES.length).toBeGreaterThan(1);
+  });
+
+  test.each(ALL_TYPES)(
+    "%s is wired into the dispatcher and returns an argument array",
+    (type: DashboardComponentType) => {
+      // The whole point: no enum member may fall through to BadDataException.
+      const args: Array<ComponentArgument<DashboardBaseComponent>> =
+        DashboardComponentsUtil.getComponentSettingsArguments(type);
+      expect(Array.isArray(args)).toBe(true);
+    },
+  );
+
+  test.each(ALL_TYPES)(
+    "every config argument for %s is well-formed",
+    (type: DashboardComponentType) => {
+      const args: Array<ComponentArgument<DashboardBaseComponent>> =
+        DashboardComponentsUtil.getComponentSettingsArguments(type);
+
+      for (const arg of args) {
+        // A blank label renders an unlabeled form field.
+        expect(typeof arg.name).toBe("string");
+        expect(arg.name.length).toBeGreaterThan(0);
+
+        /*
+         * id is the key the entered value is stored under; empty means the
+         * value has nowhere to go.
+         */
+        expect(typeof arg.id).toBe("string");
+        expect(String(arg.id).length).toBeGreaterThan(0);
+
+        /*
+         * required drives validation; it must be an actual boolean, not
+         * undefined coerced as falsy.
+         */
+        expect(typeof arg.required).toBe("boolean");
+
+        // An unknown input type renders no editor at all.
+        expect(VALID_INPUT_TYPES.has(arg.type)).toBe(true);
+      }
+    },
+  );
+
+  test.each(ALL_TYPES)(
+    "%s has no duplicate argument ids",
+    (type: DashboardComponentType) => {
+      const args: Array<ComponentArgument<DashboardBaseComponent>> =
+        DashboardComponentsUtil.getComponentSettingsArguments(type);
+
+      const ids: Array<string> = args.map(
+        (a: ComponentArgument<DashboardBaseComponent>) => {
+          return String(a.id);
+        },
+      );
+      // A duplicate id means the second field overwrites the first's value.
+      expect(new Set<string>(ids).size).toBe(ids.length);
+    },
+  );
+
+  test("an unknown component type is rejected with BadDataException", () => {
+    expect(() => {
+      return DashboardComponentsUtil.getComponentSettingsArguments(
+        "NotARealComponentType" as DashboardComponentType,
+      );
+    }).toThrow(BadDataException);
+  });
+
+  test("calling twice returns equivalent, independent argument arrays", () => {
+    /*
+     * The editor may request the arguments repeatedly; each call must yield a
+     * fresh array so mutating one rendering cannot corrupt the next.
+     */
+    const first: Array<ComponentArgument<DashboardBaseComponent>> =
+      DashboardComponentsUtil.getComponentSettingsArguments(
+        DashboardComponentType.Text,
+      );
+    const second: Array<ComponentArgument<DashboardBaseComponent>> =
+      DashboardComponentsUtil.getComponentSettingsArguments(
+        DashboardComponentType.Text,
+      );
+    expect(second).toEqual(first);
+    expect(second).not.toBe(first);
+  });
+});

package/Tests/Utils/Dashboard/DashboardNetworkMapComponent.test.ts

@@ -0,0 +1,327 @@
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+  EntityFilterModelType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardBaseComponent from "../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import DashboardNetworkMapComponent from "../../../Types/Dashboard/DashboardComponents/DashboardNetworkMapComponent";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import { ObjectType } from "../../../Types/JSON";
+import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
+import DashboardComponentsUtil from "../../../Utils/Dashboard/Components/Index";
+import DashboardNetworkMapComponentUtil, {
+  DEFAULT_MAX_SITES,
+} from "../../../Utils/Dashboard/Components/DashboardNetworkMapComponent";
+
+type ArgumentIds = keyof DashboardNetworkMapComponent["arguments"];
+
+function getArguments(): Array<
+  ComponentArgument<DashboardNetworkMapComponent>
+> {
+  return DashboardNetworkMapComponentUtil.getComponentConfigArguments();
+}
+
+function getArgumentById(
+  id: ArgumentIds,
+): ComponentArgument<DashboardNetworkMapComponent> {
+  const found: ComponentArgument<DashboardNetworkMapComponent> | undefined =
+    getArguments().find(
+      (arg: ComponentArgument<DashboardNetworkMapComponent>) => {
+        return arg.id === id;
+      },
+    );
+
+  if (!found) {
+    throw new Error(`No Network Map widget argument declared with id "${id}"`);
+  }
+
+  return found;
+}
+
+function getDropdownValues(id: ArgumentIds): Array<string> {
+  return (getArgumentById(id).dropdownOptions || []).map(
+    (option: DropdownOption): string => {
+      return String(option.value);
+    },
+  );
+}
+
+describe("DashboardNetworkMapComponentUtil", () => {
+  describe("getDefaultComponent", () => {
+    it("declares its componentType as NetworkMap so the renderer dispatch matches", () => {
+      expect(
+        DashboardNetworkMapComponentUtil.getDefaultComponent().componentType,
+      ).toBe(DashboardComponentType.NetworkMap);
+    });
+
+    it("marks itself as a dashboard component so it survives config serialization", () => {
+      expect(DashboardNetworkMapComponentUtil.getDefaultComponent()._type).toBe(
+        ObjectType.DashboardComponent,
+      );
+    });
+
+    it("places a 6x5 tile at the canvas origin", () => {
+      const component: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+
+      expect(component.widthInDashboardUnits).toBe(6);
+      expect(component.heightInDashboardUnits).toBe(5);
+      expect(component.topInDashboardUnits).toBe(0);
+      expect(component.leftInDashboardUnits).toBe(0);
+    });
+
+    /*
+     * The world is roughly 2:1, so a tile that is allowed to be short and
+     * wide letterboxes the map into an unreadable strip. The minimum has to
+     * bound BOTH axes, and the default has to sit at or above it — a widget
+     * that spawns below its own minimum is one the resize handles then
+     * refuse to shrink.
+     */
+    it("cannot be resized below a square-ish 4x4, and spawns at or above that", () => {
+      const component: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+
+      expect(component.minWidthInDashboardUnits).toBe(4);
+      expect(component.minHeightInDashboardUnits).toBe(4);
+      expect(component.widthInDashboardUnits).toBeGreaterThanOrEqual(
+        component.minWidthInDashboardUnits,
+      );
+      expect(component.heightInDashboardUnits).toBeGreaterThanOrEqual(
+        component.minHeightInDashboardUnits,
+      );
+    });
+
+    it("fits inside the 12-unit dashboard grid", () => {
+      const component: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+
+      expect(
+        component.leftInDashboardUnits + component.widthInDashboardUnits,
+      ).toBeLessThanOrEqual(12);
+    });
+
+    it("opens on the map rather than the list, with names on and the row cap seeded", () => {
+      const component: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+
+      expect(component.arguments.viewMode).toBe("map");
+      expect(component.arguments.showLabels).toBe(true);
+      expect(component.arguments.maxSites).toBe(DEFAULT_MAX_SITES);
+    });
+
+    it("seeds no filters, so a freshly added widget shows the whole estate", () => {
+      const component: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+
+      expect(component.arguments.statusFilter).toBeUndefined();
+      expect(component.arguments.networkSiteTypeIds).toBeUndefined();
+    });
+
+    /*
+     * Two widgets dropped on the same dashboard must not share an id — the
+     * canvas keys, selects and persists components by it.
+     */
+    it("generates a fresh component id on every call", () => {
+      const first: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+      const second: DashboardNetworkMapComponent =
+        DashboardNetworkMapComponentUtil.getDefaultComponent();
+
+      expect(first.componentId.toString()).not.toBe(
+        second.componentId.toString(),
+      );
+    });
+
+    it("caps the fetch at a bounded number of sites", () => {
+      expect(DEFAULT_MAX_SITES).toBeGreaterThan(0);
+      expect(Number.isInteger(DEFAULT_MAX_SITES)).toBe(true);
+    });
+  });
+
+  describe("getComponentConfigArguments", () => {
+    it("declares exactly the arguments the widget reads", () => {
+      const ids: Array<unknown> = getArguments().map(
+        (arg: ComponentArgument<DashboardNetworkMapComponent>) => {
+          return arg.id;
+        },
+      );
+
+      expect(ids).toEqual([
+        "title",
+        "viewMode",
+        "maxSites",
+        "showLabels",
+        "networkSiteTypeIds",
+        "statusFilter",
+      ]);
+    });
+
+    it("declares no duplicate argument ids", () => {
+      const ids: Array<unknown> = getArguments().map(
+        (arg: ComponentArgument<DashboardNetworkMapComponent>) => {
+          return arg.id;
+        },
+      );
+
+      expect(new Set(ids).size).toBe(ids.length);
+    });
+
+    it("gives every argument a name, a description and no required flag", () => {
+      for (const arg of getArguments()) {
+        expect(arg.name.trim().length).toBeGreaterThan(0);
+        expect(arg.description.trim().length).toBeGreaterThan(0);
+        /*
+         * Every argument has a working default, so none of them may be
+         * required — a required field with a default is a form the user
+         * cannot submit without re-entering what is already true.
+         */
+        expect(arg.required).toBe(false);
+      }
+    });
+
+    it("types each argument as the input the settings form should render", () => {
+      expect(getArgumentById("title").type).toBe(ComponentInputType.Text);
+      expect(getArgumentById("viewMode").type).toBe(
+        ComponentInputType.Dropdown,
+      );
+      expect(getArgumentById("maxSites").type).toBe(ComponentInputType.Number);
+      expect(getArgumentById("showLabels").type).toBe(
+        ComponentInputType.Boolean,
+      );
+      expect(getArgumentById("networkSiteTypeIds").type).toBe(
+        ComponentInputType.EntityMultiSelectDropdown,
+      );
+      expect(getArgumentById("statusFilter").type).toBe(
+        ComponentInputType.Dropdown,
+      );
+    });
+
+    /*
+     * The site-type picker has to name a model the EntityFilterDropdown
+     * switch knows about, or it throws when the settings modal opens.
+     */
+    it("binds the site-type picker to the NetworkSiteType lookup table", () => {
+      expect(getArgumentById("networkSiteTypeIds").entityFilterModelType).toBe(
+        EntityFilterModelType.NetworkSiteType,
+      );
+    });
+
+    it("gives only the entity picker an entityFilterModelType", () => {
+      for (const arg of getArguments()) {
+        if (arg.id === "networkSiteTypeIds") {
+          continue;
+        }
+        expect(arg.entityFilterModelType).toBeUndefined();
+      }
+    });
+
+    it("offers exactly the two view modes the renderer implements", () => {
+      expect(getDropdownValues("viewMode")).toEqual(["map", "list"]);
+    });
+
+    /*
+     * The empty option is what lets somebody UNDO a status filter. Without
+     * it the only way back to "all sites" is to delete the widget.
+     */
+    it("offers an empty status option so the filter can be cleared", () => {
+      expect(getDropdownValues("statusFilter")).toEqual([
+        "",
+        "down",
+        "operational",
+      ]);
+    });
+
+    it("gives every dropdown option a non-empty label", () => {
+      for (const arg of getArguments()) {
+        for (const option of arg.dropdownOptions || []) {
+          expect(String(option.label).trim().length).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    it("splits the arguments into a Display section and a collapsed Filters section", () => {
+      const sectionOf: (
+        id: ArgumentIds,
+      ) => ComponentArgumentSection | undefined = (
+        id: ArgumentIds,
+      ): ComponentArgumentSection | undefined => {
+        return getArgumentById(id).section;
+      };
+
+      for (const id of [
+        "title",
+        "viewMode",
+        "maxSites",
+        "showLabels",
+      ] as Array<ArgumentIds>) {
+        expect(sectionOf(id)?.name).toBe("Display Options");
+      }
+
+      for (const id of [
+        "networkSiteTypeIds",
+        "statusFilter",
+      ] as Array<ArgumentIds>) {
+        expect(sectionOf(id)?.name).toBe("Filters");
+      }
+
+      expect(sectionOf("title")?.order).toBeLessThan(
+        sectionOf("statusFilter")?.order as number,
+      );
+      expect(sectionOf("statusFilter")?.defaultCollapsed).toBe(true);
+    });
+
+    it("returns a fresh array each call so a caller cannot mutate the declaration", () => {
+      const first: Array<ComponentArgument<DashboardNetworkMapComponent>> =
+        getArguments();
+      first.pop();
+
+      expect(getArguments()).toHaveLength(6);
+    });
+  });
+
+  /*
+   * These go through the registry's public lookup rather than the util
+   * directly, so forgetting to wire DashboardComponentType.NetworkMap into
+   * Common/Utils/Dashboard/Components/Index.ts fails the suite. Nothing else
+   * in the codebase asserts that registry is exhaustive.
+   */
+  describe("registration in DashboardComponentsUtil", () => {
+    it("resolves DashboardComponentType.NetworkMap instead of throwing", () => {
+      expect(() => {
+        return DashboardComponentsUtil.getComponentSettingsArguments(
+          DashboardComponentType.NetworkMap,
+        );
+      }).not.toThrow();
+    });
+
+    it("returns the Network Map widget's own arguments for that type", () => {
+      const fromRegistry: Array<ComponentArgument<DashboardBaseComponent>> =
+        DashboardComponentsUtil.getComponentSettingsArguments(
+          DashboardComponentType.NetworkMap,
+        );
+
+      expect(
+        fromRegistry.map(
+          (arg: ComponentArgument<DashboardBaseComponent>): unknown => {
+            return arg.id;
+          },
+        ),
+      ).toEqual(
+        getArguments().map(
+          (arg: ComponentArgument<DashboardNetworkMapComponent>): unknown => {
+            return arg.id;
+          },
+        ),
+      );
+    });
+
+    it("still throws for a component type that is not registered", () => {
+      expect(() => {
+        return DashboardComponentsUtil.getComponentSettingsArguments(
+          "NotARealWidget" as DashboardComponentType,
+        );
+      }).toThrow();
+    });
+  });
+});

package/Tests/Utils/StatusPage/ReportPeriod.test.ts

@@ -0,0 +1,218 @@
+/*
+ * The window a scheduled status page report covers.
+ *
+ * The reported bug: "is there a way to have the reports be sent out monthly,
+ * i.e. to show July 1st - July 31st?" - it was not, because the window was
+ * always "the last N days counted back from whenever the cron fired", so a
+ * monthly report sent on 1 Aug covered 2 Jul - 1 Aug and never lined up with a
+ * calendar month. These tests pin the calendar option that fixes it, the
+ * timezone the boundaries are resolved in, and the rolling behaviour that
+ * existing status pages keep.
+ */
+
+import OneUptimeDate from "../../../Types/Date";
+import EventInterval from "../../../Types/Events/EventInterval";
+import Recurring from "../../../Types/Events/Recurring";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import StatusPageReportPeriodType from "../../../Types/StatusPage/StatusPageReportPeriodType";
+import Timezone from "../../../Types/Timezone";
+import StatusPageReportPeriodUtil, {
+  StatusPageReportPeriod,
+} from "../../../Utils/StatusPage/ReportPeriod";
+import { describe, expect, test } from "@jest/globals";
+
+function every(intervalType: EventInterval, intervalCount: number): Recurring {
+  const recurring: Recurring = new Recurring();
+  recurring.intervalType = intervalType;
+  recurring.intervalCount = new PositiveNumber(intervalCount);
+  return recurring;
+}
+
+function iso(date: Date): string {
+  return date.toISOString();
+}
+
+describe("StatusPageReportPeriodUtil.getReportPeriod", () => {
+  describe("the previous calendar period", () => {
+    test("a monthly report sent in August covers all of July", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Month, 1),
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-08-01T09:00:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2026-07-01T00:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2026-07-31T23:59:59.999Z");
+      expect(period.periodName).toBe("July 2026");
+      expect(period.reportDates).toBe("Jul 1, 2026 - Jul 31, 2026");
+      expect(period.numberOfDays).toBe(31);
+    });
+
+    test("still covers July when the email goes out later in August", () => {
+      /*
+       * The period is the last WHOLE one, not "the month before this instant",
+       * so moving the send time inside August must not slide the window.
+       */
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Month, 1),
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-08-27T16:45:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2026-07-01T00:00:00.000Z");
+      expect(period.periodName).toBe("July 2026");
+    });
+
+    test("resolves the month boundary in the report timezone, not the server's", () => {
+      /*
+       * 1 Aug 03:00 UTC is still 31 Jul in New York, so a status page reporting
+       * in New York has not finished July yet and must report June.
+       */
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Month, 1),
+          timezone: Timezone.AmericaNew_York,
+          sentAt: OneUptimeDate.fromString("2026-08-01T03:00:00.000Z"),
+        });
+
+      // 1 Jun 00:00 EDT and 30 Jun 23:59:59.999 EDT, both UTC-4.
+      expect(iso(period.startDate)).toBe("2026-06-01T04:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2026-07-01T03:59:59.999Z");
+      expect(period.periodName).toBe("June 2026");
+    });
+
+    test("a quarterly report covers the three whole months before it", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Month, 3),
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-10-01T09:00:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2026-07-01T00:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2026-09-30T23:59:59.999Z");
+      // Three months have no single name a reader knows, so it stays a range.
+      expect(period.periodName).toBe("Jul 1, 2026 - Sep 30, 2026");
+    });
+
+    test("a weekly report covers Monday to Sunday", () => {
+      // Wednesday 5 Aug 2026.
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Week, 1),
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-08-05T09:00:00.000Z"),
+        });
+
+      // Monday 27 Jul through Sunday 2 Aug.
+      expect(iso(period.startDate)).toBe("2026-07-27T00:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2026-08-02T23:59:59.999Z");
+      expect(period.periodName).toBe("the week of Jul 27, 2026");
+      expect(period.numberOfDays).toBe(7);
+    });
+
+    test("a daily report covers yesterday", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Day, 1),
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-08-05T09:00:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2026-08-04T00:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2026-08-04T23:59:59.999Z");
+      expect(period.periodName).toBe("Aug 4, 2026");
+    });
+
+    test("a yearly report covers the previous calendar year", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          reportRecurringInterval: every(EventInterval.Year, 1),
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-01-01T00:05:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2025-01-01T00:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2025-12-31T23:59:59.999Z");
+      expect(period.periodName).toBe("2025");
+    });
+
+    test("falls back to a daily period when no frequency is configured", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.PreviousCalendarPeriod,
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-08-05T09:00:00.000Z"),
+        });
+
+      // Recurring's own default is every 1 day.
+      expect(iso(period.startDate)).toBe("2026-08-04T00:00:00.000Z");
+    });
+  });
+
+  describe("the rolling window", () => {
+    test("ends when the report is sent and runs back the configured days", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.Rolling,
+          reportDataInDays: 30,
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-07-30T09:00:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2026-06-30T09:00:00.000Z");
+      expect(iso(period.endDate)).toBe("2026-07-30T09:00:00.000Z");
+      expect(period.periodName).toBe("the last 30 days");
+    });
+
+    test("keeps the reportDates string custom email templates were written against", () => {
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          periodType: StatusPageReportPeriodType.Rolling,
+          reportDataInDays: 30,
+          timezone: Timezone.UTC,
+          sentAt: OneUptimeDate.fromString("2026-07-30T09:00:00.000Z"),
+        });
+
+      expect(period.reportDates).toBe("30 days (Jun 30, 2026 - Jul 30, 2026)");
+    });
+
+    test("is what a status page with no period configured gets", () => {
+      // Every column is null on status pages created before this setting existed.
+      const period: StatusPageReportPeriod =
+        StatusPageReportPeriodUtil.getReportPeriod({
+          sentAt: OneUptimeDate.fromString("2026-07-30T09:00:00.000Z"),
+        });
+
+      expect(iso(period.startDate)).toBe("2026-06-30T09:00:00.000Z");
+      expect(period.numberOfDays).toBe(
+        StatusPageReportPeriodUtil.DEFAULT_REPORT_DATA_IN_DAYS,
+      );
+      expect(period.timezone).toBe(Timezone.UTC);
+    });
+
+    test("refuses a zero, negative or non-numeric day count", () => {
+      for (const badValue of [0, -5, NaN, undefined]) {
+        const period: StatusPageReportPeriod =
+          StatusPageReportPeriodUtil.getReportPeriod({
+            periodType: StatusPageReportPeriodType.Rolling,
+            reportDataInDays: badValue as number,
+            sentAt: OneUptimeDate.fromString("2026-07-30T09:00:00.000Z"),
+          });
+
+        expect(period.numberOfDays).toBe(
+          StatusPageReportPeriodUtil.DEFAULT_REPORT_DATA_IN_DAYS,
+        );
+      }
+    });
+  });
+});