@oneuptime/common 13.0.8 → 14.0.0

package/Tests/Server/Services/MonitorProbeServiceIntervalScheduling.test.ts

@@ -0,0 +1,333 @@
+import { Service as MonitorProbeServiceType } from "../../../Server/Services/MonitorProbeService";
+import ObjectID from "../../../Types/ObjectID";
+import logger from "../../../Server/Utils/Logger";
+import {
+  CapturedStatement,
+  captureClaimStatements,
+  expectPlaceholdersMatchParameters,
+} from "../TestingUtils/PastDueMonitoringClaimSql";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * WHAT THIS FILE IS DEFENDING
+ *
+ * A customer reported that monitoring had "completely stopped" for three
+ * days. It had not — every monitor was being checked the whole time. What
+ * had actually happened is subtler and worse: all 19 of their monitors
+ * stored the monitoringInterval "5m", which is not a cron expression.
+ * cron-parser threw on it, and claimMonitorProbesForProbing caught the throw
+ * with a bare `catch {}` and fell back to "one minute from now".
+ *
+ * So a monitor configured for five minutes was probed every ~75 seconds.
+ * Measured in production: 1,152 checks per probe per day against the 288 the
+ * setting implies — four times the requested rate, with nothing logged
+ * anywhere, for as long as the row existed. 103 monitors across 10 projects
+ * were affected, most of them having copied the value out of OUR OWN
+ * Terraform examples.
+ *
+ * These tests drive the real claim query through the same harness the
+ * past-due suite uses, and assert the SCHEDULE it computes — because the
+ * bug was never in whether monitors were claimed, only in how far apart.
+ */
+
+const PROBE_ID: ObjectID = new ObjectID("33333333-3333-4333-8333-333333333333");
+
+const MONITOR_PROBE_ID: string = "11111111-1111-4111-8111-111111111111";
+
+/*
+ * Drive one claim and hand back the nextPingAt the UPDATE would write.
+ *
+ * The UPDATE binds [currentDate, ids, ...nextPingDates], so the first
+ * monitor's computed schedule is parameter index 2.
+ */
+async function claimAndReadNextPingAt(
+  monitoringInterval: string | null,
+): Promise<{ nextPingAt: Date; now: Date; update: CapturedStatement }> {
+  const service: MonitorProbeServiceType = new MonitorProbeServiceType();
+
+  const statements: Array<CapturedStatement> = captureClaimStatements(service, [
+    { _id: MONITOR_PROBE_ID, monitoringInterval },
+  ]);
+
+  const before: Date = new Date();
+
+  await service.claimMonitorProbesForProbing({
+    probeId: PROBE_ID,
+    limit: 25,
+  });
+
+  expect(statements.length).toBeGreaterThanOrEqual(2);
+
+  const update: CapturedStatement = statements[1]!;
+  const nextPingAt: Date = update.parameters[2] as Date;
+
+  expect(nextPingAt).toBeInstanceOf(Date);
+
+  return { nextPingAt, now: before, update };
+}
+
+function minutesBetween(from: Date, to: Date): number {
+  return (to.getTime() - from.getTime()) / 1000 / 60;
+}
+
+describe("claimMonitorProbesForProbing computes the schedule the customer asked for", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("the production scenario", () => {
+    test('a monitor storing "5m" is scheduled ~5 minutes out, not 1', async () => {
+      const { nextPingAt, now } = await claimAndReadNextPingAt("5m");
+
+      const gap: number = minutesBetween(now, nextPingAt);
+
+      /*
+       * "*_/5 * * * *" fires on the next multiple of five, so the gap from
+       * an arbitrary "now" is anywhere in (0, 5]. The assertion that matters
+       * is that it is NOT the old hard-coded one minute: before the fix this
+       * was always ~1.0, and a 5-minute cron can only land within one minute
+       * of now for one fifth of any given five-minute window.
+       */
+      expect(gap).toBeGreaterThan(0);
+      expect(gap).toBeLessThanOrEqual(5);
+
+      // The schedule must land on a 5-minute boundary, which +1 minute never does.
+      expect(nextPingAt.getSeconds()).toBe(0);
+      expect(nextPingAt.getMinutes() % 5).toBe(0);
+    });
+
+    test.each([
+      ["Every 5 minutes", 5],
+      ["Every 5 Minutes", 5],
+      ["Every Five Minutes", 5],
+      ["5 minutes", 5],
+      ["Every 2 minutes", 2],
+      ["every-1-min", 1],
+      ["1 minute", 1],
+    ])(
+      "a monitor storing %j lands on a %i-minute boundary",
+      async (interval: string, everyMinutes: number) => {
+        const { nextPingAt } = await claimAndReadNextPingAt(interval);
+
+        expect(nextPingAt.getSeconds()).toBe(0);
+        expect(nextPingAt.getMinutes() % everyMinutes).toBe(0);
+      },
+    );
+
+    test('a monitor storing "1 day" is scheduled for midnight, not a minute away', async () => {
+      const { nextPingAt, now } = await claimAndReadNextPingAt("1 day");
+
+      expect(nextPingAt.getHours()).toBe(0);
+      expect(nextPingAt.getMinutes()).toBe(0);
+      expect(minutesBetween(now, nextPingAt)).toBeGreaterThan(1);
+    });
+  });
+
+  describe("values that were always valid are unaffected", () => {
+    test.each([
+      ["* * * * *", 1],
+      ["*/2 * * * *", 2],
+      ["*/5 * * * *", 5],
+      ["*/10 * * * *", 10],
+      ["*/15 * * * *", 15],
+      ["*/30 * * * *", 30],
+    ])(
+      "%j still lands on a %i-minute boundary",
+      async (cron: string, everyMinutes: number) => {
+        const { nextPingAt } = await claimAndReadNextPingAt(cron);
+
+        expect(nextPingAt.getSeconds()).toBe(0);
+        expect(nextPingAt.getMinutes() % everyMinutes).toBe(0);
+      },
+    );
+
+    test("a cron-parser shortcut the isomorphic grammar cannot read is still honoured", async () => {
+      /*
+       * Raw-parse-first is load-bearing: "@hourly" is Unrecognized to the
+       * normalizer but perfectly readable to cron-parser. If the order were
+       * reversed this would silently become a 1-minute fallback.
+       */
+      const { nextPingAt } = await claimAndReadNextPingAt("@hourly");
+
+      expect(nextPingAt.getMinutes()).toBe(0);
+      expect(nextPingAt.getSeconds()).toBe(0);
+    });
+  });
+
+  describe("values with no schedule fall back, quietly and correctly", () => {
+    test.each([null, ""])(
+      "%j falls back to the 1-minute default without logging an error",
+      async (interval: string | null) => {
+        const { nextPingAt, now } = await claimAndReadNextPingAt(interval);
+
+        /*
+         * A Manual monitor has no interval and that is not a fault, so this
+         * must not reach the offender log.
+         */
+        expect(minutesBetween(now, nextPingAt)).toBeGreaterThan(0.9);
+        expect(minutesBetween(now, nextPingAt)).toBeLessThan(1.2);
+      },
+    );
+
+    test("a genuinely unreadable value falls back to 1 minute", async () => {
+      const { nextPingAt, now } = await claimAndReadNextPingAt("banana");
+
+      expect(minutesBetween(now, nextPingAt)).toBeGreaterThan(0.9);
+      expect(minutesBetween(now, nextPingAt)).toBeLessThan(1.2);
+    });
+  });
+
+  describe("the failure is no longer silent", () => {
+    test("an unreadable interval is reported once per batch, naming the monitor", async () => {
+      /*
+       * The original bug was invisible: a bare `catch {}` with no logging,
+       * so nothing anywhere could be grepped for. The regression guard is
+       * that SOMETHING is logged, that it names the offending row, and that
+       * it is one line for the batch rather than one per monitor.
+       */
+      const errorSpy: ReturnType<typeof jest.spyOn> = jest
+        .spyOn(logger, "error")
+        .mockImplementation(() => {});
+
+      const service: MonitorProbeServiceType = new MonitorProbeServiceType();
+
+      captureClaimStatements(service, [
+        { _id: MONITOR_PROBE_ID, monitoringInterval: "banana" },
+        {
+          _id: "22222222-2222-4222-8222-222222222222",
+          monitoringInterval: "asap",
+        },
+        // A valid one, which must NOT appear in the report.
+        {
+          _id: "44444444-4444-4444-8444-444444444444",
+          monitoringInterval: "*/5 * * * *",
+        },
+      ]);
+
+      await service.claimMonitorProbesForProbing({
+        probeId: PROBE_ID,
+        limit: 25,
+      });
+
+      const offenderLogs: Array<string> = errorSpy.mock.calls
+        .map((call: Array<unknown>) => {
+          return String(call[0]);
+        })
+        .filter((message: string) => {
+          return message.includes("claimMonitorProbesForProbing");
+        });
+
+      // One aggregated line, not one per offending row.
+      expect(offenderLogs).toHaveLength(1);
+
+      const message: string = offenderLogs[0]!;
+
+      expect(message).toContain("2 monitor(s)");
+      expect(message).toContain(MONITOR_PROBE_ID);
+      expect(message).toContain("banana");
+      // The valid row is not an offender.
+      expect(message).not.toContain("44444444-4444-4444-8444-444444444444");
+    });
+
+    test("a clean batch logs nothing", async () => {
+      const errorSpy: ReturnType<typeof jest.spyOn> = jest
+        .spyOn(logger, "error")
+        .mockImplementation(() => {});
+
+      const service: MonitorProbeServiceType = new MonitorProbeServiceType();
+
+      captureClaimStatements(service, [
+        { _id: MONITOR_PROBE_ID, monitoringInterval: "*/5 * * * *" },
+        // "5m" is understood now, so it is not an offender either.
+        {
+          _id: "22222222-2222-4222-8222-222222222222",
+          monitoringInterval: "5m",
+        },
+      ]);
+
+      await service.claimMonitorProbesForProbing({
+        probeId: PROBE_ID,
+        limit: 25,
+      });
+
+      const offenderLogs: Array<unknown> = errorSpy.mock.calls.filter(
+        (call: Array<unknown>) => {
+          return String(call[0]).includes("claimMonitorProbesForProbing");
+        },
+      );
+
+      expect(offenderLogs).toHaveLength(0);
+    });
+  });
+
+  describe("the SQL contract is unchanged", () => {
+    test("placeholders still match parameters after the interval change", async () => {
+      /*
+       * The nextPingAt CASE fragments are built with $${i + 3} numbering
+       * against a [currentDate, ids, ...dates] parameter list. Touching the
+       * loop that builds them is exactly how that numbering gets broken.
+       */
+      const service: MonitorProbeServiceType = new MonitorProbeServiceType();
+
+      const statements: Array<CapturedStatement> = captureClaimStatements(
+        service,
+        [
+          { _id: MONITOR_PROBE_ID, monitoringInterval: "5m" },
+          {
+            _id: "22222222-2222-4222-8222-222222222222",
+            monitoringInterval: "banana",
+          },
+          {
+            _id: "44444444-4444-4444-8444-444444444444",
+            monitoringInterval: null,
+          },
+        ],
+      );
+
+      await service.claimMonitorProbesForProbing({
+        probeId: PROBE_ID,
+        limit: 25,
+      });
+
+      for (const statement of statements) {
+        expectPlaceholdersMatchParameters(statement);
+      }
+    });
+
+    test("every claimed row still gets a schedule, whatever its interval says", async () => {
+      const service: MonitorProbeServiceType = new MonitorProbeServiceType();
+
+      const statements: Array<CapturedStatement> = captureClaimStatements(
+        service,
+        [
+          { _id: MONITOR_PROBE_ID, monitoringInterval: "5m" },
+          {
+            _id: "22222222-2222-4222-8222-222222222222",
+            monitoringInterval: "banana",
+          },
+          {
+            _id: "44444444-4444-4444-8444-444444444444",
+            monitoringInterval: null,
+          },
+        ],
+      );
+
+      const claimed: Array<ObjectID> =
+        await service.claimMonitorProbesForProbing({
+          probeId: PROBE_ID,
+          limit: 25,
+        });
+
+      expect(claimed).toHaveLength(3);
+
+      const update: CapturedStatement = statements[1]!;
+
+      // [currentDate, ids, ...3 dates]
+      expect(update.parameters).toHaveLength(5);
+
+      for (const date of update.parameters.slice(2)) {
+        expect(date).toBeInstanceOf(Date);
+      }
+    });
+  });
+});

package/Tests/Server/Services/MonitorStatusTimelineDailyAggregates.test.ts

@@ -0,0 +1,303 @@
+import { Service as MonitorStatusTimelineServiceType } from "../../../Server/Services/MonitorStatusTimelineService";
+import ObjectID from "../../../Types/ObjectID";
+import {
+  MonitorUptimeDailyAggregate,
+  UptimeDailyAggregate,
+  UptimeDayBucket,
+} from "../../../Types/StatusPage/UptimeDailyAggregate";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * WHAT THIS FILE IS DEFENDING
+ *
+ * The status-page uptime bars used to be painted from raw MonitorStatusTimeline
+ * rows fetched under a single `limit: LIMIT_MAX` (10,000) across EVERY monitor
+ * on the page, sorted `startsAt DESC`.
+ *
+ * Measured on a real status page: 254,550 rows matched the 60-day window and
+ * 10,000 came back - 3.9%. The oldest surviving row started four days before
+ * the request, so 56 of 60 bars were painted from data that had been dropped,
+ * and the uptime percentage was computed from the same 3.9%.
+ *
+ * The cap is GLOBAL across monitors and the sort is newest-first, so a quiet
+ * monitor's covering row - which has an OLD startsAt - sorts last and is cut
+ * first. On the reporting page, three flapping monitors held 9,995 of the
+ * 10,000 slots. The healthier a monitor is, the more likely it loses its whole
+ * history to a noisy neighbour.
+ *
+ * These tests cover the SHAPING half (no database): turning the SQL's
+ * (monitor, day, status) rows into buckets, and in particular keeping a
+ * no-coverage day distinguishable from a day spent up.
+ */
+
+const MONITOR_A: string = "11111111-1111-4111-8111-111111111111";
+const MONITOR_B: string = "22222222-2222-4222-8222-222222222222";
+const STATUS_UP: string = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+const STATUS_DOWN: string = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+
+type Row = {
+  monitorId: string;
+  bucketStart: Date;
+  bucketEnd: Date;
+  daySeconds: string | number;
+  monitorStatusId: string | null;
+  seconds: string | number;
+};
+
+function row(
+  monitorId: string,
+  day: string,
+  statusId: string | null,
+  seconds: number,
+  daySeconds: number = 86400,
+): Row {
+  const start: Date = new Date(`${day}T00:00:00.000Z`);
+  const end: Date = new Date(start.getTime() + daySeconds * 1000);
+
+  return {
+    monitorId,
+    bucketStart: start,
+    bucketEnd: end,
+    /* The pg driver returns bigint columns as strings. */
+    daySeconds: String(daySeconds),
+    monitorStatusId: statusId,
+    seconds: String(seconds),
+  };
+}
+
+function aggregate(rows: Array<Row>): UptimeDailyAggregate {
+  return MonitorStatusTimelineServiceType.toUptimeDailyAggregate(rows);
+}
+
+function bucketsFor(
+  result: UptimeDailyAggregate,
+  monitorId: string,
+): Array<UptimeDayBucket> {
+  const monitor: MonitorUptimeDailyAggregate | undefined = result.monitors.find(
+    (m: MonitorUptimeDailyAggregate) => {
+      return m.monitorId.toString() === monitorId;
+    },
+  );
+
+  return monitor ? monitor.buckets : [];
+}
+
+describe("MonitorStatusTimelineService.toUptimeDailyAggregate", () => {
+  describe("a day with no coverage is not a day spent up", () => {
+    test("a NULL-status row yields a bucket with zero coverage and no durations", () => {
+      /*
+       * This is the LEFT JOIN's "nothing overlapped this day" row. It is the
+       * single most important case in this file: before the fix such a day
+       * fell through to the status page's defaultBarColor, which is GREEN on
+       * 4,642 status pages - the page silently asserting uptime for a period
+       * it has no data for.
+       */
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", null, 0),
+      ]);
+
+      const buckets: Array<UptimeDayBucket> = bucketsFor(result, MONITOR_A);
+
+      expect(buckets).toHaveLength(1);
+      expect(buckets[0]!.coveredSeconds).toBe(0);
+      expect(buckets[0]!.statusDurations).toHaveLength(0);
+      expect(buckets[0]!.daySeconds).toBe(86400);
+    });
+
+    test("a zero-second status row does not manufacture coverage", () => {
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 0),
+      ]);
+
+      expect(bucketsFor(result, MONITOR_A)[0]!.coveredSeconds).toBe(0);
+      expect(bucketsFor(result, MONITOR_A)[0]!.statusDurations).toHaveLength(0);
+    });
+
+    test("a fully covered day is distinguishable from a no-data day", () => {
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", null, 0),
+        row(MONITOR_A, "2026-07-02", STATUS_UP, 86400),
+      ]);
+
+      const buckets: Array<UptimeDayBucket> = bucketsFor(result, MONITOR_A);
+
+      expect(buckets[0]!.coveredSeconds).toBe(0);
+      expect(buckets[1]!.coveredSeconds).toBe(86400);
+    });
+  });
+
+  describe("partial coverage is a real reading, not a no-data day", () => {
+    test("the day a monitor was created reports what was measured", () => {
+      /*
+       * A monitor created at noon has half a day of data. That is a genuine
+       * reading of a shorter interval and must render normally - not as
+       * no-data, and not penalised for the hours before it existed.
+       */
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 43200),
+      ]);
+
+      const bucket: UptimeDayBucket = bucketsFor(result, MONITOR_A)[0]!;
+
+      expect(bucket.coveredSeconds).toBe(43200);
+      expect(bucket.daySeconds).toBe(86400);
+      expect(bucket.coveredSeconds).toBeLessThan(bucket.daySeconds);
+      expect(bucket.statusDurations).toHaveLength(1);
+    });
+  });
+
+  describe("multiple statuses in one day", () => {
+    test("durations are kept separately and summed into coverage", () => {
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 82800),
+        row(MONITOR_A, "2026-07-01", STATUS_DOWN, 3600),
+      ]);
+
+      const buckets: Array<UptimeDayBucket> = bucketsFor(result, MONITOR_A);
+
+      expect(buckets).toHaveLength(1);
+      expect(buckets[0]!.coveredSeconds).toBe(86400);
+      expect(buckets[0]!.statusDurations).toHaveLength(2);
+
+      const down: number =
+        buckets[0]!.statusDurations.find((d: { monitorStatusId: ObjectID }) => {
+          return d.monitorStatusId.toString() === STATUS_DOWN;
+        })?.seconds || 0;
+
+      expect(down).toBe(3600);
+    });
+  });
+
+  describe("day length is never assumed to be 86400", () => {
+    test("a clipped first bucket keeps its real length", () => {
+      /*
+       * The window's first and last buckets are clipped to the window, and a
+       * local day crossing a DST boundary is genuinely 23 or 25 hours. Any
+       * consumer dividing by a hardcoded 86400 would misreport both.
+       */
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 45147, 45147),
+      ]);
+
+      expect(bucketsFor(result, MONITOR_A)[0]!.daySeconds).toBe(45147);
+    });
+
+    test("a 23-hour DST day is reported as 82800 seconds", () => {
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-03-29", STATUS_UP, 82800, 82800),
+      ]);
+
+      expect(bucketsFor(result, MONITOR_A)[0]!.daySeconds).toBe(82800);
+    });
+
+    test("a 25-hour DST day is reported as 90000 seconds", () => {
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-10-25", STATUS_UP, 90000, 90000),
+      ]);
+
+      expect(bucketsFor(result, MONITOR_A)[0]!.daySeconds).toBe(90000);
+    });
+  });
+
+  describe("monitors are kept apart", () => {
+    test("a noisy monitor cannot consume a quiet one's buckets", () => {
+      /*
+       * The shape of the original bug: a global cap let three flapping
+       * monitors hold 9,995 of 10,000 slots and starve the quiet ones. The
+       * aggregate is per monitor, so a quiet monitor's days survive
+       * regardless of what its neighbours are doing.
+       */
+      const rows: Array<Row> = [];
+
+      for (let i: number = 0; i < 500; i++) {
+        rows.push(row(MONITOR_A, "2026-07-01", STATUS_UP, 1));
+        rows.push(row(MONITOR_A, "2026-07-01", STATUS_DOWN, 1));
+      }
+
+      rows.push(row(MONITOR_B, "2026-07-01", STATUS_UP, 86400));
+
+      const result: UptimeDailyAggregate = aggregate(rows);
+
+      expect(bucketsFor(result, MONITOR_B)).toHaveLength(1);
+      expect(bucketsFor(result, MONITOR_B)[0]!.coveredSeconds).toBe(86400);
+    });
+  });
+
+  describe("output shape", () => {
+    test("buckets come back in chronological order whatever order the rows arrive in", () => {
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-03", STATUS_UP, 86400),
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 86400),
+        row(MONITOR_A, "2026-07-02", STATUS_UP, 86400),
+      ]);
+
+      const starts: Array<number> = bucketsFor(result, MONITOR_A).map(
+        (b: UptimeDayBucket) => {
+          return b.bucketStart.getTime();
+        },
+      );
+
+      expect(starts).toEqual([...starts].sort());
+    });
+
+    test("bigint columns arriving as strings are coerced to numbers", () => {
+      /*
+       * The pg driver returns bigint as a string. Left uncoerced, coverage
+       * arithmetic would concatenate instead of adding.
+       */
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 3600),
+        row(MONITOR_A, "2026-07-01", STATUS_DOWN, 1800),
+      ]);
+
+      const bucket: UptimeDayBucket = bucketsFor(result, MONITOR_A)[0]!;
+
+      expect(typeof bucket.coveredSeconds).toBe("number");
+      expect(typeof bucket.daySeconds).toBe("number");
+      expect(bucket.coveredSeconds).toBe(5400);
+    });
+
+    test("fractional seconds are not rounded away per status group", () => {
+      /*
+       * Seconds come back as double precision on purpose. An earlier draft
+       * cast each (monitor, day, status) sum to a bigint, which loses up to
+       * half a second per status - so a fully covered day with two statuses
+       * reported 86,399 of 86,400 seconds and looked one second short of
+       * complete. Observed against real data, on a day with 21,914 flapping
+       * transitions.
+       */
+      const result: UptimeDailyAggregate = aggregate([
+        { ...row(MONITOR_A, "2026-07-01", STATUS_UP, 0), seconds: 86399.6 },
+        { ...row(MONITOR_A, "2026-07-01", STATUS_DOWN, 0), seconds: 0.4 },
+      ]);
+
+      const bucket: UptimeDayBucket = bucketsFor(result, MONITOR_A)[0]!;
+
+      expect(bucket.coveredSeconds).toBeCloseTo(86400, 5);
+      expect(bucket.statusDurations).toHaveLength(2);
+    });
+
+    test("an empty result set is complete, not incomplete", () => {
+      const result: UptimeDailyAggregate = aggregate([]);
+
+      expect(result.monitors).toHaveLength(0);
+      expect(result.isComplete).toBe(true);
+      expect(result.completeFrom).toBeNull();
+    });
+
+    test("there is no silent cap: the aggregate always declares completeness", () => {
+      /*
+       * Requirement 4. The old path had a bound that nothing surfaced. These
+       * fields exist so a bound added later has to SHOW rather than be
+       * absorbed into a green bar.
+       */
+      const result: UptimeDailyAggregate = aggregate([
+        row(MONITOR_A, "2026-07-01", STATUS_UP, 86400),
+      ]);
+
+      expect(result).toHaveProperty("isComplete");
+      expect(result).toHaveProperty("completeFrom");
+      expect(result.isComplete).toBe(true);
+    });
+  });
+});