@oneuptime/common 12.0.22 → 12.0.24

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,
+    );
+  });
+});