@oneuptime/common 13.0.1 → 13.0.4

package/Tests/Utils/LabelRuleImportExport.test.ts

@@ -9,8 +9,13 @@ import Monitor from "../../Models/DatabaseModels/Monitor";
 import MonitorLabelRule from "../../Models/DatabaseModels/MonitorLabelRule";
 import NetworkDeviceLabelRule from "../../Models/DatabaseModels/NetworkDeviceLabelRule";
 import TableColumnType from "../../Types/Database/TableColumnType";
+import FilterCondition from "../../Types/Filter/FilterCondition";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
+import {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaOperator,
+} from "../../Types/Rules/RuleCriteria";
 import LabelRuleImportExport, {
   LABEL_RULE_MODELS,
   ParsedLabelRuleImport,
@@ -250,6 +255,159 @@ describe("portable label rule files", () => {
     },
   );
 
+  test.each([FilterCondition.Any, FilterCondition.All])(
+    "round trips configured %s criteria with relation names instead of IDs",
+    (filterCondition: FilterCondition) => {
+      const label: Label = new Label();
+      label._id = "44444444-4444-4444-8444-444444444444";
+      label.name = "Production";
+      const rule: MonitorLabelRule = new MonitorLabelRule();
+      rule.name = "Configured criteria";
+      rule.isEnabled = true;
+      rule.monitorLabels = [label];
+      rule.labelsToAdd = [label];
+      rule.criteria = {
+        schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+        filterCondition,
+        filters: [
+          {
+            field: "monitorNamePattern",
+            operator: RuleCriteriaOperator.StartsWith,
+            value: "api-",
+          },
+          {
+            field: "monitorLabels",
+            operator: RuleCriteriaOperator.HasAllOf,
+            value: [label.id!.toString()],
+          },
+        ],
+      };
+
+      const envelope: JSONObject = LabelRuleImportExport.buildExportEnvelope({
+        modelType: MonitorLabelRule,
+        items: [rule],
+      });
+      expect(JSON.stringify(envelope)).not.toContain(label.id!.toString());
+      expect(
+        (envelope["items"] as Array<JSONObject>)[0]!["criteria"],
+      ).toMatchObject({
+        schemaVersion: 1,
+        filterCondition,
+        filters: [
+          {
+            field: "monitorNamePattern",
+            operator: RuleCriteriaOperator.StartsWith,
+            value: "api-",
+          },
+          {
+            field: "monitorLabels",
+            operator: RuleCriteriaOperator.HasAllOf,
+            value: ["Production"],
+          },
+        ],
+      });
+
+      const parsed: ParsedLabelRuleImport = LabelRuleImportExport.parse({
+        modelType: MonitorLabelRule,
+        fileText: JSON.stringify(envelope),
+      });
+      expect(parsed.items[0]!.json["criteria"]).toEqual(
+        (envelope["items"] as Array<JSONObject>)[0]!["criteria"],
+      );
+    },
+  );
+
+  test("semantically maps configured criteria fields across resource rule types", () => {
+    const output: ParsedLabelRuleImport = parse(
+      [
+        {
+          ...base,
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.Any,
+            filters: [
+              {
+                field: "incidentTitlePattern",
+                operator: RuleCriteriaOperator.Contains,
+                value: "database",
+              },
+              {
+                field: "incidentLabels",
+                operator: RuleCriteriaOperator.HasAllOf,
+                value: ["Production"],
+              },
+            ],
+          },
+        },
+      ],
+      IncidentLabelRule,
+      AlertLabelRule,
+    );
+
+    expect(output.items[0]!.json["criteria"]).toEqual({
+      schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+      filterCondition: FilterCondition.Any,
+      filters: [
+        {
+          field: "alertTitlePattern",
+          operator: RuleCriteriaOperator.Contains,
+          value: "database",
+        },
+        {
+          field: "alertLabels",
+          operator: RuleCriteriaOperator.HasAllOf,
+          value: ["Production"],
+        },
+      ],
+    });
+    expect(output.items[0]!.portableJson["criteria"]).toMatchObject({
+      filters: [{ field: "incidentTitlePattern" }, { field: "incidentLabels" }],
+    });
+    expect(output.mappings).toContain(
+      "Incident Title Pattern → Alert Title Pattern",
+    );
+  });
+
+  test("validates regex syntax only for configured pattern operators", () => {
+    expect(
+      parse([
+        {
+          ...base,
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.All,
+            filters: [
+              {
+                field: "monitorNamePattern",
+                operator: RuleCriteriaOperator.Equals,
+                value: "[literal text",
+              },
+            ],
+          },
+        },
+      ]).items[0]!.json["criteria"],
+    ).toMatchObject({ filters: [{ value: "[literal text" }] });
+
+    expect(() => {
+      parse([
+        {
+          ...base,
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.All,
+            filters: [
+              {
+                field: "monitorNamePattern",
+                operator: RuleCriteriaOperator.MatchesPattern,
+                value: "[broken",
+              },
+            ],
+          },
+        },
+      ]);
+    }).toThrow("requires a valid regular expression or wildcard pattern");
+  });
+
   test.each(
     LABEL_RULE_MODELS.map(
       (modelType: DatabaseBaseModelType): [string, DatabaseBaseModelType] => {

package/Tests/Utils/NetworkDiscovery/AutoImportRuleMatcher.test.ts

@@ -3,6 +3,12 @@ import AutoImportRuleMatcher, {
   AutoImportRuleCandidate,
 } from "../../../Utils/NetworkDiscovery/AutoImportRuleMatcher";
 import { DiscoveredNetworkDevice } from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
 import { describe, expect, it } from "@jest/globals";
 
 /*
@@ -28,6 +34,93 @@ function host(
 }
 
 describe("AutoImportRuleMatcher.ruleMatchesHost", () => {
+  it("supports Match any across independently configurable conditions", () => {
+    expect(
+      AutoImportRuleMatcher.ruleMatchesHost(
+        {
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.Any,
+            filters: [
+              {
+                field: "sysNamePattern",
+                operator: RuleCriteriaOperator.Contains,
+                value: "does-not-match",
+              },
+              {
+                field: "ipMatchTarget",
+                operator: RuleCriteriaOperator.MatchesPattern,
+                value: "10.0.0.0/24",
+              },
+            ] as Array<RuleCriteriaFilter>,
+          },
+        },
+        host(),
+      ),
+    ).toBe(true);
+  });
+
+  it("supports Match all and ignores stale legacy match fields", () => {
+    const rule: AutoImportRuleCandidate = {
+      ipMatchTarget: "192.168.0.0/16",
+      criteria: {
+        schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+        filterCondition: FilterCondition.All,
+        filters: [
+          {
+            field: "sysNamePattern",
+            operator: RuleCriteriaOperator.StartsWith,
+            value: "switch-",
+          },
+          {
+            field: "sysDescrPattern",
+            operator: RuleCriteriaOperator.DoesNotContain,
+            value: "JunOS",
+          },
+        ] as Array<RuleCriteriaFilter>,
+      },
+    };
+
+    expect(AutoImportRuleMatcher.ruleMatchesHost(rule, host())).toBe(true);
+    expect(
+      AutoImportRuleMatcher.ruleMatchesHost(
+        rule,
+        host({ sysDescr: "JunOS 23.4" }),
+      ),
+    ).toBe(false);
+  });
+
+  it("preserves the ping-only safety gate for configured conditions", () => {
+    const pingOnlyHost: DiscoveredNetworkDevice = host({
+      snmpReachable: false,
+      sysName: undefined,
+      sysDescr: undefined,
+    });
+    const rule: AutoImportRuleCandidate = {
+      criteria: {
+        schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+        filterCondition: FilterCondition.All,
+        filters: [
+          {
+            field: "ipMatchTarget",
+            operator: RuleCriteriaOperator.Equals,
+            value: "10.0.0.5",
+          },
+        ],
+      },
+    };
+
+    expect(AutoImportRuleMatcher.ruleMatchesHost(rule, pingOnlyHost)).toBe(
+      false,
+    );
+    expect(
+      AutoImportRuleMatcher.ruleMatchesHost(
+        { ...rule, includePingOnlyHosts: true },
+        pingOnlyHost,
+      ),
+    ).toBe(true);
+  });
+
   /*
    * The site-rule precedent: an all-wildcard rule is a typo, not a
    * match-everything. A rule that claimed every host on an empty form would

package/Tests/Utils/NetworkSite/CidrMatchUtil.test.ts

@@ -1,6 +1,11 @@
 import CidrMatchUtil, {
   AssignmentRuleCandidate,
 } from "../../../Utils/NetworkSite/CidrMatchUtil";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import RuleCriteria, {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
 
 describe("CidrMatchUtil.ipInCidr", () => {
   it("matches inside a /24", () => {
@@ -409,6 +414,139 @@ describe("CidrMatchUtil.ruleMatches", () => {
       ),
     ).toBe(false);
   });
+
+  it("supports Match Any across CIDR and hostname conditions", () => {
+    expect(
+      CidrMatchUtil.ruleMatches(
+        {
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.Any,
+            filters: [
+              {
+                field: "subnetCidr",
+                operator: RuleCriteriaOperator.MatchesPattern,
+                value: "192.168.0.0/16",
+              },
+              {
+                field: "hostnamePattern",
+                operator: RuleCriteriaOperator.MatchesPattern,
+                value: "edge-*",
+              },
+            ],
+          },
+        },
+        { ip: "10.0.0.5", sysName: "EDGE-SWITCH" },
+      ),
+    ).toBe(true);
+  });
+
+  it("supports Match All and does not fall back to stale legacy fields", () => {
+    const rule: AssignmentRuleCandidate = {
+      subnetCidr: "192.168.0.0/16",
+      hostnamePattern: "stale-*",
+      criteria: {
+        schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+        filterCondition: FilterCondition.All,
+        filters: [
+          {
+            field: "subnetCidr",
+            operator: RuleCriteriaOperator.MatchesPattern,
+            value: "10.0.0.0/8",
+          },
+          {
+            field: "hostnamePattern",
+            operator: RuleCriteriaOperator.Contains,
+            value: "core",
+          },
+        ],
+      },
+    };
+
+    expect(
+      CidrMatchUtil.ruleMatches(rule, {
+        ip: "10.1.2.3",
+        name: "London Core Router",
+      }),
+    ).toBe(true);
+    expect(
+      CidrMatchUtil.ruleMatches(rule, {
+        ip: "10.1.2.3",
+        name: "London Edge Router",
+      }),
+    ).toBe(false);
+  });
+
+  it("negates CIDR and hostname predicates across every name candidate", () => {
+    const criteria: RuleCriteria = {
+      schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+      filterCondition: FilterCondition.All,
+      filters: [
+        {
+          field: "subnetCidr",
+          operator: RuleCriteriaOperator.DoesNotMatchPattern,
+          value: "10.0.0.0/8",
+        },
+        {
+          field: "hostnamePattern",
+          operator: RuleCriteriaOperator.DoesNotContain,
+          value: "printer",
+        },
+      ],
+    };
+
+    expect(
+      CidrMatchUtil.ruleMatches(
+        { criteria: criteria },
+        { ip: "192.168.1.5", hostname: "edge-1", name: "Core Router" },
+      ),
+    ).toBe(true);
+    expect(
+      CidrMatchUtil.ruleMatches(
+        { criteria: criteria },
+        { ip: "192.168.1.5", hostname: "edge-1", name: "Office Printer" },
+      ),
+    ).toBe(false);
+  });
+
+  it("fails closed for configured empty, malformed, or unknown criteria", () => {
+    expect(
+      CidrMatchUtil.ruleMatches(
+        {
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.All,
+            filters: [],
+          },
+        },
+        { ip: "10.0.0.1" },
+      ),
+    ).toBe(false);
+    expect(
+      CidrMatchUtil.ruleMatches(
+        { criteria: { schemaVersion: 99, filters: [] } },
+        { ip: "10.0.0.1" },
+      ),
+    ).toBe(false);
+    expect(
+      CidrMatchUtil.ruleMatches(
+        {
+          criteria: {
+            schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+            filterCondition: FilterCondition.All,
+            filters: [
+              {
+                field: "priority",
+                operator: RuleCriteriaOperator.Equals,
+                value: 1,
+              },
+            ],
+          },
+        },
+        { ip: "10.0.0.1" },
+      ),
+    ).toBe(false);
+  });
 });
 
 describe("CidrMatchUtil.pickRule", () => {

package/Tests/Utils/NetworkSite/TypeHierarchyUtil.test.ts

@@ -207,3 +207,177 @@ describe("NetworkSiteTypeHierarchyUtil", () => {
     ).toBe(3);
   });
 });
+
+/*
+ * The site PLACEMENT rule, as opposed to the catalog's own shape rule. A site
+ * may sit under any site whose type the hierarchy does not place below its
+ * own; requiring an exact configured-parent match is what made real
+ * hierarchies unbuildable in GitHub issue #3744.
+ */
+describe("NetworkSiteTypeHierarchyUtil site placement rule", () => {
+  /*
+   * Account › Region › Market › Unit (unit level), plus an unrelated root
+   * "Other" — the catch-all the reporting project was trying to nest under.
+   */
+  function catalog(): Array<NetworkSiteType> {
+    return [
+      makeType({ index: 1, name: "Account", order: 1 }),
+      makeType({ index: 2, name: "Region", order: 2, parentIndex: 1 }),
+      makeType({ index: 3, name: "Market", order: 3, parentIndex: 2 }),
+      makeType({
+        index: 4,
+        name: "Unit",
+        order: 4,
+        parentIndex: 3,
+        isUnitLevel: true,
+      }),
+      makeType({ index: 5, name: "Other", order: 5 }),
+    ];
+  }
+
+  function allowed(childIndex: number, parentIndex: number | null): boolean {
+    return NetworkSiteTypeHierarchyUtil.isTypeAllowedAsSiteParentOfType({
+      childNetworkSiteTypeId: typeId(childIndex).toString(),
+      parentNetworkSiteTypeId:
+        parentIndex === null ? null : typeId(parentIndex).toString(),
+      networkSiteTypes: catalog(),
+    });
+  }
+
+  it("allows the configured parent type", () => {
+    expect(allowed(3, 2)).toBe(true);
+  });
+
+  it("allows an unrelated type on either side", () => {
+    expect(allowed(3, 5)).toBe(true);
+    expect(allowed(5, 3)).toBe(true);
+  });
+
+  it("allows a skipped level", () => {
+    expect(allowed(4, 1)).toBe(true);
+  });
+
+  it("allows the same type on both sides", () => {
+    expect(allowed(5, 5)).toBe(true);
+    expect(allowed(2, 2)).toBe(true);
+  });
+
+  it("allows a parent with no type at all", () => {
+    expect(allowed(3, null)).toBe(true);
+  });
+
+  it("allows a child with no type", () => {
+    expect(
+      NetworkSiteTypeHierarchyUtil.isTypeAllowedAsSiteParentOfType({
+        childNetworkSiteTypeId: null,
+        parentNetworkSiteTypeId: typeId(3).toString(),
+        networkSiteTypes: catalog(),
+      }),
+    ).toBe(true);
+  });
+
+  it("refuses a parent whose type is a direct child of the child's type", () => {
+    expect(allowed(2, 3)).toBe(false);
+  });
+
+  it("refuses a parent whose type is a deeper descendant", () => {
+    expect(allowed(1, 3)).toBe(false);
+  });
+
+  it("refuses a unit-level parent whatever the child type", () => {
+    expect(allowed(5, 4)).toBe(false);
+    expect(allowed(1, 4)).toBe(false);
+    expect(allowed(4, 4)).toBe(false);
+  });
+
+  it("is case-insensitive about ids", () => {
+    expect(
+      NetworkSiteTypeHierarchyUtil.isTypeAllowedAsSiteParentOfType({
+        childNetworkSiteTypeId: typeId(2).toString().toUpperCase(),
+        parentNetworkSiteTypeId: typeId(3).toString().toUpperCase(),
+        networkSiteTypes: catalog(),
+      }),
+    ).toBe(false);
+  });
+
+  it("treats a type whose parent link names nothing as a root", () => {
+    const orphan: NetworkSiteType = makeType({
+      index: 9,
+      name: "Orphan",
+      parentIndex: 99,
+    });
+
+    expect(
+      NetworkSiteTypeHierarchyUtil.isTypeAllowedAsSiteParentOfType({
+        childNetworkSiteTypeId: typeId(1).toString(),
+        parentNetworkSiteTypeId: typeId(9).toString(),
+        networkSiteTypes: [...catalog(), orphan],
+      }),
+    ).toBe(true);
+  });
+
+  it("terminates on a cyclic catalog instead of looping forever", () => {
+    const cyclic: Array<NetworkSiteType> = [
+      makeType({ index: 1, name: "A", parentIndex: 2 }),
+      makeType({ index: 2, name: "B", parentIndex: 1 }),
+      makeType({ index: 3, name: "C" }),
+    ];
+
+    expect(
+      NetworkSiteTypeHierarchyUtil.isTypeAllowedAsSiteParentOfType({
+        childNetworkSiteTypeId: typeId(3).toString(),
+        parentNetworkSiteTypeId: typeId(1).toString(),
+        networkSiteTypes: cyclic,
+      }),
+    ).toBe(true);
+
+    // The cycle still answers its own membership question correctly.
+    expect(
+      NetworkSiteTypeHierarchyUtil.isTypeAllowedAsSiteParentOfType({
+        childNetworkSiteTypeId: typeId(2).toString(),
+        parentNetworkSiteTypeId: typeId(1).toString(),
+        networkSiteTypes: cyclic,
+      }),
+    ).toBe(false);
+  });
+
+  it("lists the types a site may be placed under", () => {
+    expect(
+      NetworkSiteTypeHierarchyUtil.getValidSiteParentTypes({
+        networkSiteTypeId: typeId(2).toString(),
+        networkSiteTypes: catalog(),
+      }).map((networkSiteType: NetworkSiteType) => {
+        return networkSiteType.name;
+      }),
+    ).toEqual(["Account", "Region", "Other"]);
+  });
+
+  it("lists the types a new child site may take, mirroring the parent list", () => {
+    expect(
+      NetworkSiteTypeHierarchyUtil.getValidSiteChildTypes({
+        networkSiteTypeId: typeId(2).toString(),
+        networkSiteTypes: catalog(),
+      }).map((networkSiteType: NetworkSiteType) => {
+        return networkSiteType.name;
+      }),
+    ).toEqual(["Region", "Market", "Unit", "Other"]);
+  });
+
+  it("offers no child type at all under a unit-level site", () => {
+    expect(
+      NetworkSiteTypeHierarchyUtil.getValidSiteChildTypes({
+        networkSiteTypeId: typeId(4).toString(),
+        networkSiteTypes: catalog(),
+      }),
+    ).toEqual([]);
+  });
+
+  it("offers every type under a site that has no type", () => {
+    expect(
+      NetworkSiteTypeHierarchyUtil.getValidSiteChildTypes({
+        networkSiteTypeId: null,
+        networkSiteTypes: catalog(),
+      }),
+    ).toHaveLength(5);
+  });
+});