@oneuptime/common 14.0.0 → 14.0.1

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

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "@jest/globals";
+import ServiceLevelObjectiveLabelRule from "../../../Models/DatabaseModels/ServiceLevelObjectiveLabelRule";
+import ServiceLevelObjectiveOwnerRule from "../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerRule";
+import ServiceLevelObjectiveLabelRuleService from "../../../Server/Services/ServiceLevelObjectiveLabelRuleService";
+import ServiceLevelObjectiveOwnerRuleService from "../../../Server/Services/ServiceLevelObjectiveOwnerRuleService";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The SLO label and owner rule services.
+ *
+ * A pattern that is neither a regex nor a '*' wildcard matches nothing, and the
+ * engine can only log that long after the user left the form - so the write is
+ * refused, on create AND on update, naming the field in the SLO's own words.
+ *
+ * And a rule is configuration: unlike the feed-style retention most rule
+ * services copy, it is never hard-deleted by age.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+
+type RuleService =
+  | typeof ServiceLevelObjectiveLabelRuleService
+  | typeof ServiceLevelObjectiveOwnerRuleService;
+
+interface ServiceCase {
+  name: string;
+  service: RuleService;
+  makeRule: () =>
+    | ServiceLevelObjectiveLabelRule
+    | ServiceLevelObjectiveOwnerRule;
+}
+
+const SERVICES: Array<ServiceCase> = [
+  {
+    name: "ServiceLevelObjectiveLabelRuleService",
+    service: ServiceLevelObjectiveLabelRuleService,
+    makeRule: () => {
+      return new ServiceLevelObjectiveLabelRule();
+    },
+  },
+  {
+    name: "ServiceLevelObjectiveOwnerRuleService",
+    service: ServiceLevelObjectiveOwnerRuleService,
+    makeRule: () => {
+      return new ServiceLevelObjectiveOwnerRule();
+    },
+  },
+];
+
+// Calls a protected hook without widening the service's public surface.
+function callHook(
+  service: unknown,
+  name: string,
+  ...args: Array<unknown>
+): Promise<unknown> {
+  const hooks: Record<
+    string,
+    (...hookArgs: Array<unknown>) => Promise<unknown>
+  > = service as Record<
+    string,
+    (...hookArgs: Array<unknown>) => Promise<unknown>
+  >;
+
+  return hooks[name]!.apply(service, args);
+}
+
+describe.each(SERVICES)("$name", (c: ServiceCase) => {
+  function create(fields: Record<string, unknown>): Promise<unknown> {
+    const rule:
+      | ServiceLevelObjectiveLabelRule
+      | ServiceLevelObjectiveOwnerRule = c.makeRule();
+    Object.assign(rule as unknown as Record<string, unknown>, {
+      projectId: PROJECT_ID,
+      name: "Checkout SLOs",
+      ...fields,
+    });
+
+    return callHook(c.service, "onBeforeCreate", {
+      data: rule,
+      props: { isRoot: true },
+    });
+  }
+
+  function update(data: Record<string, unknown>): Promise<unknown> {
+    return callHook(c.service, "onBeforeUpdate", {
+      query: { _id: ObjectID.generate().toString() },
+      data: data,
+      props: { isRoot: true },
+      limit: 1,
+      skip: 0,
+    });
+  }
+
+  describe("on create", () => {
+    it.each([
+      ["a regex", "^checkout-.*"],
+      ["a '*' wildcard", "*checkout*"],
+      ["a plain word", "checkout"],
+    ])(
+      "accepts %s as the SLO name pattern",
+      async (_: string, pattern: string) => {
+        await expect(
+          create({ serviceLevelObjectiveNamePattern: pattern }),
+        ).resolves.toEqual(expect.objectContaining({ carryForward: null }));
+      },
+    );
+
+    it("accepts a rule without patterns", async () => {
+      await expect(create({})).resolves.toBeDefined();
+    });
+
+    it("refuses a name pattern that can never match, naming the field", async () => {
+      await expect(
+        create({ serviceLevelObjectiveNamePattern: "checkout-(01" }),
+      ).rejects.toThrow(
+        new BadDataException(
+          `SLO Name Pattern "checkout-(01" is not a valid regular expression, and contains no '*' wildcard to fall back on, so it would never match an SLO. Use a regex such as checkout-.* or a wildcard such as *checkout*.`,
+        ),
+      );
+    });
+
+    it("refuses a description pattern that can never match, naming the field", async () => {
+      await expect(
+        create({ serviceLevelObjectiveDescriptionPattern: "[unclosed" }),
+      ).rejects.toThrow('SLO Description Pattern "[unclosed"');
+    });
+
+    it("hands the create through unchanged", async () => {
+      const result: { createBy: { data: Record<string, unknown> } } =
+        (await create({
+          serviceLevelObjectiveNamePattern: "*checkout*",
+        })) as { createBy: { data: Record<string, unknown> } };
+
+      expect(result.createBy.data["serviceLevelObjectiveNamePattern"]).toBe(
+        "*checkout*",
+      );
+    });
+  });
+
+  describe("on update", () => {
+    it("accepts a valid pattern", async () => {
+      await expect(
+        update({ serviceLevelObjectiveNamePattern: "*checkout*" }),
+      ).resolves.toEqual(expect.objectContaining({ carryForward: null }));
+    });
+
+    // Updating another column must not trip over the patterns it leaves alone.
+    it("accepts an update that does not touch the patterns", async () => {
+      await expect(update({ isEnabled: false })).resolves.toBeDefined();
+    });
+
+    it("refuses a name pattern that can never match", async () => {
+      await expect(
+        update({ serviceLevelObjectiveNamePattern: "api-(01" }),
+      ).rejects.toThrow('SLO Name Pattern "api-(01"');
+    });
+
+    it("refuses a description pattern that can never match", async () => {
+      await expect(
+        update({ serviceLevelObjectiveDescriptionPattern: "(" }),
+      ).rejects.toThrow("SLO Description Pattern");
+    });
+  });
+
+  it("never hard-deletes rules by age", () => {
+    expect(c.service.hardDeleteItemByColumnName).toBe("");
+    expect(c.service.hardDeleteItemsOlderThanDays).toBe(0);
+  });
+});

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

@@ -14,6 +14,7 @@ import logger from "../../../Server/Utils/Logger";
 import SloLegacyMonitorLabelAdoption from "../../../Server/Utils/Slo/SloLegacyMonitorLabelAdoption";
 import FilterCondition from "../../../Types/Filter/FilterCondition";
 import ObjectID from "../../../Types/ObjectID";
+import MonitorType from "../../../Types/Monitor/MonitorType";
 import RuleCriteria, {
   RULE_CRITERIA_LEGACY_NEVER_MATCH_PATTERN,
   RULE_CRITERIA_SCHEMA_VERSION,
@@ -93,6 +94,7 @@ function fakeMonitor(
     description?: string | undefined;
     labelIds?: Array<ObjectID> | undefined;
     projectId?: ObjectID | null | undefined;
+    monitorType?: MonitorType | undefined;
   },
 ): Monitor {
   return {
@@ -101,6 +103,7 @@ function fakeMonitor(
     projectId: fields?.projectId === undefined ? PROJECT_ID : fields.projectId,
     name: fields?.name === undefined ? `Monitor ${id.toString()}` : fields.name,
     description: fields?.description,
+    monitorType: fields?.monitorType,
     labels: (fields?.labelIds || []).map(fakeLabel),
   } as unknown as Monitor;
 }
@@ -134,6 +137,7 @@ function fakeRule(fields: {
   id?: ObjectID | undefined;
   serviceLevelObjectiveId?: ObjectID | undefined;
   labelIds?: Array<ObjectID> | undefined;
+  monitorType?: MonitorType | undefined;
   monitorNamePattern?: string | undefined;
   monitorDescriptionPattern?: string | undefined;
   criteria?: RuleCriteria | null | undefined;
@@ -148,6 +152,7 @@ function fakeRule(fields: {
     serviceLevelObjectiveId: fields.serviceLevelObjectiveId || SLO_ID,
     isEnabled: fields.isEnabled === undefined ? true : fields.isEnabled,
     monitorLabels: (fields.labelIds || []).map(fakeLabel),
+    monitorType: fields.monitorType,
     monitorNamePattern: fields.monitorNamePattern,
     monitorDescriptionPattern: fields.monitorDescriptionPattern,
     criteria: fields.criteria,
@@ -298,6 +303,66 @@ describe("ServiceLevelObjectiveMonitorRuleEngineService.syncMonitorsForSlo", ()
     jest.restoreAllMocks();
   });
 
+  it.each([false, true])(
+    "backfills matching monitor types and detaches stale rule attachments with criteria=%p",
+    async (configured: boolean) => {
+      spies.sloFindOneById.mockResolvedValue(
+        fakeSlo({
+          monitors: [MONITOR_B_ID, MONITOR_C_ID],
+          autoAddedMonitors: [MONITOR_B_ID],
+        }),
+      );
+      spies.ruleFindBy.mockResolvedValue([
+        fakeRule(
+          configured
+            ? {
+                criteria: criteria(FilterCondition.All, [
+                  {
+                    field: "monitorType",
+                    operator: RuleCriteriaOperator.Equals,
+                    value: MonitorType.API,
+                  },
+                ]),
+                monitorNamePattern: RULE_CRITERIA_LEGACY_NEVER_MATCH_PATTERN,
+              }
+            : { monitorType: MonitorType.API },
+        ),
+      ]);
+      spies.monitorFindBy.mockResolvedValue([
+        fakeMonitor(MONITOR_A_ID, { monitorType: MonitorType.API }),
+        fakeMonitor(MONITOR_B_ID, { monitorType: MonitorType.Website }),
+        fakeMonitor(MONITOR_C_ID, { monitorType: MonitorType.Ping }),
+      ]);
+
+      const result: SloMonitorSyncResult = await syncSlo();
+
+      expect(result).toEqual({
+        monitorIdsAdded: [MONITOR_A_ID.toString()],
+        monitorIdsRemoved: [MONITOR_B_ID.toString()],
+      });
+      expect(writtenIds(spies.sloUpdateOneById, "monitors")).toEqual(
+        sortedIds([MONITOR_A_ID, MONITOR_C_ID]),
+      );
+      expect(writtenIds(spies.sloUpdateOneById, "autoAddedMonitors")).toEqual([
+        MONITOR_A_ID.toString(),
+      ]);
+      expect(spies.monitorFindBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: { projectId: PROJECT_ID },
+          select: expect.objectContaining({ monitorType: true }),
+        }),
+      );
+      expect(spies.ruleFindBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: expect.objectContaining({
+            monitorType: true,
+            criteria: true,
+          }),
+        }),
+      );
+    },
+  );
+
   it("attaches every monitor an enabled rule's labels match", async () => {
     spies.ruleFindBy.mockResolvedValue([
       fakeRule({ labelIds: [LABEL_PRODUCTION_ID] }),
@@ -536,6 +601,7 @@ describe("ServiceLevelObjectiveMonitorRuleEngineService.syncMonitorsForSlo", ()
       _id: true,
       name: true,
       description: true,
+      monitorType: true,
       labels: { _id: true },
     });
     expect(call.props).toEqual({ isRoot: true });
@@ -998,6 +1064,51 @@ describe("ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor", ()
     );
   }
 
+  it.each([MonitorType.API, MonitorType.Website])(
+    "reconciles monitor-side membership when the monitor type becomes %s",
+    async (monitorType: MonitorType) => {
+      const shouldMatch: boolean = monitorType === MonitorType.API;
+      spies.monitorFindOneById.mockResolvedValue(
+        fakeMonitor(MONITOR_A_ID, { monitorType }),
+      );
+      spies.ruleFindBy.mockResolvedValue([
+        fakeRule({
+          criteria: criteria(FilterCondition.All, [
+            {
+              field: "monitorType",
+              operator: RuleCriteriaOperator.Equals,
+              value: MonitorType.API,
+            },
+          ]),
+        }),
+      ]);
+      spies.sloFindBy.mockImplementation(
+        answerSloReads({
+          byId: [
+            fakeSlo({
+              monitors: shouldMatch ? [] : [MONITOR_A_ID],
+              autoAddedMonitors: shouldMatch ? [] : [MONITOR_A_ID],
+            }),
+          ],
+        }) as never,
+      );
+
+      const results: Array<SloMonitorSyncResult> = await syncMonitor();
+
+      expect(results).toEqual([
+        {
+          monitorIdsAdded: shouldMatch ? [MONITOR_A_ID.toString()] : [],
+          monitorIdsRemoved: shouldMatch ? [] : [MONITOR_A_ID.toString()],
+        },
+      ]);
+      expect(spies.monitorFindOneById).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: expect.objectContaining({ monitorType: true }),
+        }),
+      );
+    },
+  );
+
   it("attaches the monitor to an SLO whose enabled rule its labels satisfy", async () => {
     spies.ruleFindBy.mockResolvedValue([
       fakeRule({ labelIds: [LABEL_PRODUCTION_ID] }),
@@ -1320,6 +1431,7 @@ describe("ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor", ()
       projectId: true,
       name: true,
       description: true,
+      monitorType: true,
       labels: { _id: true },
     });
   });
@@ -1793,3 +1905,214 @@ describe("ServiceLevelObjectiveMonitorRuleEngineService.doesMonitorMatchRule", (
     });
   }
 });
+
+describe("SLO monitor type matching", () => {
+  function matches(
+    filters: Array<RuleCriteriaFilter>,
+    monitorType: MonitorType | undefined,
+    condition: FilterCondition = FilterCondition.All,
+  ): boolean {
+    return ServiceLevelObjectiveMonitorRuleEngineService.doesMonitorMatchRule({
+      monitor: fakeMonitor(MONITOR_A_ID, {
+        monitorType,
+        name: "api-production",
+        description: "primary",
+        labelIds: [LABEL_PRODUCTION_ID],
+      }),
+      rule: fakeRule({
+        criteria: criteria(condition, filters),
+        monitorNamePattern: RULE_CRITERIA_LEGACY_NEVER_MATCH_PATTERN,
+      }),
+    });
+  }
+
+  it.each(Object.values(MonitorType))(
+    "matches exact enum type %s",
+    (monitorType: MonitorType) => {
+      expect(
+        matches(
+          [
+            {
+              field: "monitorType",
+              operator: RuleCriteriaOperator.Equals,
+              value: monitorType,
+            },
+          ],
+          monitorType,
+        ),
+      ).toBe(true);
+      expect(
+        matches(
+          [
+            {
+              field: "monitorType",
+              operator: RuleCriteriaOperator.NotEquals,
+              value: monitorType,
+            },
+          ],
+          monitorType,
+        ),
+      ).toBe(false);
+    },
+  );
+
+  it("distinguishes Docker from Docker Swarm with both equality operators", () => {
+    expect(
+      matches(
+        [
+          {
+            field: "monitorType",
+            operator: RuleCriteriaOperator.Equals,
+            value: MonitorType.Docker,
+          },
+        ],
+        MonitorType.DockerSwarm,
+      ),
+    ).toBe(false);
+    expect(
+      matches(
+        [
+          {
+            field: "monitorType",
+            operator: RuleCriteriaOperator.NotEquals,
+            value: MonitorType.Docker,
+          },
+        ],
+        MonitorType.DockerSwarm,
+      ),
+    ).toBe(true);
+  });
+
+  it.each([undefined, "Unknown" as MonitorType])(
+    "does not match missing or invalid monitor types (%s), including negation",
+    (monitorType: MonitorType | undefined) => {
+      expect(
+        matches(
+          [
+            {
+              field: "monitorType",
+              operator: RuleCriteriaOperator.Equals,
+              value: MonitorType.API,
+            },
+          ],
+          monitorType,
+        ),
+      ).toBe(false);
+      expect(
+        matches(
+          [
+            {
+              field: "monitorType",
+              operator: RuleCriteriaOperator.NotEquals,
+              value: MonitorType.API,
+            },
+          ],
+          monitorType,
+        ),
+      ).toBe(false);
+    },
+  );
+
+  it.each([
+    { operator: RuleCriteriaOperator.Equals, value: "Unknown" },
+    { operator: RuleCriteriaOperator.NotEquals, value: "api" },
+    { operator: RuleCriteriaOperator.NotEquals, value: true },
+    { operator: RuleCriteriaOperator.Contains, value: MonitorType.API },
+    { operator: RuleCriteriaOperator.DoesNotMatchPattern, value: ".*" },
+    { operator: RuleCriteriaOperator.HasNoneOf, value: [MonitorType.API] },
+  ])(
+    "fails the entire rule for invalid type predicate %p even under Match any",
+    (filter: Omit<RuleCriteriaFilter, "field">) => {
+      expect(
+        matches(
+          [
+            { field: "monitorType", ...filter },
+            {
+              field: "monitorNamePattern",
+              operator: RuleCriteriaOperator.Contains,
+              value: "api",
+            },
+          ],
+          MonitorType.API,
+          FilterCondition.Any,
+        ),
+      ).toBe(false);
+    },
+  );
+
+  it("combines types with name, description, and label conditions", () => {
+    const filters: Array<RuleCriteriaFilter> = [
+      {
+        field: "monitorType",
+        operator: RuleCriteriaOperator.Equals,
+        value: MonitorType.API,
+      },
+      {
+        field: "monitorNamePattern",
+        operator: RuleCriteriaOperator.MatchesPattern,
+        value: "api-*",
+      },
+      {
+        field: "monitorDescriptionPattern",
+        operator: RuleCriteriaOperator.DoesNotMatchPattern,
+        value: "standby*",
+      },
+      {
+        field: "monitorLabels",
+        operator: RuleCriteriaOperator.HasAnyOf,
+        value: [LABEL_PRODUCTION_ID.toString()],
+      },
+    ];
+    expect(matches(filters, MonitorType.API)).toBe(true);
+    expect(matches(filters, MonitorType.Website)).toBe(false);
+    expect(matches(filters, MonitorType.Website, FilterCondition.Any)).toBe(
+      true,
+    );
+  });
+
+  it("supports several type alternatives", () => {
+    const filters: Array<RuleCriteriaFilter> = [
+      MonitorType.API,
+      MonitorType.Website,
+    ].map((monitorType: MonitorType): RuleCriteriaFilter => {
+      return {
+        field: "monitorType",
+        operator: RuleCriteriaOperator.Equals,
+        value: monitorType,
+      };
+    });
+    expect(matches(filters, MonitorType.Website, FilterCondition.Any)).toBe(
+      true,
+    );
+    expect(matches(filters, MonitorType.Ping, FilterCondition.Any)).toBe(false);
+    expect(matches(filters, MonitorType.API)).toBe(false);
+  });
+
+  it("ANDs a legacy type with legacy name and labels", () => {
+    const rule: ServiceLevelObjectiveMonitorRule = fakeRule({
+      monitorType: MonitorType.Docker,
+      monitorNamePattern: "api-*",
+      labelIds: [LABEL_PRODUCTION_ID],
+    });
+    expect(
+      ServiceLevelObjectiveMonitorRuleEngineService.doesMonitorMatchRule({
+        rule,
+        monitor: fakeMonitor(MONITOR_A_ID, {
+          monitorType: MonitorType.Docker,
+          name: "api-prod",
+          labelIds: [LABEL_PRODUCTION_ID],
+        }),
+      }),
+    ).toBe(true);
+    expect(
+      ServiceLevelObjectiveMonitorRuleEngineService.doesMonitorMatchRule({
+        rule,
+        monitor: fakeMonitor(MONITOR_A_ID, {
+          monitorType: MonitorType.DockerSwarm,
+          name: "api-prod",
+          labelIds: [LABEL_PRODUCTION_ID],
+        }),
+      }),
+    ).toBe(false);
+  });
+});

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

@@ -21,6 +21,7 @@ import LIMIT_MAX from "../../../Types/Database/LimitMax";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import FilterCondition from "../../../Types/Filter/FilterCondition";
 import ObjectID from "../../../Types/ObjectID";
+import MonitorType from "../../../Types/Monitor/MonitorType";
 import RuleCriteria, {
   RULE_CRITERIA_SCHEMA_VERSION,
   RuleCriteriaOperator,
@@ -101,6 +102,7 @@ function makeRule(fields: {
   description?: string | undefined;
   isEnabled?: boolean | undefined;
   labelIds?: Array<ObjectID> | undefined;
+  monitorType?: MonitorType | undefined;
   monitorNamePattern?: string | undefined;
   monitorDescriptionPattern?: string | undefined;
   criteria?: RuleCriteria | null | undefined;
@@ -119,6 +121,7 @@ function makeRule(fields: {
     monitorLabels: (fields.labelIds || []).map((labelId: ObjectID) => {
       return { id: labelId, _id: labelId.toString() } as unknown as Label;
     }),
+    monitorType: fields.monitorType,
     monitorNamePattern: fields.monitorNamePattern,
     monitorDescriptionPattern: fields.monitorDescriptionPattern,
     criteria: fields.criteria,
@@ -247,6 +250,72 @@ describe("ServiceLevelObjectiveMonitorRuleService.onBeforeCreate", () => {
     jest.restoreAllMocks();
   });
 
+  it.each([true, false])(
+    "accepts a monitor-type-only rule with configured criteria=%p",
+    async (configured: boolean) => {
+      await expect(
+        callHook(
+          "onBeforeCreate",
+          makeCreateBy({
+            projectId: PROJECT_ID,
+            serviceLevelObjectiveId: SLO_ID,
+            ...(configured
+              ? {
+                  criteria: criteria(FilterCondition.All, [
+                    {
+                      field: "monitorType",
+                      operator: RuleCriteriaOperator.Equals,
+                      value: MonitorType.API,
+                    },
+                  ]),
+                }
+              : { monitorType: MonitorType.API }),
+          }),
+        ),
+      ).resolves.toBeDefined();
+    },
+  );
+
+  it.each([
+    { monitorType: "Unknown" },
+    {
+      criteria: criteria(FilterCondition.All, [
+        {
+          field: "monitorType",
+          operator: RuleCriteriaOperator.NotEquals,
+          value: "Unknown",
+        },
+      ]),
+    },
+    {
+      criteria: criteria(FilterCondition.All, [
+        {
+          field: "monitorType",
+          operator: RuleCriteriaOperator.Contains,
+          value: MonitorType.API,
+        },
+      ]),
+    },
+  ])(
+    "rejects invalid monitor type conditions before checking or adopting an SLO: %p",
+    async (fields: Record<string, unknown>) => {
+      await expect(
+        callHook(
+          "onBeforeCreate",
+          makeCreateBy({
+            projectId: PROJECT_ID,
+            serviceLevelObjectiveId: SLO_ID,
+            ...fields,
+          }),
+        ),
+      ).rejects.toThrow("Monitor type criteria");
+      expect(spies.referenceValidator).not.toHaveBeenCalled();
+      expect(
+        SloLegacyMonitorLabelAdoption.adoptLegacyMonitorLabels,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
   it("refuses a rule that names no SLO", async () => {
     const promise: Promise<unknown> = callHook(
       "onBeforeCreate",
@@ -627,6 +696,52 @@ describe("ServiceLevelObjectiveMonitorRuleService.onBeforeUpdate", () => {
     jest.restoreAllMocks();
   });
 
+  it("keeps a legacy type condition when clearing a different condition", async () => {
+    spies.ruleFindBy.mockResolvedValue([
+      makeRule({ monitorType: MonitorType.API, monitorNamePattern: "api-*" }),
+    ]);
+    await expect(
+      callHook("onBeforeUpdate", makeUpdateBy({ monitorNamePattern: null })),
+    ).resolves.toBeDefined();
+    expect(spies.ruleFindBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        select: expect.objectContaining({ monitorType: true }),
+      }),
+    );
+  });
+
+  it("rejects removing the only legacy type condition", async () => {
+    spies.ruleFindBy.mockResolvedValue([
+      makeRule({ monitorType: MonitorType.API }),
+    ]);
+    await expect(
+      callHook("onBeforeUpdate", makeUpdateBy({ monitorType: null })),
+    ).rejects.toThrow("at least one match criterion");
+  });
+
+  it("validates a changed legacy monitor type and configured monitor type", async () => {
+    spies.ruleFindBy.mockResolvedValue([
+      makeRule({ monitorType: MonitorType.API }),
+    ]);
+    await expect(
+      callHook("onBeforeUpdate", makeUpdateBy({ monitorType: "Unknown" })),
+    ).rejects.toThrow("valid monitor type");
+    await expect(
+      callHook(
+        "onBeforeUpdate",
+        makeUpdateBy({
+          criteria: criteria(FilterCondition.All, [
+            {
+              field: "monitorType",
+              operator: RuleCriteriaOperator.DoesNotMatchPattern,
+              value: MonitorType.API,
+            },
+          ]),
+        }),
+      ),
+    ).rejects.toThrow("only support Equals");
+  });
+
   it("refuses a pattern the engine could never match, before reading anything", async () => {
     await expect(
       callHook(