@oneuptime/common 12.0.4 → 12.0.5

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

@@ -716,6 +716,8 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: true,
           isCurrentlyDown: false,
           uptimePercent: 99.9,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.UptimePercent);
     });
@@ -731,6 +733,8 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: true,
           isCurrentlyDown: true,
           uptimePercent: 99.9,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.CurrentStatus);
     });
@@ -746,6 +750,8 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: true,
           isCurrentlyDown: false,
           uptimePercent: null,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.None);
     });
@@ -757,6 +763,8 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: true,
           isCurrentlyDown: false,
           uptimePercent: 100,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.CurrentStatus);
     });
@@ -768,6 +776,8 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: false,
           isCurrentlyDown: false,
           uptimePercent: 100,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.None);
     });
@@ -779,6 +789,8 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: false,
           isCurrentlyDown: true,
           uptimePercent: 99.9,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.None);
     });
@@ -790,9 +802,49 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
           showCurrentStatus: true,
           isCurrentlyDown: false,
           uptimePercent: 0,
+
+          resourceCountInSubtree: 1,
         }),
       ).toBe(StatusPageGroupRollupKind.UptimePercent);
     });
+
+    /*
+     * A hierarchy is drawn while it is still being filled in, so groups with
+     * nothing under them yet are on the page. The rolled up status defaults to
+     * Operational when it finds no resources to look at, and publishing that
+     * would be telling visitors that a group containing no monitors is healthy.
+     */
+    test("a group with nothing under it shows no rollup, whatever it is configured for", () => {
+      for (const showUptimePercent of [true, false]) {
+        for (const showCurrentStatus of [true, false]) {
+          expect(
+            StatusPageGroupNestingLayoutUtil.getRollupKind({
+              showUptimePercent: showUptimePercent,
+              showCurrentStatus: showCurrentStatus,
+              isCurrentlyDown: false,
+              uptimePercent: null,
+              resourceCountInSubtree: 0,
+            }),
+          ).toBe(StatusPageGroupRollupKind.None);
+        }
+      }
+    });
+
+    /*
+     * The count is of the whole subtree, so a holder group whose own resource
+     * list is empty still reports for the monitors nested under it.
+     */
+    test("a holder group reports the resources nested below it", () => {
+      expect(
+        StatusPageGroupNestingLayoutUtil.getRollupKind({
+          showUptimePercent: false,
+          showCurrentStatus: true,
+          isCurrentlyDown: false,
+          uptimePercent: null,
+          resourceCountInSubtree: 12,
+        }),
+      ).toBe(StatusPageGroupRollupKind.CurrentStatus);
+    });
   });
 
   describe("shouldShowSubGroupDivider", () => {
@@ -878,6 +930,140 @@ describe("StatusPageGroupNestingLayoutUtil", () => {
       ).toBe(true);
     });
   });
+
+  /*
+   * The overview page used to gate its whole resources-and-groups block on
+   * `statusPageResources.length > 0`. That made a status page carrying a fully
+   * built group hierarchy and no monitors render nothing at all: the operator
+   * created their groups, saw them listed in the dashboard, and got an empty
+   * public page until the first monitor was attached to one of them.
+   *
+   * Groups are content. These two gates are what says so, and they have to
+   * agree with each other - a page that renders its hierarchy must not also
+   * render an empty state above it saying there is nothing here.
+   */
+  describe("shouldRenderResourcesSection", () => {
+    test("renders for a page with groups and no resources at all", () => {
+      expect(
+        StatusPageGroupNestingLayoutUtil.shouldRenderResourcesSection({
+          statusPageResourceCount: 0,
+          statusPageGroupCount: 1,
+        }),
+      ).toBe(true);
+    });
+
+    /* The size the bug was reported at. */
+    test("renders for a large hierarchy with no resources", () => {
+      expect(
+        StatusPageGroupNestingLayoutUtil.shouldRenderResourcesSection({
+          statusPageResourceCount: 0,
+          statusPageGroupCount: 1506,
+        }),
+      ).toBe(true);
+    });
+
+    test("renders for a page with resources and no groups", () => {
+      expect(
+        StatusPageGroupNestingLayoutUtil.shouldRenderResourcesSection({
+          statusPageResourceCount: 3,
+          statusPageGroupCount: 0,
+        }),
+      ).toBe(true);
+    });
+
+    test("renders for a page with both", () => {
+      expect(
+        StatusPageGroupNestingLayoutUtil.shouldRenderResourcesSection({
+          statusPageResourceCount: 3,
+          statusPageGroupCount: 4,
+        }),
+      ).toBe(true);
+    });
+
+    test("renders nothing for a page with neither", () => {
+      expect(
+        StatusPageGroupNestingLayoutUtil.shouldRenderResourcesSection({
+          statusPageResourceCount: 0,
+          statusPageGroupCount: 0,
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe("shouldRenderOverviewEmptyState", () => {
+    type EmptyStateInput = Parameters<
+      typeof StatusPageGroupNestingLayoutUtil.shouldRenderOverviewEmptyState
+    >[0];
+
+    function emptyPage(overrides: Partial<EmptyStateInput> = {}): boolean {
+      return StatusPageGroupNestingLayoutUtil.shouldRenderOverviewEmptyState({
+        statusPageResourceCount: 0,
+        statusPageGroupCount: 0,
+        activeIncidentCount: 0,
+        activeEpisodeCount: 0,
+        activeScheduledMaintenanceCount: 0,
+        activeAnnouncementCount: 0,
+        ...overrides,
+      });
+    }
+
+    test("a page with nothing on it shows the empty state", () => {
+      expect(emptyPage()).toBe(true);
+    });
+
+    /*
+     * The half of the bug the visitor actually saw: 1506 groups on the page,
+     * and an "all clear, nothing to see" panel rendered instead of them.
+     */
+    test("a page with groups and no resources does not show the empty state", () => {
+      expect(emptyPage({ statusPageGroupCount: 1506 })).toBe(false);
+    });
+
+    test("a page with resources does not show the empty state", () => {
+      expect(emptyPage({ statusPageResourceCount: 1 })).toBe(false);
+    });
+
+    test.each([
+      ["an active incident", "activeIncidentCount"],
+      ["an active episode", "activeEpisodeCount"],
+      ["a scheduled maintenance event", "activeScheduledMaintenanceCount"],
+      ["an announcement", "activeAnnouncementCount"],
+    ])(
+      "%s suppresses the empty state on its own",
+      (_name: string, key: string) => {
+        expect(emptyPage({ [key]: 1 } as Partial<EmptyStateInput>)).toBe(false);
+      },
+    );
+
+    /*
+     * The two gates are read off the same two counts, and the page renders
+     * both of them. If they ever disagree the visitor sees an empty state
+     * stacked on top of the hierarchy it claims is not there, so the
+     * relationship is asserted over every combination rather than sampled.
+     */
+    test("never contradicts shouldRenderResourcesSection", () => {
+      const counts: Array<number> = [0, 1, 2, 1506];
+
+      for (const statusPageResourceCount of counts) {
+        for (const statusPageGroupCount of counts) {
+          const rendersSection: boolean =
+            StatusPageGroupNestingLayoutUtil.shouldRenderResourcesSection({
+              statusPageResourceCount: statusPageResourceCount,
+              statusPageGroupCount: statusPageGroupCount,
+            });
+
+          const rendersEmptyState: boolean = emptyPage({
+            statusPageResourceCount: statusPageResourceCount,
+            statusPageGroupCount: statusPageGroupCount,
+          });
+
+          expect(rendersSection && rendersEmptyState).toBe(false);
+          expect(rendersSection || rendersEmptyState).toBe(true);
+        }
+      }
+    });
+  });
+
   describe("shouldRenderTimeAxis", () => {
     const CHARTED: ObjectID = new ObjectID(
       "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",

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

@@ -1,4 +1,5 @@
 import StatusPageGroupTreeUtil, {
+  StatusPageGroupTreeIndex,
   StatusPageGroupTreeNode,
 } from "../../../Utils/StatusPage/GroupTree";
 import ObjectID from "../../../Types/ObjectID";
@@ -90,6 +91,36 @@ function namesOf(groups: Array<StatusPageGroup>): Array<string> {
   });
 }
 
+/*
+ * Counts how many times the walk under test asks a group who its parent is.
+ * That read is the primitive every tree helper is built on, so counting it is
+ * a deterministic stand-in for "did this scan the whole list per node?" - a
+ * wall clock assertion would just be a flake on a loaded CI box.
+ */
+function watchParentReads(groups: Array<StatusPageGroup>): () => number {
+  let reads: number = 0;
+
+  const watch: (group: StatusPageGroup) => void = (
+    group: StatusPageGroup,
+  ): void => {
+    const actualParentId: ObjectID | undefined = group.parentStatusPageGroupId;
+
+    Object.defineProperty(group, "parentStatusPageGroupId", {
+      configurable: true,
+      get: (): ObjectID | undefined => {
+        reads++;
+        return actualParentId;
+      },
+    });
+  };
+
+  groups.forEach(watch);
+
+  return (): number => {
+    return reads;
+  };
+}
+
 describe("StatusPageGroupTreeUtil", () => {
   describe("getParentId", () => {
     test("returns null for a top level group", () => {
@@ -580,4 +611,429 @@ describe("StatusPageGroupTreeUtil", () => {
       ).toHaveLength(0);
     });
   });
+
+  /*
+   * The index is an optimisation, and the only thing that makes an
+   * optimisation safe is that it cannot change an answer. Every helper is
+   * therefore asserted to give byte-identical results with and without one,
+   * across the same bad-data shapes the rest of this file covers.
+   */
+  describe("buildIndex", () => {
+    test("buckets children under their parent, in order", () => {
+      const groups: Array<StatusPageGroup> = makeHierarchy();
+
+      const index: StatusPageGroupTreeIndex =
+        StatusPageGroupTreeUtil.buildIndex({ statusPageGroups: groups });
+
+      expect(
+        namesOf(index.childrenByParentId.get(CORPORATE.toString()) || []),
+      ).toEqual(["Region 1000", "Region 2000"]);
+      expect(namesOf(index.childrenByParentId.get(null) || [])).toEqual([
+        "Corporate",
+      ]);
+      expect(index.byId.size).toBe(groups.length);
+      expect(index.byId.get(UNIT.toString())?.name).toBe("Unit 0152");
+    });
+
+    /*
+     * `null` rather than "" is the key for parentless groups on purpose: a
+     * group with no id of its own reads as "" everywhere in this class, and a
+     * string sentinel would make it adopt every root on the page.
+     */
+    test("a group with no id does not adopt the parentless groups", () => {
+      const idless: StatusPageGroup = new StatusPageGroup();
+      idless.name = "No id";
+
+      const groups: Array<StatusPageGroup> = [...makeHierarchy(), idless];
+
+      expect(
+        StatusPageGroupTreeUtil.getChildGroups({
+          statusPageGroupId: "",
+          statusPageGroups: groups,
+        }),
+      ).toHaveLength(0);
+    });
+
+    test("mutating the array getChildGroups returns leaves the index intact", () => {
+      const groups: Array<StatusPageGroup> = makeHierarchy();
+      const index: StatusPageGroupTreeIndex =
+        StatusPageGroupTreeUtil.buildIndex({ statusPageGroups: groups });
+
+      const children: Array<StatusPageGroup> =
+        StatusPageGroupTreeUtil.getChildGroups({
+          statusPageGroupId: CORPORATE.toString(),
+          statusPageGroups: groups,
+          index: index,
+        });
+
+      children.pop();
+
+      expect(
+        namesOf(
+          StatusPageGroupTreeUtil.getChildGroups({
+            statusPageGroupId: CORPORATE.toString(),
+            statusPageGroups: groups,
+            index: index,
+          }),
+        ),
+      ).toEqual(["Region 1000", "Region 2000"]);
+    });
+
+    describe("answers are identical with and without a supplied index", () => {
+      function cycle(): Array<StatusPageGroup> {
+        return [
+          makeGroup({
+            id: CORPORATE,
+            name: "A",
+            parentId: REGION_ONE,
+            order: 1,
+          }),
+          makeGroup({
+            id: REGION_ONE,
+            name: "B",
+            parentId: CORPORATE,
+            order: 2,
+          }),
+        ];
+      }
+
+      function orphanAndSelfParent(): Array<StatusPageGroup> {
+        return [
+          makeGroup({ id: CORPORATE, name: "Self", parentId: CORPORATE }),
+          makeGroup({ id: REGION_ONE, name: "Orphan", parentId: MISSING }),
+          makeGroup({ id: MARKET, name: "Unordered" }),
+        ];
+      }
+
+      const SHAPES: Array<{
+        name: string;
+        groups: () => Array<StatusPageGroup>;
+      }> = [
+        { name: "a normal hierarchy", groups: makeHierarchy },
+        { name: "a cycle", groups: cycle },
+        { name: "orphans and self parents", groups: orphanAndSelfParent },
+        {
+          name: "an empty list",
+          groups: (): Array<StatusPageGroup> => {
+            return [];
+          },
+        },
+      ];
+
+      test.each(SHAPES)(
+        "$name",
+        ({ groups }: { groups: () => Array<StatusPageGroup> }) => {
+          const list: Array<StatusPageGroup> = groups();
+          const index: StatusPageGroupTreeIndex =
+            StatusPageGroupTreeUtil.buildIndex({ statusPageGroups: list });
+
+          expect(
+            namesOf(
+              StatusPageGroupTreeUtil.getRootGroups({
+                statusPageGroups: list,
+                index: index,
+              }),
+            ),
+          ).toEqual(
+            namesOf(
+              StatusPageGroupTreeUtil.getRootGroups({ statusPageGroups: list }),
+            ),
+          );
+
+          const flatten: (
+            nodes: Array<StatusPageGroupTreeNode>,
+          ) => Array<string> = (
+            nodes: Array<StatusPageGroupTreeNode>,
+          ): Array<string> => {
+            return nodes.flatMap((node: StatusPageGroupTreeNode) => {
+              return [
+                `${node.group.name}@${node.depth}`,
+                ...flatten(node.children),
+              ];
+            });
+          };
+
+          expect(
+            flatten(
+              StatusPageGroupTreeUtil.buildTree({
+                statusPageGroups: list,
+                index: index,
+              }),
+            ),
+          ).toEqual(
+            flatten(
+              StatusPageGroupTreeUtil.buildTree({ statusPageGroups: list }),
+            ),
+          );
+
+          for (const group of list) {
+            expect(
+              namesOf(
+                StatusPageGroupTreeUtil.getGroupAndDescendants({
+                  statusPageGroup: group,
+                  statusPageGroups: list,
+                  index: index,
+                }),
+              ),
+            ).toEqual(
+              namesOf(
+                StatusPageGroupTreeUtil.getGroupAndDescendants({
+                  statusPageGroup: group,
+                  statusPageGroups: list,
+                }),
+              ),
+            );
+
+            expect(
+              namesOf(
+                StatusPageGroupTreeUtil.getAncestorGroups({
+                  statusPageGroup: group,
+                  statusPageGroups: list,
+                  index: index,
+                }),
+              ),
+            ).toEqual(
+              namesOf(
+                StatusPageGroupTreeUtil.getAncestorGroups({
+                  statusPageGroup: group,
+                  statusPageGroups: list,
+                }),
+              ),
+            );
+
+            expect(
+              StatusPageGroupTreeUtil.getDepth({
+                statusPageGroup: group,
+                statusPageGroups: list,
+                index: index,
+              }),
+            ).toBe(
+              StatusPageGroupTreeUtil.getDepth({
+                statusPageGroup: group,
+                statusPageGroups: list,
+              }),
+            );
+          }
+        },
+      );
+    });
+  });
+
+  /*
+   * The bug this file's fix belongs to was filed against a status page with
+   * 1506 groups. Nothing below asserts a wall clock time - a test that fails
+   * on a loaded CI box is worse than no test - but the shape of the work is
+   * pinned: every group has to come back, at the right depth, and the walk has
+   * to stay near linear rather than degrading into a scan of the whole list
+   * per node.
+   */
+  describe("at the size the bug was reported at", () => {
+    const CORPORATE_UNITS: number = 6;
+    const REGIONS_PER_UNIT: number = 5;
+    const MARKETS_PER_REGION: number = 5;
+    const SITES_PER_MARKET: number = 10;
+
+    function makeLargeHierarchy(): Array<StatusPageGroup> {
+      const groups: Array<StatusPageGroup> = [];
+      let order: number = 0;
+
+      const idFor: (label: string) => ObjectID = (label: string): ObjectID => {
+        return new ObjectID(label);
+      };
+
+      for (let unit: number = 0; unit < CORPORATE_UNITS; unit++) {
+        const unitId: ObjectID = idFor(`unit-${unit}`);
+        groups.push(
+          makeGroup({ id: unitId, name: `Unit ${unit}`, order: order++ }),
+        );
+
+        for (let region: number = 0; region < REGIONS_PER_UNIT; region++) {
+          const regionId: ObjectID = idFor(`unit-${unit}-region-${region}`);
+          groups.push(
+            makeGroup({
+              id: regionId,
+              name: `Region ${unit}-${region}`,
+              parentId: unitId,
+              order: order++,
+            }),
+          );
+
+          for (let market: number = 0; market < MARKETS_PER_REGION; market++) {
+            const marketId: ObjectID = idFor(
+              `unit-${unit}-region-${region}-market-${market}`,
+            );
+            groups.push(
+              makeGroup({
+                id: marketId,
+                name: `Market ${unit}-${region}-${market}`,
+                parentId: regionId,
+                order: order++,
+              }),
+            );
+
+            for (let site: number = 0; site < SITES_PER_MARKET; site++) {
+              groups.push(
+                makeGroup({
+                  id: idFor(
+                    `unit-${unit}-region-${region}-market-${market}-site-${site}`,
+                  ),
+                  name: `Site ${unit}-${region}-${market}-${site}`,
+                  parentId: marketId,
+                  order: order++,
+                }),
+              );
+            }
+          }
+        }
+      }
+
+      return groups;
+    }
+
+    const EXPECTED_TOTAL: number =
+      CORPORATE_UNITS *
+      (1 +
+        REGIONS_PER_UNIT * (1 + MARKETS_PER_REGION * (1 + SITES_PER_MARKET)));
+
+    test("the fixture really is the reported size", () => {
+      expect(makeLargeHierarchy()).toHaveLength(EXPECTED_TOTAL);
+      expect(EXPECTED_TOTAL).toBeGreaterThan(1500);
+    });
+
+    test("every one of the groups reaches the tree, at the right depth", () => {
+      const groups: Array<StatusPageGroup> = makeLargeHierarchy();
+
+      const depthByName: Map<string, number> = new Map<string, number>();
+
+      const visit: (nodes: Array<StatusPageGroupTreeNode>) => void = (
+        nodes: Array<StatusPageGroupTreeNode>,
+      ): void => {
+        for (const node of nodes) {
+          depthByName.set(node.group.name || "", node.depth);
+          visit(node.children);
+        }
+      };
+
+      visit(StatusPageGroupTreeUtil.buildTree({ statusPageGroups: groups }));
+
+      expect(depthByName.size).toBe(groups.length);
+
+      for (const group of groups) {
+        const name: string = group.name || "";
+        const expectedDepth: number = name.startsWith("Unit ")
+          ? 0
+          : name.startsWith("Region ")
+            ? 1
+            : name.startsWith("Market ")
+              ? 2
+              : 3;
+
+        expect(depthByName.get(name)).toBe(expectedDepth);
+      }
+    });
+
+    test("a subtree rollup covers exactly its own branch", () => {
+      const groups: Array<StatusPageGroup> = makeLargeHierarchy();
+      const index: StatusPageGroupTreeIndex =
+        StatusPageGroupTreeUtil.buildIndex({ statusPageGroups: groups });
+
+      const oneUnit: StatusPageGroup = groups.find((group: StatusPageGroup) => {
+        return group.name === "Unit 3";
+      })!;
+
+      const subtree: Array<StatusPageGroup> =
+        StatusPageGroupTreeUtil.getGroupAndDescendants({
+          statusPageGroup: oneUnit,
+          statusPageGroups: groups,
+          index: index,
+        });
+
+      expect(subtree).toHaveLength(
+        1 +
+          REGIONS_PER_UNIT * (1 + MARKETS_PER_REGION * (1 + SITES_PER_MARKET)),
+      );
+
+      for (const group of subtree) {
+        expect(group.name).toMatch(/(Unit 3|[A-Za-z]+ 3-)/);
+      }
+    });
+
+    /*
+     * The regression guard for the walk itself. Before the index, answering
+     * "who are this group's children?" filtered the whole list, so one full
+     * pass over the tree touched every group once per node - at this size,
+     * millions of comparisons. Counting parent reads rather than milliseconds
+     * keeps this deterministic: a scan-per-node implementation lands at
+     * groups x nodes, which is three orders of magnitude above the bound here.
+     */
+    test("building the tree does not re-scan the group list per node", () => {
+      const groups: Array<StatusPageGroup> = makeLargeHierarchy();
+      const countParentReads: () => number = watchParentReads(groups);
+
+      StatusPageGroupTreeUtil.buildTree({ statusPageGroups: groups });
+
+      // One bucketing pass plus the root scan, not one scan per node.
+      expect(countParentReads()).toBeLessThan(groups.length * 4);
+    });
+
+    test("a rollup per group stays near linear when the index is shared", () => {
+      const groups: Array<StatusPageGroup> = makeLargeHierarchy();
+      const index: StatusPageGroupTreeIndex =
+        StatusPageGroupTreeUtil.buildIndex({ statusPageGroups: groups });
+
+      const countParentReads: () => number = watchParentReads(groups);
+
+      for (const group of groups) {
+        StatusPageGroupTreeUtil.getGroupAndDescendants({
+          statusPageGroup: group,
+          statusPageGroups: groups,
+          index: index,
+        });
+      }
+
+      /*
+       * A shared index means a subtree walk reads no parent pointers at all.
+       * Without one this loop is groups x groups reads - over two million.
+       */
+      expect(countParentReads()).toBe(0);
+    });
+
+    /*
+     * Nesting is capped on write, but rows written straight to the database
+     * are not, and a chain that deep must not blow the recursion in buildTree.
+     */
+    test("a long chain of nested groups still builds", () => {
+      const groups: Array<StatusPageGroup> = [];
+      let previousId: ObjectID | undefined = undefined;
+
+      for (let i: number = 0; i < 1000; i++) {
+        const id: ObjectID = new ObjectID(`chain-${i}`);
+        groups.push(
+          makeGroup({
+            id: id,
+            name: `Level ${i}`,
+            parentId: previousId,
+            order: i,
+          }),
+        );
+        previousId = id;
+      }
+
+      const tree: Array<StatusPageGroupTreeNode> =
+        StatusPageGroupTreeUtil.buildTree({ statusPageGroups: groups });
+
+      expect(tree).toHaveLength(1);
+
+      let node: StatusPageGroupTreeNode = tree[0]!;
+      let depth: number = 0;
+
+      while (node.children.length > 0) {
+        node = node.children[0]!;
+        depth++;
+      }
+
+      expect(depth).toBe(999);
+      expect(node.group.name).toBe("Level 999");
+    });
+  });
 });