@oneuptime/common 12.0.23 → 12.0.24

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

@@ -13,8 +13,10 @@ import { describe, expect, test } from "@jest/globals";
  * typo must surface to the person editing the rule, not as a cron-side
  * lastError hours later. These tests drive the create/update hooks
  * directly: invalid or aggregation-based Sigma is rejected, the rule name
- * defaults from the Sigma title, and the evaluation interval is clamped to
- * whole minutes between 1 and 1440.
+ * defaults from the Sigma title, the evaluation interval is clamped to
+ * whole minutes between 1 and 1440, and the match count threshold must be
+ * a whole number between 1 and 1000000 (or omitted — the column defaults
+ * to 1, so old API clients that never send it keep working).
  */
 
 const PROJECT_ID: ObjectID = new ObjectID(
@@ -52,6 +54,7 @@ function buildRule(
     name?: string;
     sigmaRuleYaml?: string;
     evaluationIntervalInMinutes?: number;
+    matchCountThreshold?: number;
   } = {},
 ): DetectionRule {
   const rule: DetectionRule = new DetectionRule();
@@ -66,6 +69,10 @@ function buildRule(
     rule.evaluationIntervalInMinutes = options.evaluationIntervalInMinutes;
   }
 
+  if (options.matchCountThreshold !== undefined) {
+    rule.matchCountThreshold = options.matchCountThreshold;
+  }
+
   return rule;
 }
 
@@ -219,6 +226,58 @@ detection:
       ).resolves.toBeDefined();
     });
   });
+
+  describe("match count threshold validation", () => {
+    const THRESHOLD_ERROR: string =
+      "Match count threshold must be a whole number between 1 and 1000000.";
+
+    test.each([1, 5, 1000000])("%d is accepted", async (threshold: number) => {
+      const rule: DetectionRule = buildRule({
+        name: "Thresholded",
+        matchCountThreshold: threshold,
+      });
+
+      await expect(
+        service.onBeforeCreate(buildCreateBy(rule)),
+      ).resolves.toBeDefined();
+    });
+
+    test.each([0, -1, 1.5, 1000001])(
+      "%d is rejected with the exact message",
+      async (threshold: number) => {
+        const rule: DetectionRule = buildRule({
+          name: "Bad Threshold",
+          matchCountThreshold: threshold,
+        });
+
+        await expect(
+          service.onBeforeCreate(buildCreateBy(rule)),
+        ).rejects.toThrow(THRESHOLD_ERROR);
+      },
+    );
+
+    test("an omitted threshold passes — the column defaults to 1, so old API clients that never send it still create rules", async () => {
+      const rule: DetectionRule = buildRule({ name: "No Threshold" });
+
+      expect(rule.matchCountThreshold).toBeUndefined();
+
+      await expect(
+        service.onBeforeCreate(buildCreateBy(rule)),
+      ).resolves.toBeDefined();
+    });
+
+    test("a valid threshold does not bypass the Sigma validation that runs before it", async () => {
+      const rule: DetectionRule = buildRule({
+        name: "Still Broken YAML",
+        sigmaRuleYaml: "title: [unclosed",
+        matchCountThreshold: 5,
+      });
+
+      await expect(service.onBeforeCreate(buildCreateBy(rule))).rejects.toThrow(
+        BadDataException,
+      );
+    });
+  });
 });
 
 describe("DetectionRuleService.onBeforeUpdate", () => {
@@ -251,4 +310,77 @@ describe("DetectionRuleService.onBeforeUpdate", () => {
       ),
     ).rejects.toThrow(BadDataException);
   });
+
+  test("an update with an invalid matchCountThreshold is rejected with the exact message", async () => {
+    await expect(
+      service.onBeforeUpdate(buildUpdateBy({ matchCountThreshold: 0 })),
+    ).rejects.toThrow(
+      "Match count threshold must be a whole number between 1 and 1000000.",
+    );
+  });
+
+  test("an update with a valid matchCountThreshold passes", async () => {
+    await expect(
+      service.onBeforeUpdate(buildUpdateBy({ matchCountThreshold: 42 })),
+    ).resolves.toBeDefined();
+  });
+
+  test("an update that omits matchCountThreshold skips the threshold validation", async () => {
+    await expect(
+      service.onBeforeUpdate(buildUpdateBy({ description: "No threshold" })),
+    ).resolves.toBeDefined();
+  });
+});
+
+describe("DetectionRuleService field-name trimming", () => {
+  /*
+   * groupByField / distinctCountField are looked up verbatim by the
+   * evaluator — an unknown name silently becomes an attributes[] lookup
+   * yielding '' on every row, and for a distinct-count rule that is a
+   * permanent zero-fire outage with no error anywhere. Trimming at save
+   * time kills the whitespace-from-a-paste class of that failure.
+   */
+  test("create trims whitespace from groupByField and distinctCountField", async () => {
+    const rule: DetectionRule = buildRule();
+    rule.groupByField = " principalIp ";
+    rule.distinctCountField = "principalUser\t";
+
+    const result: OnCreate<DetectionRule> = await service.onBeforeCreate(
+      buildCreateBy(rule),
+    );
+
+    expect(result.createBy.data.groupByField).toBe("principalIp");
+    expect(result.createBy.data.distinctCountField).toBe("principalUser");
+  });
+
+  test("create leaves omitted field names undefined", async () => {
+    const result: OnCreate<DetectionRule> = await service.onBeforeCreate(
+      buildCreateBy(buildRule()),
+    );
+
+    expect(result.createBy.data.groupByField).toBeUndefined();
+    expect(result.createBy.data.distinctCountField).toBeUndefined();
+  });
+
+  test("update trims field names and collapses whitespace-only to the cleared value", async () => {
+    const result: OnUpdate<DetectionRule> = await service.onBeforeUpdate(
+      buildUpdateBy({
+        groupByField: "  ",
+        distinctCountField: " targetUser ",
+      }),
+    );
+
+    // '' is the documented "feature off" value, so clearing still works.
+    expect(result.updateBy.data.groupByField).toBe("");
+    expect(result.updateBy.data.distinctCountField).toBe("targetUser");
+  });
+
+  test("an update that omits the field names does not add them", async () => {
+    const result: OnUpdate<DetectionRule> = await service.onBeforeUpdate(
+      buildUpdateBy({ description: "No field names" }),
+    );
+
+    expect("groupByField" in result.updateBy.data).toBe(false);
+    expect("distinctCountField" in result.updateBy.data).toBe(false);
+  });
 });

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

@@ -140,7 +140,13 @@ describe("discovery-scan claim hookless write safety preconditions", () => {
         "startedAt",
         "statusMessage",
       ];
-      const columnsValidatedByHook: Array<string> = ["cidr"];
+      /*
+       * `name` joined `cidr` here when discovery scans became nameable
+       * (issue #3391): the hook validates and normalizes it on any update that
+       * carries it. The claim payload does not, which is what keeps the
+       * hookless write honest.
+       */
+      const columnsValidatedByHook: Array<string> = ["cidr", "name"];
 
       for (const column of claimWriteColumns) {
         expect(columnsValidatedByHook).not.toContain(column);

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

@@ -0,0 +1,131 @@
+import fs from "fs";
+import path from "path";
+
+/*
+ * Retention windows are declared per service via hardDeleteItemsOlderThanInDays,
+ * but they only take effect once the service is listed in
+ * Server/Services/Index.ts - that array is what
+ * App/FeatureSet/Workers/Jobs/HardDelete/HardDeleteItemsInDatabase.ts iterates.
+ * A window on an unregistered service is dead configuration, and registering
+ * the service later silently arms it.
+ *
+ * That is not hypothetical: OnCallDutyPolicyFeedService sat unregistered
+ * carrying a 90 day window while every other feed kept 3 years. Commit
+ * 6bbf2f866c ("retain items for 3 years instead of 120 days") swept the feeds
+ * from 120 to 3 * 365 and missed this one precisely because it held 90 rather
+ * than 120, and nothing noticed because the service was not registered.
+ * Registering it - which the workflow component registry fix had to do, since
+ * OnCallDutyPolicyFeed is workflow-enabled - would have started hard deleting
+ * on-call policy history at 90 days on billing-enabled deployments.
+ *
+ * Feed tables are the same kind of data as each other: a user-visible activity
+ * timeline hung off a parent entity. They should expire together, whether or
+ * not they happen to be registered yet.
+ */
+
+const SERVICES_DIRECTORY: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "Server",
+  "Services",
+);
+
+const RETENTION_PATTERN: RegExp =
+  /hardDeleteItemsOlderThanInDays\(\s*"(\w+)"\s*,\s*([^)]+?)\s*\)/;
+
+interface FeedRetention {
+  serviceName: string;
+  columnName: string;
+  window: string;
+}
+
+const feedServiceNames: Array<string> = fs
+  .readdirSync(SERVICES_DIRECTORY)
+  .sort()
+  .filter((fileName: string) => {
+    return fileName.endsWith("FeedService.ts");
+  })
+  .map((fileName: string) => {
+    return fileName.replace(/\.ts$/, "");
+  });
+
+const feedRetentions: Array<FeedRetention> = [];
+
+for (const serviceName of feedServiceNames) {
+  const source: string = fs.readFileSync(
+    path.join(SERVICES_DIRECTORY, `${serviceName}.ts`),
+    "utf8",
+  );
+
+  const match: RegExpMatchArray | null = source.match(RETENTION_PATTERN);
+
+  if (!match) {
+    // Deliberately not skipped - see "declares a retention window at all" below.
+    continue;
+  }
+
+  feedRetentions.push({
+    serviceName: serviceName,
+    columnName: match[1]!,
+    window: match[2]!.trim(),
+  });
+}
+
+describe("Feed service retention windows", () => {
+  test("the feed services were actually found", () => {
+    // Guards the assertions below against a silent pass on an empty list.
+    expect(feedServiceNames.length).toBeGreaterThan(0);
+  });
+
+  test("every feed service declares a retention window at all", () => {
+    /*
+     * The window/column assertions below can only speak for services this file
+     * managed to parse. Comparing against the filenames on disk - rather than a
+     * hardcoded count - is what stops a feed service that declares no retention,
+     * or declares one in a shape the pattern misses, from being dropped from
+     * those assertions and passing in silence.
+     */
+    const parsed: Array<string> = feedRetentions.map((entry: FeedRetention) => {
+      return entry.serviceName;
+    });
+
+    expect(parsed).toEqual(feedServiceNames);
+  });
+
+  test("every feed service expires on the same window", () => {
+    const windows: Array<string> = [
+      ...new Set(
+        feedRetentions.map((entry: FeedRetention) => {
+          return entry.window;
+        }),
+      ),
+    ];
+
+    // Reported with the owning service names so a divergent one is obvious.
+    expect({
+      windows,
+      services: feedRetentions.map((entry: FeedRetention) => {
+        return `${entry.serviceName}=${entry.window}`;
+      }),
+    }).toEqual({
+      windows: ["3 * 365"],
+      services: feedRetentions.map((entry: FeedRetention) => {
+        return `${entry.serviceName}=3 * 365`;
+      }),
+    });
+  });
+
+  test("every feed service expires on the same column", () => {
+    const columns: Array<string> = [
+      ...new Set(
+        feedRetentions.map((entry: FeedRetention) => {
+          return entry.columnName;
+        }),
+      ),
+    ];
+
+    expect(columns).toEqual(["createdAt"]);
+  });
+});

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

@@ -3,6 +3,7 @@ import NetworkDeviceDiscoveryScan from "../../../Models/DatabaseModels/NetworkDe
 import BadDataException from "../../../Types/Exception/BadDataException";
 import ObjectID from "../../../Types/ObjectID";
 import ScanTargetUtil from "../../../Utils/NetworkDiscovery/ScanTargetUtil";
+import ScanNameUtil from "../../../Utils/NetworkDiscovery/ScanNameUtil";
 import CreateBy from "../../../Server/Types/Database/CreateBy";
 import UpdateBy from "../../../Server/Types/Database/UpdateBy";
 import { describe, expect, it } from "@jest/globals";
@@ -40,6 +41,41 @@ function makeCreateBy(cidr?: unknown): CreateBy<NetworkDeviceDiscoveryScan> {
   };
 }
 
+/*
+ * A scan with a valid target and whatever `name` the caller wants to try. The
+ * name is written through a Record cast for the same reason the target is: the
+ * hook runs before the model's own type checks, so a client really can send a
+ * number or an object here.
+ */
+function makeCreateByWithName(
+  name?: unknown,
+): CreateBy<NetworkDeviceDiscoveryScan> {
+  const createBy: CreateBy<NetworkDeviceDiscoveryScan> =
+    makeCreateBy("192.168.1.0/24");
+
+  if (name !== undefined) {
+    (createBy.data as unknown as Record<string, unknown>)["name"] = name;
+  }
+
+  return createBy;
+}
+
+type CreatedNameFunction = (name?: unknown) => Promise<unknown>;
+
+/*
+ * What the hook would actually store in the column, for a given input.
+ */
+const createdName: CreatedNameFunction = async (
+  name?: unknown,
+): Promise<unknown> => {
+  const createBy: CreateBy<NetworkDeviceDiscoveryScan> =
+    makeCreateByWithName(name);
+
+  await onBeforeCreate(createBy);
+
+  return (createBy.data as unknown as Record<string, unknown>)["name"];
+};
+
 function makeUpdateBy(
   data: Record<string, unknown>,
 ): UpdateBy<NetworkDeviceDiscoveryScan> {
@@ -260,3 +296,161 @@ describe("NetworkDeviceDiscoveryScanService.onBeforeUpdate", () => {
     );
   });
 });
+
+/*
+ * The optional name (issue #3391). The hook does two things with it, and the
+ * tests below separate them deliberately: it REJECTS what could never be
+ * stored (a non-string, a value past the column width), and it NORMALIZES what
+ * can be (trimming, folding onto one line, and turning a blank name into no
+ * name at all). The messages are ScanNameUtil's, so the wizard's inline error
+ * and the API's 400 are the same sentence.
+ */
+describe("NetworkDeviceDiscoveryScanService name validation on create", () => {
+  it("accepts a scan with no name, because the field is optional", async () => {
+    await expect(onBeforeCreate(makeCreateByWithName())).resolves.toBeDefined();
+    await expect(createdName()).resolves.toBeUndefined();
+  });
+
+  it("accepts an ordinary name and stores it as typed", async () => {
+    await expect(createdName("Router Discovery - Region 1100")).resolves.toBe(
+      "Router Discovery - Region 1100",
+    );
+  });
+
+  it("trims the name before storing it", async () => {
+    await expect(createdName("  Switch Discovery  ")).resolves.toBe(
+      "Switch Discovery",
+    );
+  });
+
+  /*
+   * A name pasted out of a spreadsheet cell arrives with a newline in it. The
+   * list renders one line per scan and the probe inlines the name into log
+   * messages, so the fold happens once, here, rather than at each reader.
+   */
+  it("folds a multi-line name onto one line", async () => {
+    await expect(createdName("Router\nDiscovery   1100")).resolves.toBe(
+      "Router Discovery 1100",
+    );
+  });
+
+  /*
+   * The distinction the column depends on: a blank box and an empty box are
+   * the same statement, and both store nothing. An empty string would read as
+   * a name to every caller that asks `scan.name ?`.
+   */
+  it("stores nothing at all for a blank name", async () => {
+    await expect(createdName("")).resolves.toBeUndefined();
+    await expect(createdName("   ")).resolves.toBeUndefined();
+    await expect(createdName("\n\t")).resolves.toBeUndefined();
+  });
+
+  it("rejects a name that would not fit the column", async () => {
+    await expect(
+      onBeforeCreate(makeCreateByWithName("a".repeat(101))),
+    ).rejects.toThrow(BadDataException);
+
+    await expect(
+      onBeforeCreate(makeCreateByWithName("a".repeat(100))),
+    ).resolves.toBeDefined();
+  });
+
+  /*
+   * The hook runs before the model's type checks, so this is the first thing
+   * to see a client that sent the wrong shape. It must be a 400 rather than
+   * the 500 an unguarded `.trim()` would produce.
+   */
+  it("rejects a name that is not text", async () => {
+    for (const value of [1100, true, { name: "Router" }, ["Router"]]) {
+      await expect(onBeforeCreate(makeCreateByWithName(value))).rejects.toThrow(
+        BadDataException,
+      );
+    }
+  });
+
+  it("reports the same message the shared validator does", async () => {
+    const tooLong: string = "a".repeat(101);
+
+    await expect(onBeforeCreate(makeCreateByWithName(tooLong))).rejects.toThrow(
+      ScanNameUtil.getValidationError(tooLong) as string,
+    );
+  });
+
+  // The target is still validated when a name is present.
+  it("still rejects a bad target on a named scan", async () => {
+    const createBy: CreateBy<NetworkDeviceDiscoveryScan> =
+      makeCreateBy("10.22-16.0.1");
+    (createBy.data as unknown as Record<string, unknown>)["name"] =
+      "Router Discovery";
+
+    await expect(onBeforeCreate(createBy)).rejects.toThrow(BadDataException);
+  });
+});
+
+describe("NetworkDeviceDiscoveryScanService name validation on update", () => {
+  type UpdatedNameFunction = (name: unknown) => Promise<unknown>;
+
+  const updatedName: UpdatedNameFunction = async (
+    name: unknown,
+  ): Promise<unknown> => {
+    const updateBy: UpdateBy<NetworkDeviceDiscoveryScan> = makeUpdateBy({
+      name: name,
+    });
+
+    await onBeforeUpdate(updateBy);
+
+    return (updateBy.data as unknown as Record<string, unknown>)["name"];
+  };
+
+  /*
+   * Renaming is the one edit a scan accepts, so this path is the product's,
+   * not just a guard against root writers.
+   */
+  it("accepts and normalizes a rename", async () => {
+    await expect(updatedName("  Switch Discovery — WB Units  ")).resolves.toBe(
+      "Switch Discovery — WB Units",
+    );
+  });
+
+  /*
+   * The form posts an emptied box as an empty string. That means "this scan
+   * has no name", which is NULL — not "", and not `undefined`, which TypeORM
+   * would still try to write.
+   */
+  it("clears the name with null when the box is emptied", async () => {
+    await expect(updatedName("")).resolves.toBeNull();
+    await expect(updatedName("   ")).resolves.toBeNull();
+    await expect(updatedName(null)).resolves.toBeNull();
+  });
+
+  it("rejects a rename that would not fit the column", async () => {
+    await expect(
+      onBeforeUpdate(makeUpdateBy({ name: "a".repeat(101) })),
+    ).rejects.toThrow(BadDataException);
+  });
+
+  it("rejects a rename that is not text", async () => {
+    await expect(onBeforeUpdate(makeUpdateBy({ name: 1100 }))).rejects.toThrow(
+      BadDataException,
+    );
+  });
+
+  /*
+   * The probe claim path writes status/startedAt/statusMessage through the
+   * hookless fast path, and every other run-state write goes through here
+   * without a name. Touching the column on those updates would rewrite a name
+   * nobody asked to change.
+   */
+  it("leaves an update that does not carry a name completely alone", async () => {
+    const updateBy: UpdateBy<NetworkDeviceDiscoveryScan> = makeUpdateBy({
+      status: "Completed",
+      respondedHostCount: 3,
+    });
+
+    await onBeforeUpdate(updateBy);
+
+    expect(Object.prototype.hasOwnProperty.call(updateBy.data, "name")).toBe(
+      false,
+    );
+  });
+});