@oneuptime/common 13.0.5 → 13.0.7

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

@@ -2,6 +2,9 @@ import DatabaseMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteri
 import EvaluateOverTime, {
   OverTimeCriteriaValue,
 } from "../../../../../Server/Utils/Monitor/Criteria/EvaluateOverTime";
+import MetricService from "../../../../../Server/Services/MetricService";
+import FindBy from "../../../../../Server/Types/AnalyticsDatabase/FindBy";
+import Metric from "../../../../../Models/AnalyticsModels/Metric";
 import {
   CheckOn,
   CriteriaFilter,
@@ -650,6 +653,184 @@ describe("DatabaseMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
     });
   });
 
+  /*
+   * The block above mocks the window away, which is how a Database Is Online
+   * filter that never matched once its window filled went unnoticed: the
+   * samples came back as raw 0 / 1, and True / False only match booleans.
+   *
+   * Only the metric read is stubbed here, so the samples go through the real
+   * conversion, coverage check and comparison.
+   */
+  describe("Database Is Online over a recorded window", () => {
+    const NOW: Date = new Date("2026-08-20T12:00:00.000Z");
+
+    let windowSamples: Array<Metric> = [];
+
+    /** Once a minute, oldest first, ending at `now`. */
+    function everyMinute(values: Array<number>): Array<Metric> {
+      return values.map((value: number, index: number) => {
+        const metric: Metric = new Metric();
+        metric.value = value;
+        metric.time = new Date(
+          NOW.getTime() - (values.length - 1 - index) * 60 * 1000,
+        );
+        return metric;
+      });
+    }
+
+    function isOnlineFilter(
+      filterType: FilterType,
+      evaluateOverTimeType: EvaluateOverTimeType = EvaluateOverTimeType.AllValues,
+    ): CriteriaFilter {
+      return {
+        checkOn: CheckOn.DatabaseIsOnline,
+        filterType: filterType,
+        value: undefined,
+        evaluateOverTime: true,
+        evaluateOverTimeOptions: {
+          timeValueInMinutes: 5,
+          evaluateOverTimeType: evaluateOverTimeType,
+        },
+      };
+    }
+
+    function evaluateWindow(input: {
+      isOnline: boolean;
+      criteriaFilter: CriteriaFilter;
+    }): Promise<string | null> {
+      return DatabaseMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildDataToProcess({ isOnline: input.isOnline }),
+        criteriaFilter: input.criteriaFilter,
+        monitoringInterval: "* * * * *",
+      });
+    }
+
+    beforeEach(() => {
+      jest.useFakeTimers();
+      jest.setSystemTime(NOW);
+
+      windowSamples = [];
+
+      jest
+        .spyOn(MetricService, "findBy")
+        .mockImplementation(
+          (_findBy: FindBy<Metric>): Promise<Array<Metric>> => {
+            return Promise.resolve(windowSamples);
+          },
+        );
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    test("a window that was offline throughout fires False", async () => {
+      windowSamples = everyMinute([0, 0, 0, 0, 0]);
+
+      const result: string | null = await evaluateWindow({
+        isOnline: false,
+        criteriaFilter: isOnlineFilter(FilterType.False),
+      });
+
+      expect(result).toContain("All values of");
+      expect(result).toContain(CheckOn.DatabaseIsOnline as string);
+      expect(result).toContain("over the last 5 minutes");
+      expect(result).toContain("is false");
+    });
+
+    test("a window that was offline throughout does not match True", async () => {
+      windowSamples = everyMinute([0, 0, 0, 0, 0]);
+
+      const result: string | null = await evaluateWindow({
+        isOnline: false,
+        criteriaFilter: isOnlineFilter(FilterType.True),
+      });
+
+      expect(result).toBeNull();
+    });
+
+    test("a window that was online throughout matches True", async () => {
+      windowSamples = everyMinute([1, 1, 1, 1, 1]);
+
+      const result: string | null = await evaluateWindow({
+        isOnline: true,
+        criteriaFilter: isOnlineFilter(FilterType.True),
+      });
+
+      expect(result).toContain("All values of");
+      expect(result).toContain(CheckOn.DatabaseIsOnline as string);
+      expect(result).toContain("is true");
+    });
+
+    test("a window that was online throughout does not fire False", async () => {
+      windowSamples = everyMinute([1, 1, 1, 1, 1]);
+
+      const result: string | null = await evaluateWindow({
+        isOnline: true,
+        criteriaFilter: isOnlineFilter(FilterType.False),
+      });
+
+      expect(result).toBeNull();
+    });
+
+    /*
+     * Whichever way this check went, it agrees with one of the two filters,
+     * so a comparison against the live value instead of the window would
+     * show up here.
+     */
+    test("a mixed window matches neither True nor False with All Values", async () => {
+      windowSamples = everyMinute([1, 1, 1, 0, 0]);
+
+      for (const isOnline of [true, false]) {
+        for (const filterType of [FilterType.True, FilterType.False]) {
+          const result: string | null = await evaluateWindow({
+            isOnline: isOnline,
+            criteriaFilter: isOnlineFilter(filterType),
+          });
+
+          expect(result).toBeNull();
+        }
+      }
+    });
+
+    test("Any Value fires False on a single offline sample", async () => {
+      windowSamples = everyMinute([1, 1, 1, 1, 0]);
+
+      const result: string | null = await evaluateWindow({
+        isOnline: false,
+        criteriaFilter: isOnlineFilter(
+          FilterType.False,
+          EvaluateOverTimeType.AnyValue,
+        ),
+      });
+
+      expect(result).toContain("Any value of");
+      expect(result).toContain("is false");
+    });
+
+    /*
+     * The intentional exemption: a window that does not cover the last five
+     * minutes yet falls back to this check, so a monitor that has only just
+     * started can still go offline.
+     */
+    test("a window that is still filling falls back to this check", async () => {
+      windowSamples = everyMinute([0]);
+
+      const whileOffline: string | null = await evaluateWindow({
+        isOnline: false,
+        criteriaFilter: isOnlineFilter(FilterType.False),
+      });
+
+      const whileOnline: string | null = await evaluateWindow({
+        isOnline: true,
+        criteriaFilter: isOnlineFilter(FilterType.False),
+      });
+
+      expect(whileOffline).toContain(CheckOn.DatabaseIsOnline as string);
+      expect(whileOnline).toBeNull();
+    });
+  });
+
   test("unrelated checkOn -> null", async () => {
     const result: string | null = await evaluate(buildDataToProcess({}), {
       checkOn: CheckOn.ResponseBody,

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/EvaluateOverTime.test.ts

@@ -74,6 +74,28 @@ function criteria(overrides: Partial<CriteriaFilter> = {}): CriteriaFilter {
   };
 }
 
+/*
+ * Probe CheckOns that write into the shared 1 / 0 online series instead of a
+ * series of their own.
+ */
+const SHARED_ONLINE_SERIES_CHECK_ONS: Array<CheckOn> = [
+  CheckOn.DnsIsOnline,
+  CheckOn.SnmpIsOnline,
+  CheckOn.ExternalStatusPageIsOnline,
+  CheckOn.DatabaseIsOnline,
+];
+
+/*
+ * Every CheckOn that evaluates over time against a 1 / 0 series.
+ * CompareCriteria.isTrue / isFalse match only real booleans, so the window
+ * and the Treat As Zero substitute must both come back as booleans for
+ * each of these.
+ */
+const BOOLEAN_SERIES_CHECK_ONS: Array<CheckOn> = [
+  CheckOn.IsOnline,
+  ...SHARED_ONLINE_SERIES_CHECK_ONS,
+];
+
 /*
  * The metric read is stubbed in memory rather than through a typed spy so
  * every query it receives can be asserted on directly.
@@ -243,14 +265,12 @@ describe("EvaluateOverTime", () => {
      * DNS / SNMP / External Status Page probes write into the shared online
      * and response-time series. Their CheckOns had no entry in the metric
      * map at all, so "evaluate over time" was a no-op for every one of them.
+     *
+     * Database Is Online reads the same online series. It was mapped to it,
+     * but its samples came back as raw 0 / 1, which no True / False filter
+     * ever matches.
      */
-    const onlineCheckOns: Array<CheckOn> = [
-      CheckOn.DnsIsOnline,
-      CheckOn.SnmpIsOnline,
-      CheckOn.ExternalStatusPageIsOnline,
-    ];
-
-    for (const checkOn of onlineCheckOns) {
+    for (const checkOn of SHARED_ONLINE_SERIES_CHECK_ONS) {
       test(`${checkOn} reads the online series`, async () => {
         mockSamples(everyMinute([0, 0, 0, 0, 0]));
 
@@ -808,19 +828,113 @@ describe("EvaluateOverTime", () => {
   });
 
   describe("boolean series", () => {
-    test("1 becomes true and everything else becomes false", async () => {
-      mockSamples(everyMinute([1, 0, 1, 1, 0]));
+    for (const checkOn of BOOLEAN_SERIES_CHECK_ONS) {
+      test(`${checkOn}: 1 becomes true and everything else becomes false`, async () => {
+        mockSamples(everyMinute([1, 0, 1, 1, 0]));
+
+        const result: OverTimeEvaluation = await evaluate({
+          criteriaFilter: criteria({
+            checkOn: checkOn,
+            filterType: FilterType.False,
+            value: undefined,
+          }),
+          monitoringInterval: "* * * * *",
+        });
+
+        expect(result.status).toBe(OverTimeEvaluationStatus.Evaluated);
+        expect(result.value).toEqual([true, false, true, true, false]);
+      });
+    }
+
+    const aggregateTypes: Array<EvaluateOverTimeType> = [
+      EvaluateOverTimeType.Average,
+      EvaluateOverTimeType.Sum,
+      EvaluateOverTimeType.MaximumValue,
+      EvaluateOverTimeType.MunimumValue,
+    ];
+
+    function booleanCriteria(input: {
+      checkOn: CheckOn;
+      evaluateOverTimeType: EvaluateOverTimeType;
+    }): CriteriaFilter {
+      return criteria({
+        checkOn: input.checkOn,
+        filterType: FilterType.False,
+        value: undefined,
+        evaluateOverTimeOptions: {
+          timeValueInMinutes: 5,
+          evaluateOverTimeType: input.evaluateOverTimeType,
+        },
+      });
+    }
+
+    /*
+     * An aggregate of a 1/0 window is a number such as 0.6, which neither
+     * True nor False matches. Such a filter is judged as All Values instead,
+     * so the window comes back as the samples themselves.
+     */
+    describe.each(BOOLEAN_SERIES_CHECK_ONS)(
+      "%s saved with an aggregate",
+      (checkOn: CheckOn) => {
+        test.each(aggregateTypes)(
+          "%s returns the samples rather than a number",
+          async (evaluateOverTimeType: EvaluateOverTimeType) => {
+            mockSamples(everyMinute([1, 0, 1, 1, 0]));
+
+            const result: OverTimeEvaluation = await evaluate({
+              criteriaFilter: booleanCriteria({
+                checkOn: checkOn,
+                evaluateOverTimeType: evaluateOverTimeType,
+              }),
+              monitoringInterval: "* * * * *",
+            });
+
+            expect(result.status).toBe(OverTimeEvaluationStatus.Evaluated);
+            expect(result.value).toEqual([true, false, true, true, false]);
+            expect(result.sampleCount).toBe(5);
+          },
+        );
+
+        test.each(aggregateTypes)(
+          "%s waits for the window to be covered, like All Values",
+          async (evaluateOverTimeType: EvaluateOverTimeType) => {
+            mockSamples([sample({ value: 0, minutesAgo: 0 })]);
+
+            const result: OverTimeEvaluation = await evaluate({
+              criteriaFilter: booleanCriteria({
+                checkOn: checkOn,
+                evaluateOverTimeType: evaluateOverTimeType,
+              }),
+              monitoringInterval: "* * * * *",
+            });
+
+            expect(result.status).toBe(
+              OverTimeEvaluationStatus.InsufficientData,
+            );
+            expect(result.value).toBeUndefined();
+            expect(result.sampleCount).toBe(1);
+          },
+        );
+      },
+    );
+
+    test("an aggregate on a numeric series on the same monitor still reduces", async () => {
+      mockSamples(everyMinute([10, 20, 30]));
 
       const result: OverTimeEvaluation = await evaluate({
         criteriaFilter: criteria({
-          checkOn: CheckOn.IsOnline,
-          filterType: FilterType.False,
-          value: undefined,
+          checkOn: CheckOn.DnsResponseTime,
+          filterType: FilterType.GreaterThan,
+          value: 15,
+          evaluateOverTimeOptions: {
+            timeValueInMinutes: 5,
+            evaluateOverTimeType: EvaluateOverTimeType.Average,
+          },
         }),
-        monitoringInterval: "* * * * *",
       });
 
-      expect(result.value).toEqual([true, false, true, true, false]);
+      expect(result.status).toBe(OverTimeEvaluationStatus.Evaluated);
+      expect(result.value).toBe(20);
     });
   });
 
@@ -926,24 +1040,27 @@ describe("EvaluateOverTime", () => {
       expect(result.value).toEqual([0]);
     });
 
-    test("Treat As Zero substitutes false for an online series", async () => {
-      mockSamples([]);
+    for (const checkOn of BOOLEAN_SERIES_CHECK_ONS) {
+      test(`Treat As Zero substitutes false for ${checkOn}`, async () => {
+        mockSamples([]);
 
-      const result: OverTimeCriteriaValue = await resolve({
-        criteriaFilter: criteria({
-          checkOn: CheckOn.IsOnline,
-          filterType: FilterType.False,
-          value: undefined,
-          evaluateOverTimeOptions: {
-            timeValueInMinutes: 5,
-            evaluateOverTimeType: EvaluateOverTimeType.AllValues,
-            onNoDataPolicy: NoDataPolicy.TreatAsZero,
-          },
-        }),
-      });
+        const result: OverTimeCriteriaValue = await resolve({
+          criteriaFilter: criteria({
+            checkOn: checkOn,
+            filterType: FilterType.False,
+            value: undefined,
+            evaluateOverTimeOptions: {
+              timeValueInMinutes: 5,
+              evaluateOverTimeType: EvaluateOverTimeType.AllValues,
+              onNoDataPolicy: NoDataPolicy.TreatAsZero,
+            },
+          }),
+        });
 
-      expect(result.value).toEqual([false]);
-    });
+        expect(result.earlyReturn).toBeNull();
+        expect(result.value).toEqual([false]);
+      });
+    }
 
     /*
      * A metric store we could not read tells us nothing about the monitor.

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 () => {

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

@@ -108,7 +108,7 @@ describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
 
       expect(result).toBeTruthy();
       expect(result).toContain(PSU_OID);
-      expect(result).toContain("equal to 3");
+      expect(result).toContain("equal to the 3 threshold");
     });
 
     test("Integer 3 equals 5 → criteria is not met", async () => {
@@ -163,7 +163,7 @@ describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
         });
 
       expect(result).toBeTruthy();
-      expect(result).toContain("not equal to 6");
+      expect(result).toContain("different from the 6 threshold");
     });
 
     test("Integer 3 contains '3' → criteria is met (string fallback path)", async () => {

package/Tests/Server/Utils/Monitor/MonitorCriteriaEvaluatorMetricUnits.test.ts

@@ -563,8 +563,9 @@ describe("MonitorCriteriaEvaluator - the table and the sentence agree", () => {
         bothRenderings(testCase);
 
       expect(rendered.cell.length).toBeGreaterThan(0);
-      expect(rendered.sentence).toContain(`is ${rendered.cell} which is`);
-      expect(rendered.sentence).toContain(`greater than ${rendered.cell}.`);
+      expect(rendered.sentence).toBe(
+        `${testCase.metricName} was ${rendered.cell}. The condition requires the value to be above the ${rendered.cell} threshold.`,
+      );
     });
   }
 });

package/Tests/Server/Utils/Monitor/MonitorCriteriaExpectationBuilder.test.ts

@@ -296,5 +296,22 @@ describe("MonitorCriteriaExpectationBuilder", () => {
         ),
       ).toBe("over the last 5 minutes using average");
     });
+
+    // The server judges a true/false series saved with an aggregate as All Values.
+    test("describes a true/false filter saved with an aggregate as all values", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+          makeFilter({
+            checkOn: CheckOn.DnsIsOnline,
+            filterType: FilterType.False,
+            evaluateOverTime: true,
+            evaluateOverTimeOptions: {
+              timeValueInMinutes: 5,
+              evaluateOverTimeType: EvaluateOverTimeType.Average,
+            },
+          }),
+        ),
+      ).toBe("over the last 5 minutes using all values");
+    });
   });
 });