@oneuptime/common 13.0.6 → 13.0.7

package/Tests/Server/Utils/Monitor/Criteria/CompareCriteriaHumanMessages.test.ts

@@ -0,0 +1,513 @@
+import CompareCriteria from "../../../../../Server/Utils/Monitor/Criteria/CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+
+function metricFilter(
+  filterType: FilterType,
+  evaluationType?: EvaluateOverTimeType,
+): CriteriaFilter {
+  return {
+    checkOn: CheckOn.MetricValue,
+    filterType,
+    value: 90,
+    metricMonitorOptions: {
+      metricAggregationType: evaluationType,
+    },
+  };
+}
+
+interface ComparisonCase {
+  filterType: FilterType;
+  relation: string;
+  matching: number;
+  nonmatching: number;
+}
+
+const COMPARISONS: Array<ComparisonCase> = [
+  {
+    filterType: FilterType.GreaterThan,
+    relation: "above",
+    matching: 95,
+    nonmatching: 90,
+  },
+  {
+    filterType: FilterType.GreaterThanOrEqualTo,
+    relation: "at or above",
+    matching: 90,
+    nonmatching: 85,
+  },
+  {
+    filterType: FilterType.LessThan,
+    relation: "below",
+    matching: 85,
+    nonmatching: 90,
+  },
+  {
+    filterType: FilterType.LessThanOrEqualTo,
+    relation: "at or below",
+    matching: 90,
+    nonmatching: 95,
+  },
+  {
+    filterType: FilterType.EqualTo,
+    relation: "equal to",
+    matching: 90,
+    nonmatching: 95,
+  },
+  {
+    filterType: FilterType.NotEqualTo,
+    relation: "different from",
+    matching: 95,
+    nonmatching: 90,
+  },
+];
+
+describe("human-readable numeric criteria messages", () => {
+  describe.each(COMPARISONS)(
+    "$filterType",
+    ({ filterType, relation, matching, nonmatching }: ComparisonCase) => {
+      test("describes a matching scalar without implying multiple readings", () => {
+        expect(
+          CompareCriteria.compareCriteriaNumbers({
+            value: matching,
+            threshold: 90,
+            criteriaFilter: metricFilter(filterType),
+            metricDisplayName: "CPU",
+            unit: "%",
+          }),
+        ).toBe(
+          `CPU was ${matching.toFixed(2)}%, ${relation} the 90.00% threshold.`,
+        );
+      });
+
+      test("does not produce a root cause for a scalar that did not match", () => {
+        expect(
+          CompareCriteria.compareCriteriaNumbers({
+            value: nonmatching,
+            threshold: 90,
+            criteriaFilter: metricFilter(filterType),
+            metricDisplayName: "CPU",
+            unit: "%",
+          }),
+        ).toBeNull();
+      });
+
+      test("AnyValue counts only matching readings, including duplicates", () => {
+        expect(
+          CompareCriteria.compareCriteriaNumbers({
+            value: [nonmatching, matching, nonmatching, matching, nonmatching],
+            threshold: 90,
+            criteriaFilter: metricFilter(
+              filterType,
+              EvaluateOverTimeType.AnyValue,
+            ),
+            metricDisplayName: "CPU",
+            unit: "%",
+          }),
+        ).toBe(
+          `CPU was ${matching.toFixed(2)}% in 2 of 5 readings, ${relation} the 90.00% threshold.`,
+        );
+      });
+
+      test("AllValues reports the full count without repeating identical values", () => {
+        expect(
+          CompareCriteria.compareCriteriaNumbers({
+            value: [matching, matching, matching],
+            threshold: 90,
+            criteriaFilter: metricFilter(
+              filterType,
+              EvaluateOverTimeType.AllValues,
+            ),
+            metricDisplayName: "CPU",
+            unit: "%",
+          }),
+        ).toBe(
+          `CPU was ${matching.toFixed(2)}% in all 3 readings, ${relation} the 90.00% threshold.`,
+        );
+      });
+
+      test("AllValues still rejects a window containing a nonmatching reading", () => {
+        expect(
+          CompareCriteria.compareCriteriaNumbers({
+            value: [matching, nonmatching, matching],
+            threshold: 90,
+            criteriaFilter: metricFilter(
+              filterType,
+              EvaluateOverTimeType.AllValues,
+            ),
+            metricDisplayName: "CPU",
+            unit: "%",
+          }),
+        ).toBeNull();
+      });
+
+      test("a direct description distinguishes an unmet requirement from the observation", () => {
+        expect(
+          CompareCriteria.getCompareMessage({
+            values: nonmatching,
+            threshold: 90,
+            criteriaFilter: metricFilter(filterType),
+            metricDisplayName: "CPU",
+            unit: "%",
+          }),
+        ).toBe(
+          `CPU was ${nonmatching.toFixed(2)}%. The condition requires the value to be ${relation} the 90.00% threshold.`,
+        );
+      });
+    },
+  );
+
+  test.each([
+    EvaluateOverTimeType.AnyValue,
+    EvaluateOverTimeType.AllValues,
+    undefined,
+  ])(
+    "summarizes the repeated HPA saturation readings with %s",
+    (evaluationType: EvaluateOverTimeType | undefined) => {
+      expect(
+        CompareCriteria.compareCriteriaNumbers({
+          value: [100, 100, 100, 100, 100],
+          threshold: 90,
+          criteriaFilter: metricFilter(
+            FilterType.GreaterThanOrEqualTo,
+            evaluationType,
+          ),
+          metricDisplayName: "(current_replicas / max_replicas) * 100",
+          unit: "%",
+        }),
+      ).toBe(
+        "(current_replicas / max_replicas) * 100 was 100.00% in all 5 readings, at or above the 90.00% threshold.",
+      );
+    },
+  );
+
+  test("summarizes the repeated healthy readings from the evaluation screenshot", () => {
+    expect(
+      CompareCriteria.compareCriteriaNumbers({
+        value: [100 / 3, 100 / 3, 100 / 3, 100 / 3, 100 / 3],
+        threshold: 81,
+        criteriaFilter: metricFilter(
+          FilterType.LessThan,
+          EvaluateOverTimeType.AllValues,
+        ),
+        metricDisplayName: "(current_replicas / max_replicas) * 100",
+        unit: "%",
+      }),
+    ).toBe(
+      "(current_replicas / max_replicas) * 100 was 33.33% in all 5 readings, below the 81.00% threshold.",
+    );
+  });
+
+  test("uses singular grammar for a one-reading window", () => {
+    expect(
+      CompareCriteria.getCompareMessage({
+        values: [100],
+        threshold: 90,
+        criteriaFilter: metricFilter(
+          FilterType.GreaterThan,
+          EvaluateOverTimeType.AllValues,
+        ),
+        metricDisplayName: "CPU",
+        unit: "%",
+      }),
+    ).toBe("CPU was 100.00% in 1 reading, above the 90.00% threshold.");
+  });
+
+  test("summarizes a varied window in numeric order without mutating it", () => {
+    const values: Array<number> = [97, 95, 96];
+    const original: Array<number> = [...values];
+
+    expect(
+      CompareCriteria.getCompareMessage({
+        values,
+        threshold: 90,
+        criteriaFilter: metricFilter(FilterType.GreaterThan),
+        metricDisplayName: "CPU",
+        unit: "%",
+      }),
+    ).toBe(
+      "CPU ranged from 95.00% to 97.00% across all 3 readings, above the 90.00% threshold.",
+    );
+    expect(values).toEqual(original);
+  });
+
+  test("a recovery range excludes readings that do not satisfy the condition", () => {
+    expect(
+      CompareCriteria.getCompareMessage({
+        values: [95, 80, 70],
+        threshold: 90,
+        criteriaFilter: metricFilter(
+          FilterType.LessThanOrEqualTo,
+          EvaluateOverTimeType.AnyValue,
+        ),
+        metricDisplayName: "CPU",
+        unit: "%",
+      }),
+    ).toBe(
+      "CPU ranged from 70.00% to 80.00% across 2 of 3 readings, at or below the 90.00% threshold.",
+    );
+  });
+
+  test("handles zero and negative readings without losing the sign or count", () => {
+    expect(
+      CompareCriteria.getCompareMessage({
+        values: [-2.125, 0, -1],
+        threshold: 0,
+        criteriaFilter: metricFilter(
+          FilterType.LessThanOrEqualTo,
+          EvaluateOverTimeType.AllValues,
+        ),
+        metricDisplayName: "Temperature",
+      }),
+    ).toBe(
+      "Temperature ranged from -2.13 to 0 across all 3 readings, at or below the 0 threshold.",
+    );
+  });
+
+  test("keeps a large evaluation window concise", () => {
+    const values: Array<number> = Array.from(
+      { length: 10000 },
+      (_: unknown, index: number) => {
+        return index + 1;
+      },
+    );
+
+    expect(
+      CompareCriteria.getCompareMessage({
+        values,
+        threshold: 0,
+        criteriaFilter: metricFilter(FilterType.GreaterThan),
+        metricDisplayName: "Queue length",
+      }),
+    ).toBe(
+      "Queue length ranged from 1 to 10000 across all 10000 readings, above the 0 threshold.",
+    );
+  });
+
+  test.each([
+    {
+      evaluationType: EvaluateOverTimeType.Average,
+      name: "average",
+      value: 20,
+    },
+    { evaluationType: EvaluateOverTimeType.Sum, name: "sum", value: 60 },
+    {
+      evaluationType: EvaluateOverTimeType.MaximumValue,
+      name: "maximum",
+      value: 30,
+    },
+    {
+      evaluationType: EvaluateOverTimeType.MunimumValue,
+      name: "minimum",
+      value: 10,
+    },
+  ])(
+    "reports the $name without treating it as one matching sample",
+    ({
+      evaluationType,
+      name,
+      value,
+    }: {
+      evaluationType: EvaluateOverTimeType;
+      name: string;
+      value: number;
+    }) => {
+      expect(
+        CompareCriteria.compareCriteriaNumbers({
+          value: [10, 20, 30],
+          threshold: 5,
+          criteriaFilter: metricFilter(FilterType.GreaterThan, evaluationType),
+          metricDisplayName: "CPU",
+          unit: "%",
+        }),
+      ).toBe(
+        `The ${name} of CPU was ${value.toFixed(2)}%, above the 5.00% threshold.`,
+      );
+    },
+  );
+
+  test("uses the same evaluation mode as the comparator when both options are saved", () => {
+    const filter: CriteriaFilter = metricFilter(
+      FilterType.GreaterThan,
+      EvaluateOverTimeType.AllValues,
+    );
+    filter.evaluateOverTimeOptions = {
+      evaluateOverTimeType: EvaluateOverTimeType.AnyValue,
+      timeValueInMinutes: 5,
+    };
+
+    expect(
+      CompareCriteria.compareCriteriaNumbers({
+        value: [10, 95],
+        threshold: 90,
+        criteriaFilter: filter,
+        metricDisplayName: "CPU",
+        unit: "%",
+      }),
+    ).toBe("CPU was 95.00% in 1 of 2 readings, above the 90.00% threshold.");
+  });
+
+  test.each([
+    { minutes: 1, duration: "1 minute" },
+    { minutes: 5, duration: "5 minutes" },
+  ])(
+    "uses natural duration grammar for $duration",
+    ({ minutes, duration }: { minutes: number; duration: string }) => {
+      const filter: CriteriaFilter = metricFilter(
+        FilterType.GreaterThan,
+        EvaluateOverTimeType.Average,
+      );
+      filter.evaluateOverTime = true;
+      filter.evaluateOverTimeOptions = {
+        evaluateOverTimeType: EvaluateOverTimeType.Average,
+        timeValueInMinutes: minutes,
+      };
+
+      expect(
+        CompareCriteria.compareCriteriaNumbers({
+          value: [10, 20, 30],
+          threshold: 15,
+          criteriaFilter: filter,
+          metricDisplayName: "CPU",
+          unit: "%",
+        }),
+      ).toBe(
+        `The average of CPU over the last ${duration} was 20.00%, above the 15.00% threshold.`,
+      );
+    },
+  );
+
+  test.each([
+    {
+      evaluationType: EvaluateOverTimeType.AnyValue,
+      requirement: "at least one reading",
+    },
+    {
+      evaluationType: EvaluateOverTimeType.AllValues,
+      requirement: "every reading",
+    },
+    { evaluationType: undefined, requirement: "every reading" },
+  ])(
+    "does not claim an unmet $evaluationType condition was satisfied",
+    ({
+      evaluationType,
+      requirement,
+    }: {
+      evaluationType: EvaluateOverTimeType | undefined;
+      requirement: string;
+    }) => {
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: [70, 80],
+          threshold: 90,
+          criteriaFilter: metricFilter(FilterType.GreaterThan, evaluationType),
+          metricDisplayName: "CPU",
+          unit: "%",
+        }),
+      ).toBe(
+        `CPU ranged from 70.00% to 80.00% across all 2 readings. The condition requires ${requirement} to be above the 90.00% threshold.`,
+      );
+    },
+  );
+
+  test("an unmet average condition still reports the actual average", () => {
+    expect(
+      CompareCriteria.getCompareMessage({
+        values: [10, 20, 30],
+        threshold: 90,
+        criteriaFilter: metricFilter(
+          FilterType.GreaterThan,
+          EvaluateOverTimeType.Average,
+        ),
+        metricDisplayName: "CPU",
+        unit: "%",
+      }),
+    ).toBe(
+      "The average of CPU was 20.00%. The condition requires the average to be above the 90.00% threshold.",
+    );
+  });
+
+  test("a partly matching AllValues window reports its whole range and unmet requirement", () => {
+    expect(
+      CompareCriteria.getCompareMessage({
+        values: [100, 80],
+        threshold: 90,
+        criteriaFilter: metricFilter(
+          FilterType.GreaterThan,
+          EvaluateOverTimeType.AllValues,
+        ),
+        metricDisplayName: "CPU",
+        unit: "%",
+      }),
+    ).toBe(
+      "CPU ranged from 80.00% to 100.00% across all 2 readings. The condition requires every reading to be above the 90.00% threshold.",
+    );
+  });
+
+  test("preserves disk and time context in the same observation", () => {
+    const filter: CriteriaFilter = {
+      checkOn: CheckOn.DiskUsagePercent,
+      filterType: FilterType.GreaterThan,
+      value: 90,
+      serverMonitorOptions: { diskPath: "/var/log" },
+      evaluateOverTime: true,
+      evaluateOverTimeOptions: {
+        evaluateOverTimeType: EvaluateOverTimeType.AllValues,
+        timeValueInMinutes: 1,
+      },
+    };
+
+    expect(
+      CompareCriteria.getCompareMessage({
+        values: [95, 95],
+        threshold: 90,
+        criteriaFilter: filter,
+      }),
+    ).toBe(
+      "Disk Usage (in %) on disk /var/log over the last 1 minute was 95 in all 2 readings, above the 90 threshold.",
+    );
+  });
+
+  test.each([NaN, Infinity, -Infinity])(
+    "a non-finite reading (%s) is not summarized as a numeric range",
+    (value: number) => {
+      const message: string = CompareCriteria.getCompareMessage({
+        values: [95, value],
+        threshold: 90,
+        criteriaFilter: metricFilter(FilterType.GreaterThan),
+        metricDisplayName: "CPU",
+        unit: "%",
+      });
+
+      expect(message).toContain(String(value));
+      expect(message).not.toContain("ranged from");
+      expect(message).not.toContain("readings");
+    },
+  );
+
+  test.each([
+    EvaluateOverTimeType.AnyValue,
+    EvaluateOverTimeType.AllValues,
+    EvaluateOverTimeType.Average,
+    EvaluateOverTimeType.Sum,
+    EvaluateOverTimeType.MaximumValue,
+    EvaluateOverTimeType.MunimumValue,
+  ])(
+    "an empty %s window still produces no root cause",
+    (evaluationType: EvaluateOverTimeType) => {
+      expect(
+        CompareCriteria.compareCriteriaNumbers({
+          value: [],
+          threshold: 90,
+          criteriaFilter: metricFilter(FilterType.GreaterThan, evaluationType),
+          metricDisplayName: "CPU",
+          unit: "%",
+        }),
+      ).toBeNull();
+    },
+  );
+});

package/Tests/Server/Utils/Monitor/Criteria/CustomCodeMonitorCriteria.test.ts

@@ -63,7 +63,7 @@ describe("CustomCodeMonitoringCriteria.isMonitorInstanceCriteriaFilterMet", () =
 
       expect(result).toBeTruthy();
       expect(result).toContain("Execution Time");
-      expect(result).toContain("greater than");
+      expect(result).toContain("above the 1000 threshold");
     });
 
     test("execution below threshold → not met", async () => {
@@ -445,7 +445,7 @@ describe("CustomCodeMonitoringCriteria.isMonitorInstanceCriteriaFilterMet", () =
 
       expect(result).toBeTruthy();
       expect(result).toContain("Result Value");
-      expect(result).toContain("greater than");
+      expect(result).toContain("above the 40 threshold");
     });
 
     test("numeric result below a numeric threshold → not met", async () => {

package/Tests/Server/Utils/Monitor/Criteria/DnsMonitorCriteria.test.ts

@@ -614,7 +614,7 @@ describe("DnsMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       );
 
       expect(result).toContain("DNS record (MX)");
-      expect(result).toContain("greater than");
+      expect(result).toContain("above the 200 threshold");
     });
 
     test("numeric record value + GreaterThan numeric threshold not exceeded → undecidable", async () => {

package/Tests/Server/Utils/Monitor/Criteria/ExternalStatusPageMonitorCriteria.test.ts

@@ -242,7 +242,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
 
       expect(result).toContain("External Status Page Response Time");
       expect(result).toContain("500");
-      expect(result).toContain("greater than 100");
+      expect(result).toContain("above the 100 threshold");
     });
 
     test("response time below threshold + GreaterThan → not met", async () => {
@@ -294,7 +294,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
       );
 
       expect(result).toContain("External Status Page Response Time");
-      expect(result).toContain("greater than or equal to 100");
+      expect(result).toContain("at or above the 100 threshold");
     });
 
     test("response time below threshold + LessThan → met", async () => {
@@ -311,7 +311,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
         },
       );
 
-      expect(result).toContain("less than 100");
+      expect(result).toContain("below the 100 threshold");
     });
 
     test("numeric string threshold is accepted", async () => {
@@ -328,7 +328,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
         },
       );
 
-      expect(result).toContain("greater than 100");
+      expect(result).toContain("above the 100 threshold");
     });
 
     test("undefined threshold → undecidable", async () => {
@@ -410,7 +410,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
       );
 
       expect(result).toContain("250");
-      expect(result).toContain("greater than 100");
+      expect(result).toContain("above the 100 threshold");
     });
 
     /*
@@ -823,7 +823,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
 
       expect(result).toContain("External Status Page Active Incidents");
       expect(result).toContain("3");
-      expect(result).toContain("greater than 2");
+      expect(result).toContain("above the 2 threshold");
     });
 
     test("incident count equal to threshold + GreaterThan → not met (boundary)", async () => {
@@ -857,7 +857,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
         },
       );
 
-      expect(result).toContain("greater than or equal to 2");
+      expect(result).toContain("at or above the 2 threshold");
     });
 
     /*
@@ -876,7 +876,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
       );
 
       expect(result).toContain("0");
-      expect(result).toContain("less than or equal to 5");
+      expect(result).toContain("at or below the 5 threshold");
     });
 
     test("zero incidents + GreaterThan zero → not met", async () => {
@@ -910,7 +910,7 @@ describe("ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet",
         },
       );
 
-      expect(result).toContain("greater than 2");
+      expect(result).toContain("above the 2 threshold");
     });
   });
 });

package/Tests/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.test.ts

@@ -118,7 +118,7 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
      * ms is written "2.5 sec"; the threshold gets the same treatment so
      * the two halves of the sentence cannot disagree.
      */
-    expect(message).toContain("greater than 2 sec");
+    expect(message).toContain("above the 2 sec threshold");
     expect(message).toContain("2.5 sec");
     expect(criteriaFilter.metricCriteriaContext?.unit).toBe("ms");
     expect(criteriaFilter.metricCriteriaContext?.breachingSample?.value).toBe(
@@ -149,7 +149,7 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet(inputs);
 
     expect(message).toBeTruthy();
-    expect(message).toContain("greater than 2 sec");
+    expect(message).toContain("above the 2 sec threshold");
     expect(message).toContain("2.5 sec");
     expect(criteriaFilter.metricCriteriaContext?.unit).toBe("sec");
     expect(criteriaFilter.metricCriteriaContext?.breachingSample?.value).toBe(
@@ -179,7 +179,7 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet(inputs);
 
     expect(message).toBeTruthy();
-    expect(message).toContain("greater than 2 GB");
+    expect(message).toContain("above the 2 GB threshold");
     expect(message).toContain("2.5 GB");
     expect(criteriaFilter.metricCriteriaContext?.unit).toBe("GB");
   });
@@ -519,8 +519,10 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
      * land on a different scale than the other once values spread far
      * enough apart.
      */
-    expect(message).toContain("10 samples between 110 ms and 200 ms");
-    expect(message).toContain("greater than 100 ms");
+    expect(message).toContain(
+      "ranged from 110 ms to 200 ms across all 10 readings",
+    );
+    expect(message).toContain("above the 100 ms threshold");
     // The raw comma-joined dump is no longer in the message
     expect(message).not.toContain("110, 120, 130, 140, 150, 160");
   });

package/Tests/Server/Utils/Monitor/Criteria/ProfileMonitorCriteria.test.ts

@@ -47,7 +47,7 @@ describe("ProfileMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       });
       expect(result).toBeTruthy();
       expect(result).toContain("Profile Count");
-      expect(result).toContain("greater than");
+      expect(result).toContain("above the 5 threshold");
     });
 
     test("count equal to threshold → not met (strict comparison)", async () => {
@@ -111,7 +111,7 @@ describe("ProfileMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
         value: 0,
       });
       expect(result).toBeTruthy();
-      expect(result).toContain("equal to 0");
+      expect(result).toContain("equal to the 0 threshold");
     });
 
     test("some profiles equal to 0 → not met", async () => {

package/Tests/Server/Utils/Monitor/Criteria/ServerMonitorCriteria.test.ts

@@ -279,7 +279,7 @@ describe("ServerMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       );
 
       expect(result).toContain(CheckOn.CPUUsagePercent);
-      expect(result).toContain("greater than");
+      expect(result).toContain("above the 50 threshold");
       expect(result).toContain("80");
     });
 
@@ -1114,8 +1114,9 @@ describe("ServerMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
         },
       );
 
-      expect(result).toContain("All values of");
-      expect(result).toContain("95");
+      expect(result).toBe(
+        "Disk Usage (in %) on disk / over the last 5 minutes ranged from 95 to 97 across all 3 readings, above the 90 threshold.",
+      );
     });
 
     test("disk usage does not fire while its window is unusable", async () => {