@oneuptime/common 13.0.6 → 13.0.7

package/Tests/Server/Utils/Database/PostgresErrorTranslator.test.ts

@@ -307,6 +307,69 @@ describe("PostgresErrorTranslator", () => {
     });
   });
 
+  describe("createUniqueViolationException (issue #3394)", () => {
+    /*
+     * @UniqueColumnsTogether refuses a duplicate owner row before the insert.
+     * The callers that add owners in bulk must treat that refusal exactly like
+     * the unique index rejecting a racing insert, through one predicate.
+     */
+    it("is a BadDataException carrying the given message", () => {
+      const exception: BadDataException =
+        PostgresErrorTranslator.createUniqueViolationException(
+          "This team is already an owner of this incident.",
+        );
+
+      expect(exception).toBeInstanceOf(BadDataException);
+      expect(exception.message).toBe(
+        "This team is already an owner of this incident.",
+      );
+    });
+
+    it("is recognised by isUniqueViolation", () => {
+      expect(
+        PostgresErrorTranslator.isUniqueViolation(
+          PostgresErrorTranslator.createUniqueViolationException("Duplicate."),
+        ),
+      ).toBe(true);
+    });
+
+    it("is tagged with the unique-violation SQLSTATE, like a translated one", () => {
+      const exception: TranslatedPostgresException =
+        PostgresErrorTranslator.createUniqueViolationException(
+          "Duplicate.",
+        ) as TranslatedPostgresException;
+      const translated: TranslatedPostgresException =
+        PostgresErrorTranslator.translate(
+          twilioAccountSidCollision(),
+        ) as TranslatedPostgresException;
+
+      expect(exception.postgresErrorCode).toBe("23505");
+      expect(exception.postgresErrorCode).toBe(translated.postgresErrorCode);
+    });
+
+    it("keeps the same HTTP-facing code as any other BadDataException", () => {
+      expect(
+        PostgresErrorTranslator.createUniqueViolationException("Duplicate.")
+          .code,
+      ).toBe(new BadDataException("Duplicate.").code);
+    });
+
+    it("passes through translate() unchanged", () => {
+      const exception: BadDataException =
+        PostgresErrorTranslator.createUniqueViolationException("Duplicate.");
+
+      expect(PostgresErrorTranslator.translate(exception)).toBe(exception);
+    });
+
+    it("returns a new exception on every call", () => {
+      expect(
+        PostgresErrorTranslator.createUniqueViolationException("Duplicate."),
+      ).not.toBe(
+        PostgresErrorTranslator.createUniqueViolationException("Duplicate."),
+      );
+    });
+  });
+
   describe("errors it should not touch", () => {
     it("passes through an unrecognised Postgres error unchanged", () => {
       const notNullViolation: FakeQueryFailedError = {

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

@@ -171,10 +171,9 @@ describe("APIRequestCriteria evaluate over time", () => {
         dataToProcess: buildResponse({ responseCode: 404 }),
       });
 
-      expect(result).toContain("All values of");
-      expect(result).toContain(CheckOn.ResponseStatusCode as string);
-      expect(result).toContain("over the last 5 minutes");
-      expect(result).toContain("not equal to 200");
+      expect(result).toBe(
+        `${CheckOn.ResponseStatusCode} over the last 5 minutes was 404 in all 5 readings, different from the 200 threshold.`,
+      );
     });
 
     /*
@@ -229,8 +228,9 @@ describe("APIRequestCriteria evaluate over time", () => {
         dataToProcess: buildResponse({ responseTimeInMs: 8800 }),
       });
 
-      expect(result).toContain("All values of");
-      expect(result).toContain("greater than 8000");
+      expect(result).toBe(
+        `${CheckOn.ResponseTime} over the last 2 minutes ranged from 8800 to 9171 across all 3 readings, above the 8000 threshold.`,
+      );
     });
 
     /*
@@ -251,7 +251,9 @@ describe("APIRequestCriteria evaluate over time", () => {
         dataToProcess: buildResponse({ responseTimeInMs: 9171 }),
       });
 
-      expect(result).toContain("Any value of");
+      expect(result).toBe(
+        `${CheckOn.ResponseTime} over the last 2 minutes was 9171 in 1 of 3 readings, above the 8000 threshold.`,
+      );
     });
 
     test("Any Value fires off the very first sample", async () => {
@@ -371,7 +373,7 @@ describe("APIRequestCriteria evaluate over time", () => {
       });
 
       // 0 is not equal to 200, so the filter is met.
-      expect(result).toContain("not equal to 200");
+      expect(result).toContain("different from the 200 threshold");
     });
   });
 
@@ -456,7 +458,7 @@ describe("APIRequestCriteria evaluate over time", () => {
         dataToProcess: buildResponse({ responseCode: 404 }),
       });
 
-      expect(result).toContain("not equal to 200");
+      expect(result).toContain("different from the 200 threshold");
     });
 
     test("the metric store is never read for them", async () => {

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

@@ -580,7 +580,7 @@ describe("CompareCriteria", () => {
           threshold: 50,
           criteriaFilter: filter,
         }),
-      ).toBe("Response Time (in ms) is 100 which is greater than 50.");
+      ).toBe("Response Time (in ms) was 100, above the 50 threshold.");
     });
 
     test("does not fire when the threshold is not breached", () => {
@@ -677,7 +677,7 @@ describe("CompareCriteria", () => {
   });
 
   describe("getCompareMessage formatting", () => {
-    test("prefixes 'Any value of' / 'All values of' for over-time evaluation", () => {
+    test("summarizes the readings when AnyValue and AllValues both match the whole window", () => {
       const anyFilter: CriteriaFilter = makeFilter({
         checkOn: CheckOn.ResponseTime,
         filterType: FilterType.GreaterThan,
@@ -693,7 +693,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: anyFilter,
         }),
       ).toBe(
-        "Any value of Response Time (in ms) is 10, 20 which is greater than 5.",
+        "Response Time (in ms) ranged from 10 to 20 across all 2 readings, above the 5 threshold.",
       );
 
       const allFilter: CriteriaFilter = makeFilter({
@@ -711,7 +711,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: allFilter,
         }),
       ).toBe(
-        "All values of Response Time (in ms) is 10, 20 which is greater than 5.",
+        "Response Time (in ms) ranged from 10 to 20 across all 2 readings, above the 5 threshold.",
       );
     });
 
@@ -727,7 +727,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: filter,
         }),
       ).toBe(
-        "Response Time (in ms) is 6 samples between 1 and 6 which is greater than 0.",
+        "Response Time (in ms) ranged from 1 to 6 across all 6 readings, above the 0 threshold.",
       );
     });
 
@@ -756,7 +756,7 @@ describe("CompareCriteria", () => {
           threshold: 1.9999,
           criteriaFilter: filter,
         }),
-      ).toBe("Response Time (in ms) is 12.35 which is greater than 2.");
+      ).toBe("Response Time (in ms) was 12.35, above the 2 threshold.");
     });
 
     test("appends a unit suffix to both the value and the threshold", () => {
@@ -771,7 +771,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: filter,
           unit: "ms",
         }),
-      ).toBe("Metric Value is 100 ms which is greater than 50 ms.");
+      ).toBe("Metric Value was 100 ms, above the 50 ms threshold.");
     });
 
     /*
@@ -798,7 +798,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: filter,
           unit: "By",
         }),
-      ).toBe("Metric Value is 1.07 GB which is greater than 1 GB.");
+      ).toBe("Metric Value was 1.07 GB, above the 1 GB threshold.");
     });
 
     test("rescales a duration", () => {
@@ -813,10 +813,10 @@ describe("CompareCriteria", () => {
           criteriaFilter: filter,
           unit: "ms",
         }),
-      ).toBe("Metric Value is 1.5 sec which is greater than 1 sec.");
+      ).toBe("Metric Value was 1.5 sec, above the 1 sec threshold.");
     });
 
-    test("gives every listed sample its own scale", () => {
+    test("gives each end of a range its own scale", () => {
       const filter: CriteriaFilter = makeFilter({
         checkOn: CheckOn.MetricValue,
         filterType: FilterType.GreaterThan,
@@ -834,11 +834,11 @@ describe("CompareCriteria", () => {
           unit: "By",
         }),
       ).toBe(
-        "All values of Metric Value over the last 5 minutes is 922 KB, 1.26 MB which is greater than 900 KB.",
+        "Metric Value over the last 5 minutes ranged from 922 KB to 1.26 MB across all 2 readings, above the 900 KB threshold.",
       );
     });
 
-    test("units ride both ends of the 'N samples between X and Y' summary", () => {
+    test("units ride both ends of a range summary", () => {
       const filter: CriteriaFilter = makeFilter({
         checkOn: CheckOn.MetricValue,
         filterType: FilterType.GreaterThan,
@@ -854,8 +854,10 @@ describe("CompareCriteria", () => {
         unit: "By",
       });
 
-      expect(message).toContain("6 samples between 1 GB and 6 GB");
-      expect(message).toContain("greater than 500 MB");
+      expect(message).toContain(
+        "ranged from 1 GB to 6 GB across all 6 readings",
+      );
+      expect(message).toContain("above the 500 MB threshold");
     });
 
     /*
@@ -877,7 +879,7 @@ describe("CompareCriteria", () => {
       });
 
       expect(message).toBe(
-        "browser.cumulative_layout_shift is 0.31 which is greater than or equal to 0.25.",
+        "browser.cumulative_layout_shift was 0.31, at or above the 0.25 threshold.",
       );
       expect(message).not.toContain("0.31 1");
     });
@@ -897,7 +899,7 @@ describe("CompareCriteria", () => {
       });
 
       expect(message).toBe(
-        "system.cpu.utilization is 5.85% which is greater than 5.00%.",
+        "system.cpu.utilization was 5.85%, above the 5.00% threshold.",
       );
     });
 
@@ -913,7 +915,7 @@ describe("CompareCriteria", () => {
         unit: "{thread}",
       });
 
-      expect(message).toBe("Metric Value is 512 which is greater than 500.");
+      expect(message).toBe("Metric Value was 512, above the 500 threshold.");
       expect(message).not.toContain("{thread}");
     });
 
@@ -938,7 +940,7 @@ describe("CompareCriteria", () => {
         unit: "1",
       });
 
-      expect(message).toBe("a / b_ratio is 0.42 which is greater than 0.4.");
+      expect(message).toBe("a / b_ratio was 0.42, above the 0.4 threshold.");
       expect(message).not.toContain("42.00%");
     });
 
@@ -946,16 +948,16 @@ describe("CompareCriteria", () => {
      * BACKWARD COMPATIBILITY. Only MetricMonitorCriteria and
      * DatabaseMonitorCriteria pass a unit; every other monitor type
      * carries its unit inside the CheckOn label ("Response Time (in ms)")
-     * and must keep byte-identical, unabbreviated output.
+     * and must keep its numbers unabbreviated.
      */
-    test("a message with no unit is unchanged, digits and all", () => {
+    test("a message with no unit preserves its original numeric scale", () => {
       const filter: CriteriaFilter = makeFilter({
         checkOn: CheckOn.ResponseTime,
         filterType: FilterType.GreaterThan,
       });
 
       const expected: string =
-        "Response Time (in ms) is 5000 which is greater than 4900.";
+        "Response Time (in ms) was 5000, above the 4900 threshold.";
 
       expect(
         CompareCriteria.getCompareMessage({
@@ -1028,7 +1030,7 @@ describe("CompareCriteria", () => {
           threshold: 80,
           criteriaFilter: withPath,
         }),
-      ).toBe("Disk Usage (in %) on disk /var is 95 which is greater than 80.");
+      ).toBe("Disk Usage (in %) on disk /var was 95, above the 80 threshold.");
 
       const withoutPath: CriteriaFilter = makeFilter({
         checkOn: CheckOn.DiskUsagePercent,
@@ -1074,7 +1076,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: metricFilter,
           metricDisplayName: "http.server.duration",
         }),
-      ).toBe("http.server.duration is 100 which is greater than 50.");
+      ).toBe("http.server.duration was 100, above the 50 threshold.");
 
       // For a non-MetricValue check the display name is ignored.
       const responseFilter: CriteriaFilter = makeFilter({
@@ -1088,7 +1090,7 @@ describe("CompareCriteria", () => {
           criteriaFilter: responseFilter,
           metricDisplayName: "http.server.duration",
         }),
-      ).toBe("Response Time (in ms) is 100 which is greater than 50.");
+      ).toBe("Response Time (in ms) was 100, above the 50 threshold.");
     });
 
     test("True/False messages omit the 'which is' clause", () => {
@@ -1105,35 +1107,50 @@ describe("CompareCriteria", () => {
       ).toBe("Is Online is true.");
     });
 
-    test("renders each comparison verb", () => {
-      const verbs: Array<{ filterType: FilterType; verb: string }> = [
-        { filterType: FilterType.GreaterThan, verb: "greater than" },
-        {
-          filterType: FilterType.GreaterThanOrEqualTo,
-          verb: "greater than or equal to",
-        },
-        { filterType: FilterType.LessThan, verb: "less than" },
-        {
-          filterType: FilterType.LessThanOrEqualTo,
-          verb: "less than or equal to",
-        },
-        { filterType: FilterType.EqualTo, verb: "equal to" },
-        { filterType: FilterType.NotEqualTo, verb: "not equal to" },
-      ];
-
-      for (const { filterType, verb } of verbs) {
+    test.each([
+      { filterType: FilterType.GreaterThan, value: 100, relation: "above" },
+      {
+        filterType: FilterType.GreaterThanOrEqualTo,
+        value: 50,
+        relation: "at or above",
+      },
+      { filterType: FilterType.LessThan, value: 25, relation: "below" },
+      {
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 50,
+        relation: "at or below",
+      },
+      { filterType: FilterType.EqualTo, value: 50, relation: "equal to" },
+      {
+        filterType: FilterType.NotEqualTo,
+        value: 100,
+        relation: "different from",
+      },
+    ])(
+      "renders $filterType as $relation",
+      ({
+        filterType,
+        value,
+        relation,
+      }: {
+        filterType: FilterType;
+        value: number;
+        relation: string;
+      }) => {
         const filter: CriteriaFilter = makeFilter({
           checkOn: CheckOn.ResponseTime,
           filterType,
         });
         expect(
           CompareCriteria.getCompareMessage({
-            values: 100,
+            values: value,
             threshold: 50,
             criteriaFilter: filter,
           }),
-        ).toContain(verb);
-      }
-    });
+        ).toBe(
+          `Response Time (in ms) was ${value}, ${relation} the 50 threshold.`,
+        );
+      },
+    );
   });
 });

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

@@ -295,7 +295,7 @@ describe("CompareCriteria aggregation semantics", () => {
        */
       expect(message).toContain("91.53");
       expect(message).toContain(
-        "1 of 5 samples in the evaluation window breached this threshold.",
+        "in 1 of 5 readings, above the 90.00% threshold.",
       );
     });
 
@@ -312,7 +312,7 @@ describe("CompareCriteria aggregation semantics", () => {
       });
 
       expect(message).toBe(
-        "Any value of CPU is 95.00%, 96.00%, 97.00% which is greater than 90.00%.",
+        "CPU ranged from 95.00% to 97.00% across all 3 readings, above the 90.00% threshold.",
       );
     });
 
@@ -328,11 +328,13 @@ describe("CompareCriteria aggregation semantics", () => {
         unit: "%",
       });
 
-      expect(message).toContain("80.00%, 70.00%");
+      expect(message).toContain(
+        "ranged from 70.00% to 80.00% across 2 of 3 readings",
+      );
       expect(message).not.toContain("95");
     });
 
-    test("AllValues is unaffected — every sample breached by definition", () => {
+    test("AllValues describes the range and the full reading count", () => {
       const message: string = CompareCriteria.getCompareMessage({
         values: [95, 96],
         threshold: 90,
@@ -345,7 +347,7 @@ describe("CompareCriteria aggregation semantics", () => {
       });
 
       expect(message).toBe(
-        "All values of CPU is 95.00%, 96.00% which is greater than 90.00%.",
+        "CPU ranged from 95.00% to 96.00% across all 2 readings, above the 90.00% threshold.",
       );
     });
 
@@ -361,7 +363,7 @@ describe("CompareCriteria aggregation semantics", () => {
         unit: "%",
       });
 
-      expect(message).toContain("The average of CPU is 20");
+      expect(message).toContain("The average of CPU was 20");
       expect(message).not.toContain("10, 20, 30");
     });
 
@@ -370,8 +372,8 @@ describe("CompareCriteria aggregation semantics", () => {
       [EvaluateOverTimeType.Sum, "The sum of"],
       [EvaluateOverTimeType.MaximumValue, "The maximum of"],
       [EvaluateOverTimeType.MunimumValue, "The minimum of"],
-      [EvaluateOverTimeType.AnyValue, "Any value of"],
-      [EvaluateOverTimeType.AllValues, "All values of"],
+      [EvaluateOverTimeType.AnyValue, "CPU was"],
+      [EvaluateOverTimeType.AllValues, "CPU was"],
     ])(
       "%s is named in the sentence as %s",
       (evaluationType: EvaluateOverTimeType, expectedPrefix: string) => {
@@ -389,8 +391,8 @@ describe("CompareCriteria aggregation semantics", () => {
 
     test("a message rendered for a filter that did not match degrades gracefully", () => {
       /*
-       * Nothing in the window is above 200; the whole window is quoted
-       * rather than an empty list.
+       * Nothing in the window is above 200. Report what was observed,
+       * then describe the unmet requirement without claiming a breach.
        */
       const message: string = CompareCriteria.getCompareMessage({
         values: WINDOW,
@@ -405,6 +407,9 @@ describe("CompareCriteria aggregation semantics", () => {
 
       expect(message).toContain("72.35");
       expect(message).not.toContain("samples in the evaluation window");
+      expect(message).toContain(
+        "The condition requires at least one reading to be above the 200.00% threshold.",
+      );
     });
 
     test("a non-numeric window is left alone", () => {
@@ -470,9 +475,7 @@ describe("CompareCriteria aggregation semantics", () => {
     test("the dimensionless '1' is dropped from the value AND the threshold", () => {
       const message: string = unitMessage("1");
 
-      expect(message).toBe(
-        "Any value of Metric Value is 0.85 which is greater than 0.8.",
-      );
+      expect(message).toBe("Metric Value was 0.85, above the 0.8 threshold.");
       // The two halves of the defect, pinned separately.
       expect(message).not.toContain("0.85 1");
       expect(message).not.toContain("0.8 1");
@@ -492,7 +495,7 @@ describe("CompareCriteria aggregation semantics", () => {
         unit: "1",
       });
 
-      expect(message).toContain("0.31 which is");
+      expect(message).toContain("0.31, at or above the 0.25 threshold");
       expect(message).not.toMatch(/\d\s1\b/);
     });
 
@@ -501,9 +504,7 @@ describe("CompareCriteria aggregation semantics", () => {
 
       expect(message).not.toContain("{cpu}");
       expect(message).not.toContain("{");
-      expect(message).toBe(
-        "Any value of Metric Value is 0.85 which is greater than 0.8.",
-      );
+      expect(message).toBe("Metric Value was 0.85, above the 0.8 threshold.");
 
       expect(unitMessage("{packets}")).not.toContain("{packets}");
       expect(unitMessage("{errors}")).not.toContain("{errors}");
@@ -521,13 +522,13 @@ describe("CompareCriteria aggregation semantics", () => {
        * value and the threshold can never be quoted in different units.
        */
       expect(unitMessage("By")).toBe(
-        "Any value of Metric Value is 0.85 B which is greater than 0.8 B.",
+        "Metric Value was 0.85 B, above the 0.8 B threshold.",
       );
       expect(unitMessage("%")).toBe(
-        "Any value of Metric Value is 0.85% which is greater than 0.80%.",
+        "Metric Value was 0.85%, above the 0.80% threshold.",
       );
       expect(unitMessage("ms")).toBe(
-        "Any value of Metric Value is 850 µs which is greater than 800 µs.",
+        "Metric Value was 850 µs, above the 800 µs threshold.",
       );
       // "1" is suppressed; a unit that merely CONTAINS a 1 is not.
       expect(unitMessage("m/s2")).toContain("0.85 m/s2");
@@ -538,17 +539,17 @@ describe("CompareCriteria aggregation semantics", () => {
       const message: string = unitMessage(" ms ");
 
       expect(message).toBe(
-        "Any value of Metric Value is 850 µs which is greater than 800 µs.",
+        "Metric Value was 850 µs, above the 800 µs threshold.",
       );
       expect(message).not.toContain("  ");
     });
 
     test("a whitespace-only unit is treated as no unit at all", () => {
       expect(unitMessage("   ")).toBe(
-        "Any value of Metric Value is 0.85 which is greater than 0.8.",
+        "Metric Value was 0.85, above the 0.8 threshold.",
       );
       expect(unitMessage(undefined)).toBe(
-        "Any value of Metric Value is 0.85 which is greater than 0.8.",
+        "Metric Value was 0.85, above the 0.8 threshold.",
       );
       // A padded "1" is still the dimensionless marker.
       expect(unitMessage(" 1 ")).not.toMatch(/\d\s1\b/);
@@ -583,7 +584,7 @@ describe("CompareCriteria aggregation semantics", () => {
 
         expect(message).not.toMatch(/\d\s1\b/);
         expect(message).toContain("0.85");
-        expect(message).toContain("0.8.");
+        expect(message).toMatch(/0\.8(?: threshold)?\./);
       }
     });
   });