@oneuptime/common 13.0.1 → 13.0.4

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

@@ -13,6 +13,12 @@ import BadDataException from "../../../Types/Exception/BadDataException";
 import ObjectID from "../../../Types/ObjectID";
 import CreateBy from "../../../Server/Types/Database/CreateBy";
 import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import RuleCriteria, {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
 import { describe, expect, it, afterEach } from "@jest/globals";
 
 /*
@@ -89,6 +95,17 @@ function fakeOwnerRule(data: Record<string, unknown>): NetworkDeviceOwnerRule {
   } as unknown as NetworkDeviceOwnerRule;
 }
 
+function criteria(
+  filterCondition: FilterCondition,
+  filters: Array<RuleCriteriaFilter>,
+): RuleCriteria {
+  return {
+    schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+    filterCondition: filterCondition,
+    filters: filters,
+  };
+}
+
 /*
  * The label engine attaches through the relation query builder rather than a
  * model write, so the assertion surface is the `.add(ids)` call at the end of
@@ -123,7 +140,7 @@ describe("NetworkDeviceLabelRuleEngineService - wildcard patterns", () => {
    * The reported bug, end to end: an enabled rule with the glob the user
    * typed, against the device the dashboard showed them.
    */
-  it("attaches labels for the *0664* pattern from issue #2940", async () => {
+  it("falls back to legacy label criteria when criteria is absent", async () => {
     jest
       .spyOn(NetworkDeviceLabelRuleService, "findBy")
       .mockResolvedValue([
@@ -303,10 +320,102 @@ describe("NetworkDeviceLabelRuleEngineService - rule selection and attach", () =
     const query: any = rulesSpy.mock.calls[0]![0].query;
     expect(query.isEnabled).toBe(true);
     expect(query.projectId.toString()).toBe(PROJECT_ID.toString());
+    expect(rulesSpy.mock.calls[0]![0].select.criteria).toBe(true);
     // No rules means no reason to re-read the device.
     expect(deviceSpy).not.toHaveBeenCalled();
   });
 
+  it("matches when any configured criterion matches and ignores stale legacy fields", async () => {
+    jest.spyOn(NetworkDeviceLabelRuleService, "findBy").mockResolvedValue([
+      fakeLabelRule({
+        criteria: criteria(FilterCondition.Any, [
+          {
+            field: "networkDeviceNamePattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "not-this-device",
+          },
+          {
+            field: "networkDeviceDescriptionPattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "IOS-XE",
+          },
+        ]),
+        networkDeviceNamePattern: "*stale-and-never-matches*",
+      }),
+    ]);
+    jest.spyOn(NetworkDeviceService, "findOneById").mockResolvedValue(
+      fakeDeviceDetails({
+        description: "Cisco IOS-XE Software",
+        labels: [],
+      }),
+    );
+    const addSpy: jest.Mock = mockLabelAttach();
+
+    await NetworkDeviceLabelRuleEngineService.applyRulesToNetworkDevice(
+      ruleTarget(),
+    );
+
+    expect(addSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("requires all configured criteria when Match All is selected", async () => {
+    jest.spyOn(NetworkDeviceLabelRuleService, "findBy").mockResolvedValue([
+      fakeLabelRule({
+        criteria: criteria(FilterCondition.All, [
+          {
+            field: "networkDeviceNamePattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "0664",
+          },
+          {
+            field: "networkDeviceDescriptionPattern",
+            operator: RuleCriteriaOperator.EndsWith,
+            value: "Switch",
+          },
+        ]),
+      }),
+    ]);
+    jest.spyOn(NetworkDeviceService, "findOneById").mockResolvedValue(
+      fakeDeviceDetails({
+        description: "Cisco Router",
+        labels: [],
+      }),
+    );
+    const addSpy: jest.Mock = mockLabelAttach();
+
+    await NetworkDeviceLabelRuleEngineService.applyRulesToNetworkDevice(
+      ruleTarget(),
+    );
+
+    expect(addSpy).not.toHaveBeenCalled();
+  });
+
+  it("supports Has All Of for label criteria", async () => {
+    jest.spyOn(NetworkDeviceLabelRuleService, "findBy").mockResolvedValue([
+      fakeLabelRule({
+        criteria: criteria(FilterCondition.All, [
+          {
+            field: "networkDeviceLabels",
+            operator: RuleCriteriaOperator.HasAllOf,
+            value: [PREREQUISITE_LABEL_ID.toString(), LABEL_B_ID.toString()],
+          },
+        ]),
+      }),
+    ]);
+    jest.spyOn(NetworkDeviceService, "findOneById").mockResolvedValue(
+      fakeDeviceDetails({
+        labels: [fakeLabel(PREREQUISITE_LABEL_ID), fakeLabel(LABEL_B_ID)],
+      }),
+    );
+    const addSpy: jest.Mock = mockLabelAttach();
+
+    await NetworkDeviceLabelRuleEngineService.applyRulesToNetworkDevice(
+      ruleTarget(),
+    );
+
+    expect(addSpy).toHaveBeenCalledTimes(1);
+  });
+
   it("unions the labels of every matching rule", async () => {
     jest.spyOn(NetworkDeviceLabelRuleService, "findBy").mockResolvedValue([
       fakeLabelRule({
@@ -494,7 +603,7 @@ describe("NetworkDeviceOwnerRuleEngineService - wildcard patterns", () => {
     jest.restoreAllMocks();
   });
 
-  it("adds owners for a *0664* pattern", async () => {
+  it("falls back to legacy owner criteria when criteria is absent", async () => {
     jest
       .spyOn(NetworkDeviceOwnerRuleService, "findBy")
       .mockResolvedValue([
@@ -517,6 +626,74 @@ describe("NetworkDeviceOwnerRuleEngineService - wildcard patterns", () => {
     );
   });
 
+  it("uses Match Any owner criteria instead of stale legacy fields", async () => {
+    jest.spyOn(NetworkDeviceOwnerRuleService, "findBy").mockResolvedValue([
+      fakeOwnerRule({
+        criteria: criteria(FilterCondition.Any, [
+          {
+            field: "networkDeviceNamePattern",
+            operator: RuleCriteriaOperator.Equals,
+            value: "not-this-device",
+          },
+          {
+            field: "networkDeviceDescriptionPattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "Catalyst",
+          },
+        ]),
+        networkDeviceNamePattern: "*stale-and-never-matches*",
+      }),
+    ]);
+    jest.spyOn(NetworkDeviceService, "findOneById").mockResolvedValue(
+      fakeDeviceDetails({
+        description: "Cisco Catalyst Switch",
+        labels: [],
+      }),
+    );
+    const createUserSpy: jest.SpyInstance = jest
+      .spyOn(NetworkDeviceOwnerUserService, "create")
+      .mockResolvedValue(undefined as never);
+
+    await NetworkDeviceOwnerRuleEngineService.applyRulesToNetworkDevice(
+      ruleTarget(),
+    );
+
+    expect(createUserSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("supports Match All and Has All Of for owner criteria", async () => {
+    jest.spyOn(NetworkDeviceOwnerRuleService, "findBy").mockResolvedValue([
+      fakeOwnerRule({
+        criteria: criteria(FilterCondition.All, [
+          {
+            field: "networkDeviceNamePattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "0664",
+          },
+          {
+            field: "networkDeviceLabels",
+            operator: RuleCriteriaOperator.HasAllOf,
+            value: [PREREQUISITE_LABEL_ID.toString(), LABEL_B_ID.toString()],
+          },
+        ]),
+      }),
+    ]);
+    jest.spyOn(NetworkDeviceService, "findOneById").mockResolvedValue(
+      fakeDeviceDetails({
+        labels: [fakeLabel(PREREQUISITE_LABEL_ID), fakeLabel(LABEL_B_ID)],
+      }),
+    );
+    const createUserSpy: jest.SpyInstance = jest
+      .spyOn(NetworkDeviceOwnerUserService, "create")
+      .mockResolvedValue(undefined as never);
+
+    await NetworkDeviceOwnerRuleEngineService.applyRulesToNetworkDevice(
+      ruleTarget(),
+    );
+
+    expect(createUserSpy).toHaveBeenCalledTimes(1);
+  });
+
   it("adds owner teams too", async () => {
     jest.spyOn(NetworkDeviceOwnerRuleService, "findBy").mockResolvedValue([
       fakeOwnerRule({

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

@@ -6,6 +6,10 @@ import BadDataException from "../../../Types/Exception/BadDataException";
 import ObjectID from "../../../Types/ObjectID";
 import CreateBy from "../../../Server/Types/Database/CreateBy";
 import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import RuleCriteria, {
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
 import { describe, expect, it, afterEach } from "@jest/globals";
 
 /*
@@ -40,6 +44,7 @@ function mockSiteInProject(projectId: ObjectID): jest.SpyInstance {
 function makeCreateBy(data: {
   subnetCidr?: string | undefined;
   hostnamePattern?: string | undefined;
+  criteria?: RuleCriteria | undefined;
 }): CreateBy<NetworkSiteAssignmentRule> {
   const rule: NetworkSiteAssignmentRule = new NetworkSiteAssignmentRule();
   rule.projectId = PROJECT_ID;
@@ -50,12 +55,26 @@ function makeCreateBy(data: {
   if (data.hostnamePattern !== undefined) {
     rule.hostnamePattern = data.hostnamePattern;
   }
+  if (data.criteria !== undefined) {
+    rule.criteria = data.criteria;
+  }
   return {
     data: rule,
     props: { isRoot: true },
   };
 }
 
+function makeCriteria(data: {
+  filterCondition?: FilterCondition | undefined;
+  filters?: RuleCriteria["filters"] | undefined;
+}): RuleCriteria {
+  return {
+    schemaVersion: 1,
+    filterCondition: data.filterCondition || FilterCondition.All,
+    filters: data.filters || [],
+  };
+}
+
 describe("NetworkSiteAssignmentRuleService.onBeforeCreate", () => {
   afterEach(() => {
     jest.restoreAllMocks();
@@ -110,6 +129,115 @@ describe("NetworkSiteAssignmentRuleService.onBeforeCreate", () => {
     ).resolves.toBeDefined();
   });
 
+  it.each([FilterCondition.All, FilterCondition.Any])(
+    "accepts configurable %s criteria instead of legacy match fields",
+    async (filterCondition: FilterCondition) => {
+      mockSiteInProject(PROJECT_ID);
+
+      await expect(
+        (NetworkSiteAssignmentRuleService as any).onBeforeCreate(
+          makeCreateBy({
+            criteria: makeCriteria({
+              filterCondition: filterCondition,
+              filters: [
+                {
+                  field: "subnetCidr",
+                  operator: RuleCriteriaOperator.MatchesPattern,
+                  value: "10.0.0.0/24",
+                },
+                {
+                  field: "hostnamePattern",
+                  operator: RuleCriteriaOperator.Contains,
+                  value: "gateway",
+                },
+              ],
+            }),
+          }),
+        ),
+      ).resolves.toBeDefined();
+    },
+  );
+
+  it("uses configured criteria even when stale legacy fields are invalid", async () => {
+    mockSiteInProject(PROJECT_ID);
+
+    await expect(
+      (NetworkSiteAssignmentRuleService as any).onBeforeCreate(
+        makeCreateBy({
+          subnetCidr: "not-a-cidr",
+          criteria: makeCriteria({
+            filters: [
+              {
+                field: "hostnamePattern",
+                operator: RuleCriteriaOperator.StartsWith,
+                value: "edge-",
+              },
+            ],
+          }),
+        }),
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  it("rejects empty or malformed configured criteria", async () => {
+    await expect(
+      (NetworkSiteAssignmentRuleService as any).onBeforeCreate(
+        makeCreateBy({ criteria: makeCriteria({}) }),
+      ),
+    ).rejects.toThrow(BadDataException);
+
+    const createBy: CreateBy<NetworkSiteAssignmentRule> = makeCreateBy({});
+    createBy.data.criteria = {
+      schemaVersion: 99,
+      filterCondition: FilterCondition.All,
+      filters: [],
+    } as unknown as RuleCriteria;
+
+    await expect(
+      (NetworkSiteAssignmentRuleService as any).onBeforeCreate(createBy),
+    ).rejects.toThrow(BadDataException);
+  });
+
+  it.each([
+    ["unknownField", RuleCriteriaOperator.Equals, "value", "not a supported"],
+    [
+      "subnetCidr",
+      RuleCriteriaOperator.Equals,
+      "10.0.0.0/24",
+      "CIDR match operator",
+    ],
+    [
+      "subnetCidr",
+      RuleCriteriaOperator.MatchesPattern,
+      "10.0.0.0/99",
+      "not a valid IPv4 CIDR",
+    ],
+    [
+      "hostnamePattern",
+      RuleCriteriaOperator.HasAnyOf,
+      ["gateway"],
+      "not supported for Hostname Pattern",
+    ],
+  ])(
+    "rejects an invalid configured filter for %s",
+    async (
+      field: string,
+      operator: RuleCriteriaOperator,
+      value: string | Array<string>,
+      message: string,
+    ) => {
+      await expect(
+        (NetworkSiteAssignmentRuleService as any).onBeforeCreate(
+          makeCreateBy({
+            criteria: makeCriteria({
+              filters: [{ field: field, operator: operator, value: value }],
+            }),
+          }),
+        ),
+      ).rejects.toThrow(message);
+    },
+  );
+
   it("rejects a rule that points at another project's site", async () => {
     mockSiteInProject(OTHER_PROJECT_ID);
 
@@ -169,6 +297,7 @@ describe("NetworkSiteAssignmentRuleService.onBeforeUpdate", () => {
   function mockExistingRule(data: {
     subnetCidr?: string | undefined;
     hostnamePattern?: string | undefined;
+    criteria?: RuleCriteria | undefined;
   }): void {
     jest
       .spyOn(NetworkSiteAssignmentRuleService, "findBy")
@@ -231,6 +360,47 @@ describe("NetworkSiteAssignmentRuleService.onBeforeUpdate", () => {
     ).resolves.toBeDefined();
   });
 
+  it("accepts replacing legacy fields with configured criteria", async () => {
+    mockExistingRule({ subnetCidr: "10.0.0.0/24" });
+
+    await expect(
+      (NetworkSiteAssignmentRuleService as any).onBeforeUpdate(
+        makeUpdateBy({
+          criteria: makeCriteria({
+            filterCondition: FilterCondition.Any,
+            filters: [
+              {
+                field: "hostnamePattern",
+                operator: RuleCriteriaOperator.EndsWith,
+                value: "-prod",
+              },
+            ],
+          }),
+        }),
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  it("rejects clearing configured criteria when no legacy condition remains", async () => {
+    mockExistingRule({
+      criteria: makeCriteria({
+        filters: [
+          {
+            field: "hostnamePattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "gateway",
+          },
+        ],
+      }),
+    });
+
+    await expect(
+      (NetworkSiteAssignmentRuleService as any).onBeforeUpdate(
+        makeUpdateBy({ criteria: null }),
+      ),
+    ).rejects.toThrow(BadDataException);
+  });
+
   it("skips validation entirely when neither criterion nor site is touched", async () => {
     const findBySpy: jest.SpyInstance = jest.spyOn(
       NetworkSiteAssignmentRuleService,