@oneuptime/common 13.0.1 → 13.0.3

package/Tests/Server/Services/NetworkSiteTypeService.test.ts

@@ -468,88 +468,143 @@ describe("NetworkSiteTypeService update hierarchy validation", () => {
     }
   });
 
-  it("allows detaching a type when all existing sites of that type are roots", async () => {
+  /*
+   * Re-parenting a TYPE cannot invalidate the sites OF that type: their
+   * subtree moves with them. What it can do is push the moved type BELOW a
+   * type whose sites are already parented under it, and that inversion is the
+   * only thing refused here.
+   */
+  it("allows detaching a type whatever its sites' parents are", async () => {
     mockParentUpdate({});
-    jest
+    const siteFindSpy: jest.SpyInstance = jest
       .spyOn(NetworkSiteService, "findBy")
-      .mockResolvedValue([makeSite({ index: 1, typeIndex: 2 })]);
+      .mockResolvedValue([
+        makeSite({ index: 1, typeIndex: 2, parentIndex: 10 }),
+      ]);
 
     await expect(
       (NetworkSiteTypeService as any).onBeforeUpdate(
         updateBy({ parentNetworkSiteTypeId: null }),
       ),
     ).resolves.toBeDefined();
+
+    // Clearing a parent adds no ancestors, so no site is even read.
+    expect(siteFindSpy).not.toHaveBeenCalled();
   });
 
-  it("rejects detaching a type while one of its sites still has a parent", async () => {
-    mockParentUpdate({});
+  it("allows a new parent when no site of the gained ancestor types is affected", async () => {
+    mockParentUpdate({ parent: makeType({ index: 4 }) });
     jest
       .spyOn(NetworkSiteService, "findBy")
-      .mockResolvedValue([
-        makeSite({ index: 1, typeIndex: 2, parentIndex: 10 }),
-      ]);
+      .mockImplementation(async (findBy: any) => {
+        if (findBy.query?._id) {
+          return [makeSite({ index: 10, typeIndex: 4 })];
+        }
+
+        return [
+          makeSite({ index: 1, typeIndex: 2, parentIndex: 10 }),
+          makeSite({ index: 2, typeIndex: 2, parentIndex: 10 }),
+        ];
+      });
 
     await expect(
       (NetworkSiteTypeService as any).onBeforeUpdate(
-        updateBy({ parentNetworkSiteTypeId: null }),
+        updateBy({ parentNetworkSiteTypeId: typeId(4) }),
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  it("allows a new parent even when an existing site of the type is a root", async () => {
+    mockParentUpdate({ parent: makeType({ index: 4 }) });
+    jest
+      .spyOn(NetworkSiteService, "findBy")
+      .mockImplementation(async (findBy: any) => {
+        return findBy.query?._id ? [] : [makeSite({ index: 1, typeIndex: 2 })];
+      });
+
+    await expect(
+      (NetworkSiteTypeService as any).onBeforeUpdate(
+        updateBy({ parentNetworkSiteTypeId: typeId(4) }),
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  it("rejects a new parent that would put a site of the new ancestor type under this type", async () => {
+    mockParentUpdate({
+      parent: makeType({ index: 4 }),
+      projectTypes: [
+        makeType({ index: 2, parentIndex: 1 }),
+        makeType({ index: 4 }),
+      ],
+    });
+    jest
+      .spyOn(NetworkSiteService, "findBy")
+      .mockImplementation(async (findBy: any) => {
+        if (findBy.query?._id) {
+          return [makeSite({ index: 10, typeIndex: 2 })];
+        }
+
+        return [makeSite({ index: 1, typeIndex: 4, parentIndex: 10 })];
+      });
+
+    await expect(
+      (NetworkSiteTypeService as any).onBeforeUpdate(
+        updateBy({ parentNetworkSiteTypeId: typeId(4) }),
       ),
     ).rejects.toThrow(
-      "Create a new site type under the desired parent, then move and reassign the sites to it",
+      "an existing site is already placed under a site that the move would push below it",
     );
   });
 
-  it("accepts a new parent type when every site's actual parent has that type", async () => {
-    mockParentUpdate({ parent: makeType({ index: 4 }) });
+  it("rejects the same inversion reached through a descendant of the moving type", async () => {
+    mockParentUpdate({
+      parent: makeType({ index: 4 }),
+      projectTypes: [
+        makeType({ index: 2, parentIndex: 1 }),
+        makeType({ index: 3, parentIndex: 2 }),
+        makeType({ index: 4 }),
+      ],
+    });
     jest
       .spyOn(NetworkSiteService, "findBy")
       .mockImplementation(async (findBy: any) => {
         if (findBy.query?._id) {
-          return [makeSite({ index: 10, typeIndex: 4 })];
+          return [makeSite({ index: 10, typeIndex: 3 })];
         }
 
-        return [
-          makeSite({ index: 1, typeIndex: 2, parentIndex: 10 }),
-          makeSite({ index: 2, typeIndex: 2, parentIndex: 10 }),
-        ];
+        return [makeSite({ index: 1, typeIndex: 4, parentIndex: 10 })];
       });
 
     await expect(
       (NetworkSiteTypeService as any).onBeforeUpdate(
         updateBy({ parentNetworkSiteTypeId: typeId(4) }),
       ),
-    ).resolves.toBeDefined();
+    ).rejects.toThrow(
+      "an existing site is already placed under a site that the move would push below it",
+    );
   });
 
-  it("rejects a new parent when an existing site is root or its parent has another type", async () => {
-    const cases: Array<{
-      sites: Array<NetworkSite>;
-      parentSites: Array<NetworkSite>;
-    }> = [
-      {
-        sites: [makeSite({ index: 1, typeIndex: 2 })],
-        parentSites: [],
-      },
-      {
-        sites: [makeSite({ index: 1, typeIndex: 2, parentIndex: 10 })],
-        parentSites: [makeSite({ index: 10, typeIndex: 9 })],
-      },
-    ];
+  it("reads nothing when the new parent is already an ancestor of the old one", async () => {
+    mockParentUpdate({
+      moving: makeType({ index: 2, parentIndex: 4 }),
+      parent: makeType({ index: 1 }),
+      projectTypes: [
+        makeType({ index: 2, parentIndex: 4 }),
+        makeType({ index: 4, parentIndex: 1 }),
+        makeType({ index: 1 }),
+      ],
+    });
+    const siteFindSpy: jest.SpyInstance = jest
+      .spyOn(NetworkSiteService, "findBy")
+      .mockResolvedValue([]);
 
-    for (const testCase of cases) {
-      jest.restoreAllMocks();
-      mockParentUpdate({ parent: makeType({ index: 4 }) });
-      jest
-        .spyOn(NetworkSiteService, "findBy")
-        .mockImplementation(async (findBy: any) => {
-          return findBy.query?._id ? testCase.parentSites : testCase.sites;
-        });
+    await expect(
+      (NetworkSiteTypeService as any).onBeforeUpdate(
+        updateBy({ parentNetworkSiteTypeId: typeId(1) }),
+      ),
+    ).resolves.toBeDefined();
 
-      await expect(
-        (NetworkSiteTypeService as any).onBeforeUpdate(
-          updateBy({ parentNetworkSiteTypeId: typeId(4) }),
-        ),
-      ).rejects.toThrow("Create a new site type under the desired parent");
-    }
+    expect(siteFindSpy).not.toHaveBeenCalled();
   });
 
   it("does not revalidate sites or reorder when the parent did not change", async () => {
@@ -724,29 +779,41 @@ describe("NetworkSiteTypeService update hierarchy validation", () => {
     expect(siteFindSpy).not.toHaveBeenCalled();
   });
 
-  it("validates site parent consistency beyond the first 10,000 rows", async () => {
-    mockParentUpdate({});
-    const rootSite: NetworkSite = makeSite({ index: 1, typeIndex: 2 });
-    const mismatch: NetworkSite = makeSite({
+  it("validates site placement beyond the first 10,000 rows", async () => {
+    mockParentUpdate({
+      parent: makeType({ index: 4 }),
+      projectTypes: [
+        makeType({ index: 2, parentIndex: 1 }),
+        makeType({ index: 4 }),
+      ],
+    });
+    const harmlessSite: NetworkSite = makeSite({ index: 1, typeIndex: 4 });
+    const inverting: NetworkSite = makeSite({
       index: 2,
-      typeIndex: 2,
+      typeIndex: 4,
       parentIndex: 10,
     });
     jest
       .spyOn(NetworkSiteService, "findBy")
       .mockImplementation(async (findBy: any) => {
+        if (findBy.query?._id) {
+          return [makeSite({ index: 10, typeIndex: 2 })];
+        }
+
         if (findBy.skip === 0) {
-          return new Array<NetworkSite>(10_000).fill(rootSite);
+          return new Array<NetworkSite>(10_000).fill(harmlessSite);
         }
 
-        return [mismatch];
+        return [inverting];
       });
 
     await expect(
       (NetworkSiteTypeService as any).onBeforeUpdate(
-        updateBy({ parentNetworkSiteTypeId: null }),
+        updateBy({ parentNetworkSiteTypeId: typeId(4) }),
       ),
-    ).rejects.toThrow("Create a new site type under the desired parent");
+    ).rejects.toThrow(
+      "an existing site is already placed under a site that the move would push below it",
+    );
 
     expect(NetworkSiteService.findBy).toHaveBeenCalledWith(
       expect.objectContaining({ skip: 10_000 }),

package/Tests/Server/Services/ReminderRuleCriteria.test.ts

@@ -0,0 +1,173 @@
+import AlertReminderRule from "../../../Models/DatabaseModels/AlertReminderRule";
+import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
+import IncidentReminderRule from "../../../Models/DatabaseModels/IncidentReminderRule";
+import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
+import Label from "../../../Models/DatabaseModels/Label";
+import ScheduledMaintenanceReminderRule from "../../../Models/DatabaseModels/ScheduledMaintenanceReminderRule";
+import AlertReminderRuleService from "../../../Server/Services/AlertReminderRuleService";
+import IncidentReminderRuleService from "../../../Server/Services/IncidentReminderRuleService";
+import ScheduledMaintenanceReminderRuleService from "../../../Server/Services/ScheduledMaintenanceReminderRuleService";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import ObjectID from "../../../Types/ObjectID";
+import {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
+import { describe, expect, it } from "@jest/globals";
+
+const SEVERITY_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const LABEL_A_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const LABEL_B_ID: ObjectID = new ObjectID(
+  "33333333-3333-4333-8333-333333333333",
+);
+
+function label(id: ObjectID): Label {
+  const item: Label = new Label();
+  item.id = id;
+  return item;
+}
+
+describe("reminder rule configurable criteria", () => {
+  it("matches an alert when any one of severity or labels matches", () => {
+    const rule: AlertReminderRule = new AlertReminderRule();
+    rule.criteria = {
+      schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+      filterCondition: FilterCondition.Any,
+      filters: [
+        {
+          field: "alertSeverities",
+          operator: RuleCriteriaOperator.HasAnyOf,
+          value: ["44444444-4444-4444-8444-444444444444"],
+        },
+        {
+          field: "labels",
+          operator: RuleCriteriaOperator.HasAnyOf,
+          value: [LABEL_A_ID.toString()],
+        },
+      ],
+    };
+
+    expect(
+      AlertReminderRuleService.doesAlertMatchRule({
+        rule: rule,
+        alertSeverityId: SEVERITY_ID,
+        labelIds: [LABEL_A_ID],
+      }),
+    ).toBe(true);
+  });
+
+  it("requires every incident condition in Match all mode", () => {
+    const rule: IncidentReminderRule = new IncidentReminderRule();
+    rule.criteria = {
+      schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+      filterCondition: FilterCondition.All,
+      filters: [
+        {
+          field: "incidentSeverities",
+          operator: RuleCriteriaOperator.HasAnyOf,
+          value: [SEVERITY_ID.toString()],
+        },
+        {
+          field: "labels",
+          operator: RuleCriteriaOperator.HasAllOf,
+          value: [LABEL_A_ID.toString(), LABEL_B_ID.toString()],
+        },
+      ],
+    };
+
+    expect(
+      IncidentReminderRuleService.doesIncidentMatchRule({
+        rule: rule,
+        incidentSeverityId: SEVERITY_ID,
+        labelIds: [LABEL_A_ID, LABEL_B_ID],
+      }),
+    ).toBe(true);
+    expect(
+      IncidentReminderRuleService.doesIncidentMatchRule({
+        rule: rule,
+        incidentSeverityId: SEVERITY_ID,
+        labelIds: [LABEL_A_ID],
+      }),
+    ).toBe(false);
+  });
+
+  it("supports excluding labels from scheduled maintenance reminders", () => {
+    const rule: ScheduledMaintenanceReminderRule =
+      new ScheduledMaintenanceReminderRule();
+    rule.criteria = {
+      schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+      filterCondition: FilterCondition.All,
+      filters: [
+        {
+          field: "labels",
+          operator: RuleCriteriaOperator.HasNoneOf,
+          value: [LABEL_B_ID.toString()],
+        },
+      ],
+    };
+
+    expect(
+      ScheduledMaintenanceReminderRuleService.doesScheduledMaintenanceMatchRule(
+        { rule: rule, labelIds: [LABEL_A_ID] },
+      ),
+    ).toBe(true);
+    expect(
+      ScheduledMaintenanceReminderRuleService.doesScheduledMaintenanceMatchRule(
+        { rule: rule, labelIds: [LABEL_A_ID, LABEL_B_ID] },
+      ),
+    ).toBe(false);
+  });
+
+  it("ignores stale legacy fields after configurable criteria is saved", () => {
+    const rule: AlertReminderRule = new AlertReminderRule();
+    const staleSeverity: AlertSeverity = new AlertSeverity();
+    staleSeverity.id = new ObjectID("55555555-5555-4555-8555-555555555555");
+    rule.alertSeverities = [staleSeverity];
+    rule.criteria = {
+      schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+      filterCondition: FilterCondition.All,
+      filters: [
+        {
+          field: "labels",
+          operator: RuleCriteriaOperator.HasAnyOf,
+          value: [LABEL_A_ID.toString()],
+        },
+      ],
+    };
+
+    expect(
+      AlertReminderRuleService.doesAlertMatchRule({
+        rule: rule,
+        alertSeverityId: SEVERITY_ID,
+        labelIds: [LABEL_A_ID],
+      }),
+    ).toBe(true);
+  });
+
+  it("preserves legacy matching when criteria has not been configured", () => {
+    const rule: IncidentReminderRule = new IncidentReminderRule();
+    const severity: IncidentSeverity = new IncidentSeverity();
+    severity.id = SEVERITY_ID;
+    rule.incidentSeverities = [severity];
+    rule.labels = [label(LABEL_A_ID)];
+
+    expect(
+      IncidentReminderRuleService.doesIncidentMatchRule({
+        rule: rule,
+        incidentSeverityId: SEVERITY_ID,
+        labelIds: [LABEL_A_ID],
+      }),
+    ).toBe(true);
+    expect(
+      IncidentReminderRuleService.doesIncidentMatchRule({
+        rule: rule,
+        incidentSeverityId: SEVERITY_ID,
+        labelIds: [LABEL_B_ID],
+      }),
+    ).toBe(false);
+  });
+});

package/Tests/Server/Services/ResourceRuleCriteriaEngineServices.test.ts

@@ -0,0 +1,170 @@
+import Label from "../../../Models/DatabaseModels/Label";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorLabelRule from "../../../Models/DatabaseModels/MonitorLabelRule";
+import MonitorOwnerRule from "../../../Models/DatabaseModels/MonitorOwnerRule";
+import MonitorLabelRuleEngineService from "../../../Server/Services/MonitorLabelRuleEngineService";
+import MonitorOwnerRuleEngineService from "../../../Server/Services/MonitorOwnerRuleEngineService";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import ObjectID from "../../../Types/ObjectID";
+import RuleCriteria, {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
+import { describe, expect, it } from "@jest/globals";
+
+const PRODUCTION_LABEL_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const CUSTOMER_LABEL_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+
+interface MonitorRuleMatchFields {
+  criteria?: RuleCriteria | null | undefined;
+  monitorLabels?: Array<Label> | undefined;
+  monitorNamePattern?: string | undefined;
+  monitorDescriptionPattern?: string | undefined;
+}
+
+interface MonitorRuleMatcher<RuleType extends MonitorRuleMatchFields> {
+  doesMonitorMatchRule: (monitor: Monitor, rule: RuleType) => boolean;
+}
+
+function fakeLabel(id: ObjectID): Label {
+  return { id, _id: id.toString() } as unknown as Label;
+}
+
+function fakeMonitor(fields?: {
+  name?: string | undefined;
+  description?: string | undefined;
+  labels?: Array<ObjectID> | undefined;
+}): Monitor {
+  return {
+    name: fields?.name || "API Monitor",
+    description: fields?.description || "Production customer API",
+    labels: (fields?.labels || [PRODUCTION_LABEL_ID]).map(fakeLabel),
+  } as unknown as Monitor;
+}
+
+function criteria(
+  filterCondition: FilterCondition,
+  filters: RuleCriteria["filters"],
+): RuleCriteria {
+  return {
+    schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+    filterCondition,
+    filters,
+  };
+}
+
+const matchers: Array<{
+  name: string;
+  match: (monitor: Monitor, rule: MonitorRuleMatchFields) => boolean;
+}> = [
+  {
+    name: "monitor label rules",
+    match: (monitor: Monitor, rule: MonitorRuleMatchFields): boolean => {
+      const matcher: MonitorRuleMatcher<MonitorLabelRule> =
+        MonitorLabelRuleEngineService as unknown as MonitorRuleMatcher<MonitorLabelRule>;
+
+      return matcher.doesMonitorMatchRule(monitor, rule as MonitorLabelRule);
+    },
+  },
+  {
+    name: "monitor owner rules",
+    match: (monitor: Monitor, rule: MonitorRuleMatchFields): boolean => {
+      const matcher: MonitorRuleMatcher<MonitorOwnerRule> =
+        MonitorOwnerRuleEngineService as unknown as MonitorRuleMatcher<MonitorOwnerRule>;
+
+      return matcher.doesMonitorMatchRule(monitor, rule as MonitorOwnerRule);
+    },
+  },
+];
+
+describe.each(matchers)(
+  "$name configurable criteria",
+  ({
+    match,
+  }: {
+    match: (monitor: Monitor, rule: MonitorRuleMatchFields) => boolean;
+  }) => {
+    it("matches when any configured condition succeeds and ignores stale legacy fields", () => {
+      expect(
+        match(fakeMonitor(), {
+          monitorDescriptionPattern: "this stale criterion must be ignored",
+          criteria: criteria(FilterCondition.Any, [
+            {
+              field: "monitorNamePattern",
+              operator: RuleCriteriaOperator.StartsWith,
+              value: "worker",
+            },
+            {
+              field: "monitorLabels",
+              operator: RuleCriteriaOperator.HasAnyOf,
+              value: [PRODUCTION_LABEL_ID.toString()],
+            },
+          ]),
+        }),
+      ).toBe(true);
+    });
+
+    it("requires every configured condition when matching all", () => {
+      const rule: MonitorRuleMatchFields = {
+        criteria: criteria(FilterCondition.All, [
+          {
+            field: "monitorNamePattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "api",
+          },
+          {
+            field: "monitorLabels",
+            operator: RuleCriteriaOperator.HasAnyOf,
+            value: [PRODUCTION_LABEL_ID.toString()],
+          },
+        ]),
+      };
+
+      expect(match(fakeMonitor(), rule)).toBe(true);
+      expect(match(fakeMonitor({ name: "Background worker" }), rule)).toBe(
+        false,
+      );
+    });
+
+    it("supports requiring all selected labels", () => {
+      const rule: MonitorRuleMatchFields = {
+        criteria: criteria(FilterCondition.All, [
+          {
+            field: "monitorLabels",
+            operator: RuleCriteriaOperator.HasAllOf,
+            value: [
+              PRODUCTION_LABEL_ID.toString(),
+              CUSTOMER_LABEL_ID.toString(),
+            ],
+          },
+        ]),
+      };
+
+      expect(
+        match(
+          fakeMonitor({ labels: [PRODUCTION_LABEL_ID, CUSTOMER_LABEL_ID] }),
+          rule,
+        ),
+      ).toBe(true);
+      expect(match(fakeMonitor({ labels: [PRODUCTION_LABEL_ID] }), rule)).toBe(
+        false,
+      );
+    });
+
+    it("preserves the legacy all-fields matcher when criteria is absent", () => {
+      const rule: MonitorRuleMatchFields = {
+        monitorLabels: [fakeLabel(PRODUCTION_LABEL_ID)],
+        monitorNamePattern: "^api",
+        monitorDescriptionPattern: "customer",
+      };
+
+      expect(match(fakeMonitor(), rule)).toBe(true);
+      expect(match(fakeMonitor({ name: "Worker" }), rule)).toBe(false);
+      expect(match(fakeMonitor(), {})).toBe(true);
+    });
+  },
+);