@oneuptime/common 14.0.0 → 14.0.2

package/Tests/UI/Components/MonitorGraphs/Uptime.test.tsx

@@ -1,6 +1,6 @@
 /** @timezone UTC */
 import "@testing-library/jest-dom";
-import { fireEvent, render, screen } from "@testing-library/react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import React, { Profiler } from "react";
 import { afterEach, describe, expect, jest, test } from "@jest/globals";
 import { SpyInstance } from "jest-mock";
@@ -8,9 +8,13 @@ import MonitorUptimeGraph, {
   ComponentProps,
 } from "../../../../UI/Components/MonitorGraphs/Uptime";
 import UptimeUtil from "../../../../UI/Components/MonitorGraphs/UptimeUtil";
-import { Green, Red } from "../../../../Types/BrandColors";
+import { UptimeBarDaySummary } from "../../../../UI/Components/Graphs/DayUptimeGraph";
+import { StatusDuration } from "../../../../UI/Components/Graphs/UptimeDaySummary";
+import { Green, Orange, Red } from "../../../../Types/BrandColors";
 import Color from "../../../../Types/Color";
 import ObjectID from "../../../../Types/ObjectID";
+import { UptimeDayBucket } from "../../../../Types/StatusPage/UptimeDailyAggregate";
+import UptimeBarTooltipIncident from "../../../../Types/Monitor/UptimeBarTooltipIncident";
 import MonitorStatus from "../../../../Models/DatabaseModels/MonitorStatus";
 import MonitorStatusTimeline from "../../../../Models/DatabaseModels/MonitorStatusTimeline";
 import StatusPageHistoryChartBarColorRule from "../../../../Models/DatabaseModels/StatusPageHistoryChartBarColorRule";
@@ -299,3 +303,403 @@ describe("MonitorUptimeGraph - loading and recovery", () => {
     );
   });
 });
+
+/*
+ * The server's day buckets. A day whose timeline rows were dropped by the
+ * fetch cap is painted from its bucket alone, and a bucket only names status
+ * ids, so the graph resolves each one to the status's name, colour, downtime
+ * flag and priority. Without the priority the bar could not take the colour
+ * of the day's worst status the way a day painted from rows does.
+ */
+describe("MonitorUptimeGraph - server buckets", () => {
+  type OnBarClickFunction = (
+    date: Date,
+    incidents: Array<UptimeBarTooltipIncident>,
+    summary: UptimeBarDaySummary,
+  ) => void;
+
+  interface BucketDuration {
+    status: MonitorStatus;
+    seconds: number;
+  }
+
+  function bucketFor(
+    day: string,
+    durations: Array<BucketDuration>,
+  ): UptimeDayBucket {
+    const bucketStart: Date = new Date(`${day}T00:00:00.000Z`);
+
+    return {
+      bucketStart: bucketStart,
+      bucketEnd: new Date(bucketStart.getTime() + 86400 * 1000),
+      daySeconds: 86400,
+      coveredSeconds: durations.reduce(
+        (sum: number, duration: BucketDuration) => {
+          return sum + duration.seconds;
+        },
+        0,
+      ),
+      statusDurations: durations.map((duration: BucketDuration) => {
+        return {
+          monitorStatusId: duration.status.id as ObjectID,
+          seconds: duration.seconds,
+        };
+      }),
+    };
+  }
+
+  function openBar(
+    onBarClick: ReturnType<typeof jest.fn<OnBarClickFunction>>,
+    index: number,
+  ): UptimeBarDaySummary {
+    fireEvent.click(screen.getAllByTestId("uptime-bar")[index] as HTMLElement);
+
+    const calls: Array<Parameters<OnBarClickFunction>> = onBarClick.mock.calls;
+
+    return calls[calls.length - 1]?.[2] as UptimeBarDaySummary;
+  }
+
+  test("bucket durations carry the status priority", () => {
+    const up: MonitorStatus = makeStatus(false);
+    const down: MonitorStatus = makeStatus(true);
+    const onBarClick: ReturnType<typeof jest.fn<OnBarClickFunction>> =
+      jest.fn<OnBarClickFunction>();
+
+    renderHistory({
+      items: [],
+      monitorStatuses: [up, down],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: [
+        bucketFor("2026-01-02", [
+          { status: up, seconds: 43200 },
+          { status: down, seconds: 43200 },
+        ]),
+      ],
+      onBarClick: onBarClick,
+    });
+
+    const summary: UptimeBarDaySummary = openBar(onBarClick, 1);
+
+    expect(
+      summary.statusDurations.map((duration: StatusDuration) => {
+        return {
+          label: duration.label,
+          priority: duration.priority,
+          isDowntime: duration.isDowntime,
+        };
+      }),
+    ).toEqual([
+      { label: "Operational", priority: 1, isDowntime: false },
+      { label: "Offline", priority: 2, isDowntime: true },
+    ]);
+
+    // The day has no rows of its own, so the bucket paints it.
+    expect(summary.uptimePercent).toBe(50);
+    expect(screen.getAllByTestId("uptime-bar")[1]).toHaveStyle({
+      backgroundColor: Red.toString(),
+    });
+  });
+
+  test("the day takes the colour of its highest-priority status, not its downtime status", () => {
+    const up: MonitorStatus = makeStatus(false);
+    const down: MonitorStatus = makeStatus(true);
+
+    // A status ranked above Offline that the page does not count as down.
+    const maintenance: MonitorStatus = new MonitorStatus();
+    maintenance._id = "status-maintenance";
+    maintenance.name = "Maintenance";
+    maintenance.color = Orange;
+    maintenance.priority = 3;
+
+    renderHistory({
+      items: [],
+      monitorStatuses: [up, down, maintenance],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: [
+        bucketFor("2026-01-02", [
+          { status: up, seconds: 60000 },
+          { status: down, seconds: 25800 },
+          { status: maintenance, seconds: 600 },
+        ]),
+      ],
+    });
+
+    expect(screen.getAllByTestId("uptime-bar")[1]).toHaveStyle({
+      backgroundColor: Orange.toString(),
+    });
+  });
+
+  test("a status the page holds no priority for leaves the duration without one", () => {
+    // The same two statuses, read without their priority column.
+    const up: MonitorStatus = new MonitorStatus();
+    up._id = "status-up";
+    up.name = "Operational";
+    up.color = Green;
+
+    const down: MonitorStatus = new MonitorStatus();
+    down._id = "status-down";
+    down.name = "Offline";
+    down.color = Red;
+
+    const onBarClick: ReturnType<typeof jest.fn<OnBarClickFunction>> =
+      jest.fn<OnBarClickFunction>();
+
+    renderHistory({
+      items: [],
+      monitorStatuses: [up, down],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: [
+        bucketFor("2026-01-02", [
+          { status: up, seconds: 64800 },
+          { status: down, seconds: 21600 },
+        ]),
+      ],
+      onBarClick: onBarClick,
+    });
+
+    const summary: UptimeBarDaySummary = openBar(onBarClick, 1);
+
+    expect(
+      summary.statusDurations.map((duration: StatusDuration) => {
+        return duration.priority;
+      }),
+    ).toEqual([undefined, undefined]);
+
+    // With no priorities, the downtime status the day spent longest in.
+    expect(summary.uptimePercent).toBe(75);
+    expect(screen.getAllByTestId("uptime-bar")[1]).toHaveStyle({
+      backgroundColor: Red.toString(),
+    });
+  });
+
+  /*
+   * This test used to be "a day with timeline rows keeps its row-derived
+   * reading beside a bucket-only day": Jan 2's rows decided Jan 2 whatever
+   * its bucket said. That precedence is what left status.chainflip.io wrong.
+   * The rows arrive under a 10,000 row cap across the whole page, so the day
+   * the cap cuts through still "has rows" - just not all of them - and the
+   * pre-fix client sort could leave a day with rows that describe nothing
+   * real. The bucket is measured server-side from every row, so a bucket with
+   * coverage now decides its day even when the day has rows.
+   *
+   * Fails on the pre-fix code: Jan 2 read 0% and Red from its rows.
+   */
+  test("a day's bucket decides it even when the day has timeline rows", () => {
+    const up: MonitorStatus = makeStatus(false);
+    const down: MonitorStatus = makeStatus(true);
+    const onBarClick: ReturnType<typeof jest.fn<OnBarClickFunction>> =
+      jest.fn<OnBarClickFunction>();
+
+    renderHistory({
+      // Down 01:00-23:00 on Jan 2, from the rows.
+      items: [makeTimeline(down)],
+      monitorStatuses: [up, down],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: [
+        bucketFor("2026-01-01", [
+          { status: up, seconds: 64800 },
+          { status: down, seconds: 21600 },
+        ]),
+        // Disagrees with the rows on purpose: the bucket decides Jan 2.
+        bucketFor("2026-01-02", [{ status: up, seconds: 86400 }]),
+      ],
+      onBarClick: onBarClick,
+    });
+
+    const bars: Array<HTMLElement> = screen.getAllByTestId("uptime-bar");
+
+    // Jan 1 has no rows, so its bucket paints it.
+    expect(openBar(onBarClick, 0).uptimePercent).toBe(75);
+    expect(bars[0]).toHaveStyle({ backgroundColor: Red.toString() });
+
+    // Jan 2 has rows, and its bucket still decides it.
+    const jan2: UptimeBarDaySummary = openBar(onBarClick, 1);
+
+    expect(jan2.uptimePercent).toBe(100);
+    expect(
+      jan2.statusDurations.map((duration: StatusDuration) => {
+        return duration.label;
+      }),
+    ).toEqual(["Operational"]);
+    expect(bars[1]).toHaveStyle({ backgroundColor: Green.toString() });
+    expect(bars[1]).toHaveAttribute(
+      "aria-label",
+      expect.stringContaining("100% uptime"),
+    );
+  });
+});
+
+/*
+ * The zone the buckets were cut in. The status page's buckets are UTC days
+ * shared by every visitor through one cached response, so the strip has to be
+ * drawn on those same days or each bar is paired with a bucket for a
+ * different span of time. MonitorUptimeGraph takes that zone as
+ * uptimeTimezone and hands it to the strip. The dashboard passes none (its
+ * buckets are asked for in the browser's zone) and must see no change.
+ *
+ * This file runs in UTC, so a zone that is NOT the browser's is needed to see
+ * the prop do anything: Tokyo buckets, cut at 15:00 UTC.
+ */
+describe("MonitorUptimeGraph - uptimeTimezone", () => {
+  type OnBarClickFunction = (
+    date: Date,
+    incidents: Array<UptimeBarTooltipIncident>,
+    summary: UptimeBarDaySummary,
+  ) => void;
+
+  const up: MonitorStatus = makeStatus(false);
+  const down: MonitorStatus = makeStatus(true);
+
+  function bucketBetween(
+    start: string,
+    end: string,
+    uptimePercent: number,
+  ): UptimeDayBucket {
+    const bucketStart: Date = new Date(start);
+    const bucketEnd: Date = new Date(end);
+    const coveredSeconds: number =
+      (bucketEnd.getTime() - bucketStart.getTime()) / 1000;
+    const downSeconds: number = (coveredSeconds * (100 - uptimePercent)) / 100;
+
+    return {
+      bucketStart: bucketStart,
+      bucketEnd: bucketEnd,
+      daySeconds: coveredSeconds,
+      coveredSeconds: coveredSeconds,
+      statusDurations: [
+        {
+          monitorStatusId: up.id as ObjectID,
+          seconds: coveredSeconds - downSeconds,
+        },
+        { monitorStatusId: down.id as ObjectID, seconds: downSeconds },
+      ],
+    };
+  }
+
+  /*
+   * The window is Jan 1 12:00 UTC to Jan 3 12:00 UTC - 21:00 JST on Jan 1 to
+   * 21:00 JST on Jan 3 - so Tokyo's buckets are a clipped Jan 1, a whole
+   * Jan 2 and a Jan 3 cut off at "now", each with its own percentage.
+   */
+  const TOKYO_BUCKETS: Array<UptimeDayBucket> = [
+    bucketBetween("2026-01-01T12:00:00.000Z", "2026-01-01T15:00:00.000Z", 90),
+    bucketBetween("2026-01-01T15:00:00.000Z", "2026-01-02T15:00:00.000Z", 91),
+    bucketBetween("2026-01-02T15:00:00.000Z", "2026-01-03T12:00:00.000Z", 92),
+  ];
+
+  function barLabels(): Array<string | null> {
+    return screen.getAllByTestId("uptime-bar").map((bar: HTMLElement) => {
+      return bar.getAttribute("aria-label");
+    });
+  }
+
+  test("the strip is drawn on the buckets' own days, so bar i is painted from bucket i", () => {
+    const onBarClick: ReturnType<typeof jest.fn<OnBarClickFunction>> =
+      jest.fn<OnBarClickFunction>();
+
+    renderHistory({
+      items: [],
+      monitorStatuses: [up, down],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: TOKYO_BUCKETS,
+      uptimeTimezone: "Asia/Tokyo",
+      onBarClick: onBarClick,
+    });
+
+    // The zone is not the browser's (UTC), so the labels say which it is.
+    expect(barLabels()).toEqual([
+      "Jan 01, 2026 (JST): 90% uptime",
+      "Jan 02, 2026 (JST): 91% uptime",
+      "Jan 03, 2026 (JST): 92% uptime",
+    ]);
+
+    // Each bar opens as the Tokyo midnight it stands for.
+    const bars: Array<HTMLElement> = screen.getAllByTestId("uptime-bar");
+
+    bars.forEach((bar: HTMLElement) => {
+      fireEvent.click(bar);
+    });
+
+    expect(
+      onBarClick.mock.calls.map((call: Parameters<OnBarClickFunction>) => {
+        return call[0].toISOString();
+      }),
+    ).toEqual([
+      "2025-12-31T15:00:00.000Z",
+      "2026-01-01T15:00:00.000Z",
+      "2026-01-02T15:00:00.000Z",
+    ]);
+  });
+
+  /*
+   * Without the zone, what the pre-fix code always did: UTC days in this
+   * browser, so Jan 1 holds the starts of two Tokyo buckets and keeps the
+   * first, the whole-day Jan 2 bucket (91%) is on no bar, and the last bar
+   * has nothing.
+   */
+  test("without uptimeTimezone the same buckets are drawn on the browser's days and mis-pair", () => {
+    renderHistory({
+      items: [],
+      monitorStatuses: [up, down],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: TOKYO_BUCKETS,
+    });
+
+    expect(barLabels()).toEqual([
+      "Jan 01, 2026: 90% uptime",
+      "Jan 02, 2026: 92% uptime",
+      "Jan 03, 2026: no data",
+    ]);
+  });
+
+  /*
+   * The dashboard's case: the buckets are the browser's own days. Passing
+   * that zone, or passing nothing, must draw the same strip.
+   */
+  test("a zone that is the browser's own draws exactly what omitting it draws", () => {
+    interface HistoryLook {
+      labels: Array<string | null>;
+      colors: Array<string>;
+    }
+
+    const readHistory: () => HistoryLook = (): HistoryLook => {
+      return {
+        labels: barLabels(),
+        colors: screen.getAllByTestId("uptime-bar").map((bar: HTMLElement) => {
+          return bar.style.backgroundColor;
+        }),
+      };
+    };
+
+    const utcBuckets: Array<UptimeDayBucket> = [
+      bucketBetween("2026-01-01T12:00:00.000Z", "2026-01-02T00:00:00.000Z", 75),
+      bucketBetween("2026-01-02T00:00:00.000Z", "2026-01-03T00:00:00.000Z", 50),
+      bucketBetween("2026-01-03T00:00:00.000Z", "2026-01-03T12:00:00.000Z", 99),
+    ];
+
+    const sharedProps: Partial<ComponentProps> = {
+      items: [makeTimeline(down)],
+      monitorStatuses: [up, down],
+      downtimeMonitorStatuses: [down],
+      uptimeBuckets: utcBuckets,
+      barColorRules: [makeRule(new Color("#123456"))],
+    };
+
+    renderHistory(sharedProps);
+
+    const omitted: HistoryLook = readHistory();
+
+    cleanup();
+
+    renderHistory({ ...sharedProps, uptimeTimezone: "UTC" });
+
+    const inUtc: HistoryLook = readHistory();
+
+    expect(inUtc).toEqual(omitted);
+    expect(inUtc.labels).toEqual([
+      "Jan 01, 2026: 75% uptime",
+      "Jan 02, 2026: 50% uptime",
+      "Jan 03, 2026: 99% uptime",
+    ]);
+  });
+});

package/Tests/UI/Components/MonitorGraphs/UptimeBarDayModal.test.tsx

@@ -1,12 +1,13 @@
 import "@testing-library/jest-dom";
-import { fireEvent, render, screen } from "@testing-library/react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import React from "react";
-import { describe, expect, jest, test } from "@jest/globals";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
 import UptimeBarDayModal from "../../../../UI/Components/MonitorGraphs/UptimeBarDayModal";
 import { StatusDuration } from "../../../../UI/Components/Graphs/UptimeDaySummary";
 import { Green, Red } from "../../../../Types/BrandColors";
 import Color from "../../../../Types/Color";
 import OneUptimeDate from "../../../../Types/Date";
+import Timezone from "../../../../Types/Timezone";
 import UptimeBarTooltipIncident from "../../../../Types/Monitor/UptimeBarTooltipIncident";
 import UptimeHistoryLabels, {
   DefaultUptimeHistoryLabels,
@@ -300,3 +301,169 @@ describe("UptimeBarDayModal - translation", () => {
     expect(screen.getByText("No incidents")).toBeInTheDocument();
   });
 });
+
+/*
+ * The day is named in the zone its bar was drawn in.
+ *
+ * The status page's uptime strip is drawn on UTC days (its readings are cut
+ * on UTC days, one cached payload for every visitor), so the bar a New York
+ * visitor opens at eight in the evening on Sep 21 stands for Sep 22 UTC. The
+ * dialog has to name that same day, and say it is a UTC day, or it titles the
+ * day with a date the bar does not stand for.
+ *
+ * The visitor's zone is pinned with setUserTimezone so these read the same on
+ * any machine. Every test that passes `timezone` fails on the pre-fix dialog:
+ * the prop did not exist, and the title was always the visitor's local date.
+ */
+describe("UptimeBarDayModal - the day is named in the zone its bar was drawn in", () => {
+  const UTC_MIDNIGHT: Date = new Date("2026-09-22T00:00:00.000Z");
+
+  afterEach(() => {
+    OneUptimeDate.setUserTimezone(null);
+  });
+
+  function renderDay(date: Date, timezone?: string | undefined): void {
+    render(
+      <UptimeBarDayModal
+        date={date}
+        timezone={timezone}
+        incidents={[]}
+        hasEvents={true}
+        uptimePercent={100}
+        statusDurations={[UPTIME]}
+        onClose={() => {}}
+      />,
+    );
+  }
+
+  test("a UTC day opened from New York is titled with the UTC date and says it is UTC", () => {
+    OneUptimeDate.setUserTimezone(Timezone.AmericaNew_York);
+
+    renderDay(UTC_MIDNIGHT, "UTC");
+
+    expect(screen.getByText("Sep 22, 2026 (UTC)")).toBeInTheDocument();
+    expect(screen.queryByText("Sep 21, 2026")).not.toBeInTheDocument();
+  });
+
+  test("without a zone, New York sees exactly the old local title", () => {
+    OneUptimeDate.setUserTimezone(Timezone.AmericaNew_York);
+
+    renderDay(UTC_MIDNIGHT);
+
+    // 00:00 UTC on Sep 22 is 20:00 on Sep 21 in New York.
+    expect(screen.getByText("Sep 21, 2026")).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
+          UTC_MIDNIGHT,
+          true,
+        ),
+      ),
+    ).toBeInTheDocument();
+  });
+
+  test("a UTC day opened from Tokyo is titled with the UTC date and says it is UTC", () => {
+    OneUptimeDate.setUserTimezone(Timezone.AsiaTokyo);
+
+    /*
+     * 09:00 in Tokyo, the same date - but nine hours off UTC, so the day is
+     * still marked as the UTC day it is.
+     */
+    renderDay(UTC_MIDNIGHT, "UTC");
+
+    expect(screen.getByText("Sep 22, 2026 (UTC)")).toBeInTheDocument();
+  });
+
+  test("a visitor in UTC gets the UTC date with no zone on it", () => {
+    OneUptimeDate.setUserTimezone(Timezone.UTC);
+
+    renderDay(UTC_MIDNIGHT, "UTC");
+
+    expect(screen.getByText("Sep 22, 2026")).toBeInTheDocument();
+    expect(screen.queryByText("Sep 22, 2026 (UTC)")).not.toBeInTheDocument();
+  });
+
+  /*
+   * The suffix follows the offset, not the name: London is on UTC's offset in
+   * winter, so a UTC day needs no explanation there; in summer London is an
+   * hour ahead, and it does.
+   */
+  test("London in winter shares UTC's offset, so the UTC day is left unmarked", () => {
+    OneUptimeDate.setUserTimezone(Timezone.EuropeLondon);
+
+    renderDay(new Date("2026-01-15T00:00:00.000Z"), "UTC");
+
+    expect(screen.getByText("Jan 15, 2026")).toBeInTheDocument();
+    expect(screen.queryByText("Jan 15, 2026 (UTC)")).not.toBeInTheDocument();
+  });
+
+  test("London in summer is an hour ahead of UTC, so the UTC day is marked", () => {
+    OneUptimeDate.setUserTimezone(Timezone.EuropeLondon);
+
+    renderDay(new Date("2026-07-15T00:00:00.000Z"), "UTC");
+
+    expect(screen.getByText("Jul 15, 2026 (UTC)")).toBeInTheDocument();
+  });
+
+  test("a bar drawn in the visitor's own zone is titled with no zone on it", () => {
+    OneUptimeDate.setUserTimezone(Timezone.AmericaNew_York);
+
+    // New York midnight on Sep 22.
+    renderDay(new Date("2026-09-22T04:00:00.000Z"), "America/New_York");
+
+    expect(screen.getByText("Sep 22, 2026")).toBeInTheDocument();
+    expect(screen.queryByText(/\(EDT\)/)).not.toBeInTheDocument();
+  });
+
+  test("the zone's abbreviation is the one in force on that date", () => {
+    OneUptimeDate.setUserTimezone(Timezone.UTC);
+
+    renderDay(new Date("2026-01-15T05:00:00.000Z"), "America/New_York");
+
+    expect(screen.getByText("Jan 15, 2026 (EST)")).toBeInTheDocument();
+
+    cleanup();
+
+    renderDay(new Date("2026-07-15T04:00:00.000Z"), "America/New_York");
+
+    expect(screen.getByText("Jul 15, 2026 (EDT)")).toBeInTheDocument();
+  });
+
+  test.each(["Not/A_Zone", "", "   "])(
+    "an unusable zone %p is ignored and the title is the old local one",
+    (timezone: string) => {
+      OneUptimeDate.setUserTimezone(Timezone.AmericaNew_York);
+
+      renderDay(UTC_MIDNIGHT, timezone);
+
+      expect(screen.getByText("Sep 21, 2026")).toBeInTheDocument();
+    },
+  );
+
+  test("the zone names the day only: an incident's time is still the visitor's own", () => {
+    OneUptimeDate.setUserTimezone(Timezone.AmericaNew_York);
+
+    const declaredAt: Date = new Date("2026-09-22T01:30:00.000Z");
+
+    render(
+      <UptimeBarDayModal
+        date={UTC_MIDNIGHT}
+        timezone="UTC"
+        incidents={[makeIncident({ declaredAt: declaredAt })]}
+        onClose={() => {}}
+      />,
+    );
+
+    expect(screen.getByText("Sep 22, 2026 (UTC)")).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        new RegExp(
+          OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
+            declaredAt,
+            false,
+          ).replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+        ),
+      ),
+    ).toBeInTheDocument();
+  });
+});

package/Tests/UI/Components/RuleCriteria/RuleCriteriaModelTable.test.tsx

@@ -332,9 +332,9 @@ More details stay here.
       },
     );
 
-    expect(staticRuleFormFiles).toHaveLength(62);
-    expect(helpFormFiles).toHaveLength(55);
-    expect(helpMarkdown).toHaveLength(61);
+    expect(staticRuleFormFiles).toHaveLength(64);
+    expect(helpFormFiles).toHaveLength(57);
+    expect(helpMarkdown).toHaveLength(63);
 
     for (const markdown of helpMarkdown) {
       const transformed: string = replaceRuleCriteriaHelpMarkdown(markdown);