@oneuptime/common 12.0.24 → 12.0.26

package/Tests/Utils/NetworkSite/SiteUptimeUtil.test.ts

@@ -1,5 +1,8 @@
 import SiteUptimeUtil, {
+  DailyUptimeEntry,
+  SiteMaintenanceWindow,
   SiteStatusTimelineRow,
+  SiteUptimeMeasurement,
 } from "../../../Utils/NetworkSite/SiteUptimeUtil";
 
 const WINDOW_START: Date = new Date("2026-07-22T00:00:00Z");
@@ -281,3 +284,694 @@ describe("SiteUptimeUtil.calculateUptimePercent", () => {
     ).toBe(75);
   });
 });
+
+/*
+ * Maintenance exclusion and the daily strip (issue #3431).
+ *
+ * The rule under test, stated once: a maintenance window is subtracted from
+ * BOTH sides of the fraction. Subtracting it only from the downtime would
+ * report a planned outage as perfect uptime; subtracting it from neither is
+ * the behaviour the issue was filed about.
+ */
+
+const MS_IN_AN_HOUR: number = 60 * 60 * 1000;
+
+function maintenance(
+  fromHour: number,
+  toHour: number | null,
+): SiteMaintenanceWindow {
+  return {
+    startsAt: hoursAfterStart(fromHour),
+    endsAt: toHour === null ? null : hoursAfterStart(toHour),
+  };
+}
+
+describe("SiteUptimeUtil.calculateUptimePercent with maintenance", () => {
+  it("excludes maintenance downtime from BOTH the outage and the measured period", () => {
+    /*
+     * Two hours down, entirely inside a two-hour window. The day becomes 22
+     * hours long with nothing wrong in it — 100%, not 91.7% (down counted)
+     * and not 100% of 24 hours either, which would be the same number by
+     * accident here. The next test separates those two readings.
+     */
+    expect(
+      SiteUptimeUtil.calculateUptimePercent(
+        [
+          row({
+            startsAt: hoursAfterStart(2),
+            endsAt: hoursAfterStart(4),
+            isOperationalState: false,
+          }),
+        ],
+        WINDOW_START,
+        WINDOW_END,
+        [maintenance(2, 4)],
+      ),
+    ).toBe(100);
+  });
+
+  it("shrinks the denominator, so unplanned downtime beside a window weighs MORE", () => {
+    /*
+     * One hour of real outage in a day that also had 12 hours of planned
+     * work. Measured against the remaining 12 hours that is 91.67%, not the
+     * 95.83% you would get by leaving the denominator at 24. The site was
+     * only being watched for half the day; the failure should count against
+     * the half that was watched.
+     */
+    const percent: number = SiteUptimeUtil.calculateUptimePercent(
+      [
+        row({
+          startsAt: hoursAfterStart(20),
+          endsAt: hoursAfterStart(21),
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+      [maintenance(0, 12)],
+    );
+
+    expect(percent).toBeCloseTo((11 / 12) * 100, 6);
+  });
+
+  it("counts only the part of an outage that falls outside the window", () => {
+    /*
+     * Down 02:00-06:00, maintenance 02:00-04:00. Two hours count, out of a
+     * 22-hour measured period.
+     */
+    const percent: number = SiteUptimeUtil.calculateUptimePercent(
+      [
+        row({
+          startsAt: hoursAfterStart(2),
+          endsAt: hoursAfterStart(6),
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+      [maintenance(2, 4)],
+    );
+
+    expect(percent).toBeCloseTo((20 / 22) * 100, 6);
+  });
+
+  it("reports 100 when the whole window is maintenance", () => {
+    /*
+     * Nothing left to measure. Zero would be a lie (nothing unplanned
+     * failed) and NaN would poison every consumer.
+     */
+    expect(
+      SiteUptimeUtil.calculateUptimePercent(
+        [
+          row({
+            startsAt: WINDOW_START,
+            endsAt: WINDOW_END,
+            isOperationalState: false,
+          }),
+        ],
+        WINDOW_START,
+        WINDOW_END,
+        [maintenance(-5, 30)],
+      ),
+    ).toBe(100);
+  });
+
+  it("merges overlapping windows instead of double-subtracting them", () => {
+    /*
+     * 00:00-06:00 and 04:00-08:00 overlap. Subtracting both lengths would
+     * remove 10 hours from a 24-hour day rather than 8, and the whole
+     * fraction would be wrong.
+     */
+    const percent: number = SiteUptimeUtil.calculateUptimePercent(
+      [
+        row({
+          startsAt: hoursAfterStart(10),
+          endsAt: hoursAfterStart(12),
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+      [maintenance(0, 6), maintenance(4, 8)],
+    );
+
+    expect(percent).toBeCloseTo((14 / 16) * 100, 6);
+  });
+
+  it("an open-ended window runs to the end of the measured period", () => {
+    expect(
+      SiteUptimeUtil.calculateUptimePercent(
+        [
+          row({
+            startsAt: hoursAfterStart(20),
+            endsAt: null,
+            isOperationalState: false,
+          }),
+        ],
+        WINDOW_START,
+        WINDOW_END,
+        [maintenance(20, null)],
+      ),
+    ).toBe(100);
+  });
+
+  it("is unchanged by a window that does not overlap the measured period", () => {
+    const withoutWindow: number = SiteUptimeUtil.calculateUptimePercent(
+      [
+        row({
+          startsAt: hoursAfterStart(2),
+          endsAt: hoursAfterStart(4),
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+    );
+
+    const withWindow: number = SiteUptimeUtil.calculateUptimePercent(
+      [
+        row({
+          startsAt: hoursAfterStart(2),
+          endsAt: hoursAfterStart(4),
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+      [maintenance(-10, -5)],
+    );
+
+    expect(withWindow).toBe(withoutWindow);
+  });
+});
+
+describe("SiteUptimeUtil.isUnderMaintenanceAt", () => {
+  it("is true inside a window and false on its closing edge", () => {
+    expect(
+      SiteUptimeUtil.isUnderMaintenanceAt(
+        [maintenance(2, 4)],
+        hoursAfterStart(3),
+      ),
+    ).toBe(true);
+    // Half-open, matching how every other interval here is treated.
+    expect(
+      SiteUptimeUtil.isUnderMaintenanceAt(
+        [maintenance(2, 4)],
+        hoursAfterStart(4),
+      ),
+    ).toBe(false);
+    expect(
+      SiteUptimeUtil.isUnderMaintenanceAt(
+        [maintenance(2, 4)],
+        hoursAfterStart(2),
+      ),
+    ).toBe(true);
+  });
+
+  it("treats an open-ended window as still running", () => {
+    expect(
+      SiteUptimeUtil.isUnderMaintenanceAt(
+        [maintenance(2, null)],
+        hoursAfterStart(500),
+      ),
+    ).toBe(true);
+  });
+
+  it("is false with no windows", () => {
+    expect(SiteUptimeUtil.isUnderMaintenanceAt([], hoursAfterStart(3))).toBe(
+      false,
+    );
+  });
+});
+
+describe("SiteUptimeUtil.calculateDailyUptime", () => {
+  /*
+   * The strip exists because a 30-day average cannot show a bad day: a full
+   * day of outage moves it by 3.3 points. These pin that the per-day
+   * numbers actually separate the bad day out.
+   */
+  it("returns one entry per day, oldest first, each 24 hours long", () => {
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: new Date(WINDOW_END.getTime() - 30 * 24 * MS_IN_AN_HOUR),
+            endsAt: null,
+            isOperationalState: true,
+          }),
+        ],
+        days: 7,
+        endDate: WINDOW_END,
+      });
+
+    expect(entries).toHaveLength(7);
+    expect(entries[6]!.dayEnd.getTime()).toBe(WINDOW_END.getTime());
+    expect(entries[0]!.dayStart.getTime()).toBe(
+      WINDOW_END.getTime() - 7 * 24 * MS_IN_AN_HOUR,
+    );
+    for (const entry of entries) {
+      expect(entry.dayEnd.getTime() - entry.dayStart.getTime()).toBe(
+        24 * MS_IN_AN_HOUR,
+      );
+    }
+  });
+
+  it("isolates one bad day that the 30-day average would bury", () => {
+    /*
+     * Down for the whole of the day that ended 3 days ago. The 30-day
+     * figure reads 96.7% — noise. The strip reads 0% for that one bar.
+     */
+    const badDayEnd: Date = new Date(
+      WINDOW_END.getTime() - 3 * 24 * MS_IN_AN_HOUR,
+    );
+    const badDayStart: Date = new Date(
+      badDayEnd.getTime() - 24 * MS_IN_AN_HOUR,
+    );
+
+    const rows: Array<SiteStatusTimelineRow> = [
+      row({
+        startsAt: new Date(WINDOW_END.getTime() - 30 * 24 * MS_IN_AN_HOUR),
+        endsAt: badDayStart,
+        isOperationalState: true,
+      }),
+      row({
+        startsAt: badDayStart,
+        endsAt: badDayEnd,
+        isOperationalState: false,
+      }),
+      row({ startsAt: badDayEnd, endsAt: null, isOperationalState: true }),
+    ];
+
+    const monthly: number = SiteUptimeUtil.calculateUptimePercent(
+      rows,
+      new Date(WINDOW_END.getTime() - 30 * 24 * MS_IN_AN_HOUR),
+      WINDOW_END,
+    );
+    expect(monthly).toBeCloseTo((29 / 30) * 100, 6);
+
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: rows,
+        days: 30,
+        endDate: WINDOW_END,
+      });
+
+    // entries[26] is the day ending 3 days before the window end.
+    const badEntry: DailyUptimeEntry = entries[26]!;
+    expect(badEntry.dayEnd.getTime()).toBe(badDayEnd.getTime());
+    expect(badEntry.uptimePercent).toBe(0);
+    expect(entries[27]!.uptimePercent).toBe(100);
+  });
+
+  it("marks a day entirely inside a maintenance window rather than calling it perfect", () => {
+    const rows: Array<SiteStatusTimelineRow> = [
+      row({
+        startsAt: new Date(WINDOW_END.getTime() - 5 * 24 * MS_IN_AN_HOUR),
+        endsAt: null,
+        isOperationalState: false,
+      }),
+    ];
+
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: rows,
+        days: 3,
+        endDate: WINDOW_END,
+        maintenanceWindows: [
+          {
+            startsAt: new Date(WINDOW_END.getTime() - 2 * 24 * MS_IN_AN_HOUR),
+            endsAt: new Date(WINDOW_END.getTime() - 1 * 24 * MS_IN_AN_HOUR),
+          },
+        ],
+      });
+
+    const maintainedDay: DailyUptimeEntry = entries[1]!;
+    expect(maintainedDay.isFullyMaintained).toBe(true);
+    expect(maintainedDay.uptimePercent).toBeNull();
+    expect(maintainedDay.maintenanceInMs).toBe(24 * MS_IN_AN_HOUR);
+    // The neighbouring days are still measured, and still down.
+    expect(entries[0]!.uptimePercent).toBe(0);
+    expect(entries[2]!.uptimePercent).toBe(0);
+  });
+
+  it("reports days before the timeline begins as uncovered, not as 100%", () => {
+    /*
+     * A site attached yesterday must not draw a solid green month. "We were
+     * not watching" is a different fact from "nothing was wrong".
+     */
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: new Date(WINDOW_END.getTime() - 1 * 24 * MS_IN_AN_HOUR),
+            endsAt: null,
+            isOperationalState: true,
+          }),
+        ],
+        days: 5,
+        endDate: WINDOW_END,
+      });
+
+    expect(entries[0]!.hasTimelineCoverage).toBe(false);
+    expect(entries[0]!.uptimePercent).toBeNull();
+    expect(entries[4]!.hasTimelineCoverage).toBe(true);
+    expect(entries[4]!.uptimePercent).toBe(100);
+  });
+
+  it("subtracts a partial maintenance window from a day's denominator", () => {
+    /*
+     * Six hours of maintenance and three hours of unplanned outage in the
+     * last day: 15 good hours out of 18 measured, not 21 out of 24.
+     */
+    const dayStart: Date = new Date(WINDOW_END.getTime() - 24 * MS_IN_AN_HOUR);
+
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: new Date(WINDOW_END.getTime() - 10 * 24 * MS_IN_AN_HOUR),
+            endsAt: new Date(dayStart.getTime() + 6 * MS_IN_AN_HOUR),
+            isOperationalState: true,
+          }),
+          row({
+            startsAt: new Date(dayStart.getTime() + 6 * MS_IN_AN_HOUR),
+            endsAt: new Date(dayStart.getTime() + 9 * MS_IN_AN_HOUR),
+            isOperationalState: false,
+          }),
+          row({
+            startsAt: new Date(dayStart.getTime() + 9 * MS_IN_AN_HOUR),
+            endsAt: null,
+            isOperationalState: true,
+          }),
+        ],
+        days: 1,
+        endDate: WINDOW_END,
+        maintenanceWindows: [
+          {
+            startsAt: dayStart,
+            endsAt: new Date(dayStart.getTime() + 6 * MS_IN_AN_HOUR),
+          },
+        ],
+      });
+
+    const entry: DailyUptimeEntry = entries[0]!;
+    expect(entry.isFullyMaintained).toBe(false);
+    expect(entry.maintenanceInMs).toBe(6 * MS_IN_AN_HOUR);
+    expect(entry.downtimeInMs).toBe(3 * MS_IN_AN_HOUR);
+    expect(entry.uptimePercent).toBeCloseTo((15 / 18) * 100, 6);
+  });
+
+  it("returns nothing for a non-positive day count", () => {
+    expect(
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [],
+        days: 0,
+        endDate: WINDOW_END,
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe("SiteUptimeUtil.subtractIntervals", () => {
+  it("punches every hole out of every interval", () => {
+    expect(
+      SiteUptimeUtil.subtractIntervals(
+        [{ startInMs: 0, endInMs: 100 }],
+        [
+          { startInMs: 10, endInMs: 20 },
+          { startInMs: 50, endInMs: 60 },
+        ],
+      ),
+    ).toEqual([
+      { startInMs: 0, endInMs: 10 },
+      { startInMs: 20, endInMs: 50 },
+      { startInMs: 60, endInMs: 100 },
+    ]);
+  });
+
+  it("merges overlapping holes before subtracting", () => {
+    expect(
+      SiteUptimeUtil.subtractIntervals(
+        [{ startInMs: 0, endInMs: 100 }],
+        [
+          { startInMs: 10, endInMs: 40 },
+          { startInMs: 30, endInMs: 60 },
+        ],
+      ),
+    ).toEqual([
+      { startInMs: 0, endInMs: 10 },
+      { startInMs: 60, endInMs: 100 },
+    ]);
+  });
+
+  it("returns the interval untouched when no hole overlaps it", () => {
+    expect(
+      SiteUptimeUtil.subtractIntervals(
+        [{ startInMs: 0, endInMs: 100 }],
+        [{ startInMs: 200, endInMs: 300 }],
+      ),
+    ).toEqual([{ startInMs: 0, endInMs: 100 }]);
+  });
+
+  it("removes an interval entirely covered by a hole", () => {
+    expect(
+      SiteUptimeUtil.subtractIntervals(
+        [{ startInMs: 10, endInMs: 20 }],
+        [{ startInMs: 0, endInMs: 100 }],
+      ),
+    ).toEqual([]);
+  });
+});
+
+/*
+ * measureUptime and the difference between "perfect" and "nothing to
+ * measure" (issue #3431, follow-up review).
+ *
+ * calculateUptimePercent has to return a number, so a period spent entirely
+ * inside a maintenance window comes back as 100. Rendering that as
+ * "100% uptime" for a site that was switched off all month is the exact
+ * misreading this feature exists to remove, so every UI caller reads
+ * measuredInMs and draws a dash instead.
+ */
+describe("SiteUptimeUtil.measureUptime", () => {
+  it("reports nothing measured for a fully-maintained period", () => {
+    const measurement: SiteUptimeMeasurement = SiteUptimeUtil.measureUptime(
+      [
+        row({
+          startsAt: WINDOW_START,
+          endsAt: WINDOW_END,
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+      [maintenance(-5, 30)],
+    );
+
+    expect(measurement.measuredInMs).toBe(0);
+    expect(measurement.downtimeInMs).toBe(0);
+    expect(measurement.maintenanceInMs).toBe(24 * MS_IN_AN_HOUR);
+    /*
+     * The scalar placeholder is still 100 — which is why callers must not
+     * read it without checking measuredInMs.
+     */
+    expect(measurement.uptimePercent).toBe(100);
+    expect(
+      SiteUptimeUtil.calculateUptimePercent(
+        [
+          row({
+            startsAt: WINDOW_START,
+            endsAt: WINDOW_END,
+            isOperationalState: false,
+          }),
+        ],
+        WINDOW_START,
+        WINDOW_END,
+        [maintenance(-5, 30)],
+      ),
+    ).toBe(100);
+  });
+
+  it("reports the evidence behind an ordinary measurement", () => {
+    const measurement: SiteUptimeMeasurement = SiteUptimeUtil.measureUptime(
+      [
+        row({
+          startsAt: hoursAfterStart(2),
+          endsAt: hoursAfterStart(6),
+          isOperationalState: false,
+        }),
+      ],
+      WINDOW_START,
+      WINDOW_END,
+      [maintenance(2, 4)],
+    );
+
+    expect(measurement.maintenanceInMs).toBe(2 * MS_IN_AN_HOUR);
+    expect(measurement.measuredInMs).toBe(22 * MS_IN_AN_HOUR);
+    expect(measurement.downtimeInMs).toBe(2 * MS_IN_AN_HOUR);
+    expect(measurement.uptimePercent).toBeCloseTo((20 / 22) * 100, 6);
+  });
+
+  it("reports nothing measured for an empty or inverted period", () => {
+    expect(
+      SiteUptimeUtil.measureUptime([], WINDOW_START, WINDOW_START).measuredInMs,
+    ).toBe(0);
+    expect(
+      SiteUptimeUtil.measureUptime([], WINDOW_END, WINDOW_START).measuredInMs,
+    ).toBe(0);
+  });
+
+  it("agrees with calculateUptimePercent wherever there IS something to measure", () => {
+    /*
+     * The scalar form is now a thin wrapper. If the two ever disagree, one
+     * of the surfaces reading them is showing a different number for the
+     * same site.
+     */
+    const rows: Array<SiteStatusTimelineRow> = [
+      row({
+        startsAt: hoursAfterStart(3),
+        endsAt: hoursAfterStart(9),
+        isOperationalState: false,
+      }),
+    ];
+    const windows: Array<SiteMaintenanceWindow> = [maintenance(4, 5)];
+
+    expect(
+      SiteUptimeUtil.measureUptime(rows, WINDOW_START, WINDOW_END, windows)
+        .uptimePercent,
+    ).toBe(
+      SiteUptimeUtil.calculateUptimePercent(
+        rows,
+        WINDOW_START,
+        WINDOW_END,
+        windows,
+      ),
+    );
+  });
+});
+
+describe("SiteUptimeUtil.trailingWindowStart", () => {
+  it("is exactly N times 24 hours, not a calendar day", () => {
+    /*
+     * The strip's buckets are fixed 24-hour slices. A calendar subtraction
+     * would make the "Last 24 Hours" card span 23 or 25 hours on the two
+     * days a year the clocks move, and disagree with the bar beside it.
+     */
+    for (const days of [1, 7, 30, 90]) {
+      expect(
+        WINDOW_END.getTime() -
+          SiteUptimeUtil.trailingWindowStart(WINDOW_END, days).getTime(),
+      ).toBe(days * 24 * MS_IN_AN_HOUR);
+    }
+  });
+
+  it("lines the daily card up with the newest strip bucket exactly", () => {
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: new Date(WINDOW_END.getTime() - 40 * 24 * MS_IN_AN_HOUR),
+            endsAt: null,
+            isOperationalState: true,
+          }),
+        ],
+        days: 30,
+        endDate: WINDOW_END,
+      });
+
+    const newest: DailyUptimeEntry = entries[entries.length - 1]!;
+    expect(newest.dayStart.getTime()).toBe(
+      SiteUptimeUtil.trailingWindowStart(WINDOW_END, 1).getTime(),
+    );
+    expect(newest.dayEnd.getTime()).toBe(WINDOW_END.getTime());
+  });
+});
+
+describe("SiteUptimeUtil.calculateDailyUptime partial coverage", () => {
+  it("scores the day the timeline BEGINS only over the part it can speak for", () => {
+    /*
+     * A site first rolled up 6 hours before the window end, and down for
+     * every one of those 6 hours. Measuring the whole 24 would score the 18
+     * hours before anyone was watching as up and report 75% for a day the
+     * site was down for all of the observed time.
+     */
+    const firstRowAt: Date = new Date(WINDOW_END.getTime() - 6 * MS_IN_AN_HOUR);
+
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: firstRowAt,
+            endsAt: null,
+            isOperationalState: false,
+          }),
+        ],
+        days: 1,
+        endDate: WINDOW_END,
+      });
+
+    expect(entries[0]!.hasTimelineCoverage).toBe(true);
+    expect(entries[0]!.uptimePercent).toBe(0);
+    expect(entries[0]!.downtimeInMs).toBe(6 * MS_IN_AN_HOUR);
+  });
+
+  it("scores a partially covered day that was healthy as fully up", () => {
+    const firstRowAt: Date = new Date(WINDOW_END.getTime() - 6 * MS_IN_AN_HOUR);
+
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({ startsAt: firstRowAt, endsAt: null, isOperationalState: true }),
+        ],
+        days: 1,
+        endDate: WINDOW_END,
+      });
+
+    expect(entries[0]!.uptimePercent).toBe(100);
+    expect(entries[0]!.downtimeInMs).toBe(0);
+  });
+
+  it("still reports a fully-covered day over the whole 24 hours", () => {
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: new Date(WINDOW_END.getTime() - 10 * 24 * MS_IN_AN_HOUR),
+            endsAt: new Date(WINDOW_END.getTime() - 6 * MS_IN_AN_HOUR),
+            isOperationalState: true,
+          }),
+          row({
+            startsAt: new Date(WINDOW_END.getTime() - 6 * MS_IN_AN_HOUR),
+            endsAt: null,
+            isOperationalState: false,
+          }),
+        ],
+        days: 1,
+        endDate: WINDOW_END,
+      });
+
+    // 18 good hours out of 24, not out of 6.
+    expect(entries[0]!.uptimePercent).toBeCloseTo((18 / 24) * 100, 6);
+  });
+
+  it("reports a day whose covered part is entirely maintenance as unmeasurable", () => {
+    const firstRowAt: Date = new Date(WINDOW_END.getTime() - 6 * MS_IN_AN_HOUR);
+
+    const entries: Array<DailyUptimeEntry> =
+      SiteUptimeUtil.calculateDailyUptime({
+        rows: [
+          row({
+            startsAt: firstRowAt,
+            endsAt: null,
+            isOperationalState: false,
+          }),
+        ],
+        days: 1,
+        endDate: WINDOW_END,
+        maintenanceWindows: [{ startsAt: firstRowAt, endsAt: null }],
+      });
+
+    expect(entries[0]!.uptimePercent).toBeNull();
+    expect(entries[0]!.isFullyMaintained).toBe(true);
+  });
+});