@oneuptime/common 12.0.6 → 12.0.8

package/Tests/Server/Utils/Telemetry/InventoryEntityRegistry.test.ts

@@ -0,0 +1,322 @@
+import TelemetryEntity from "../../../../Models/DatabaseModels/TelemetryEntity";
+import {
+  buildInventoryEntityModel,
+  compactAttributes,
+  ErasedInventorySource,
+  INVENTORY_SOURCES,
+  inventoryEntityNeedsUpdate,
+  InventoryRowProjection,
+} from "../../../../Server/Utils/Telemetry/InventoryEntityRegistry";
+import ColumnLength from "../../../../Types/Database/ColumnLength";
+import Dictionary from "../../../../Types/Dictionary";
+import ObjectID from "../../../../Types/ObjectID";
+import EntitySource from "../../../../Types/Telemetry/EntitySource";
+import EntityType from "../../../../Types/Telemetry/EntityType";
+import { INVENTORY_ENTITY_TYPES } from "../../../../Types/Telemetry/EntityTypeGroups";
+import { keyForInventoryEntity } from "../../../../Utils/Telemetry/EntityKey";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The pure half of the inventory mirror — the mapping from an inventory row
+ * to its registry row, and the drift check that decides whether to write.
+ *
+ * Worth testing closely for two reasons. A mistake in the mapping mints a
+ * duplicate entity that looks entirely correct, and a mistake in the drift
+ * check either writes on every reconcile (seven table scans' worth of
+ * needless UPDATEs every fifteen minutes) or never writes at all (renames
+ * never propagate).
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "0f8b9c0d-e1a2-4b3c-8d5e-6f7a8b9c0d1e",
+);
+const RESOURCE_ID: ObjectID = new ObjectID(
+  "6f2e5c1a-0b3d-4e5f-8a9b-1c2d3e4f5a6b",
+);
+const NOW: Date = new Date("2026-03-04T05:06:07.000Z");
+
+function projection(
+  overrides: Partial<InventoryRowProjection> = {},
+): InventoryRowProjection {
+  return {
+    id: RESOURCE_ID,
+    projectId: PROJECT_ID,
+    displayName: "core-switch-1",
+    descriptiveAttributes: { "net.device.hostname": "core-switch-1.dc1" },
+    ...overrides,
+  };
+}
+
+const NETWORK_SOURCE: Pick<
+  ErasedInventorySource,
+  "entityType" | "resourceType"
+> = {
+  entityType: EntityType.NetworkDevice,
+  resourceType: "NetworkDevice",
+};
+
+describe("compactAttributes", () => {
+  test("keeps ordinary values", () => {
+    expect(compactAttributes({ a: "1", b: "two" })).toEqual({
+      a: "1",
+      b: "two",
+    });
+  });
+
+  test("drops undefined, null, empty and whitespace-only values", () => {
+    const out: Dictionary<string> = compactAttributes({
+      keep: "yes",
+      undef: undefined,
+      nul: null,
+      empty: "",
+      blank: "   ",
+    });
+
+    expect(out).toEqual({ keep: "yes" });
+  });
+
+  test("trims surviving values", () => {
+    expect(compactAttributes({ a: "  spaced  " })).toEqual({ a: "spaced" });
+  });
+
+  test("returns an empty object when everything is dropped", () => {
+    expect(compactAttributes({ a: undefined, b: "" })).toEqual({});
+  });
+});
+
+describe("buildInventoryEntityModel", () => {
+  test("marks the row as inventory-sourced", () => {
+    const model: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+
+    /*
+     * The single most important assertion in this file: PruneStaleEntities
+     * exempts rows by source, so a mirror that came out marked `discovered`
+     * would be deleted the first time the sweep ran past its TTL.
+     */
+    expect(model.source).toBe(EntitySource.Inventory);
+  });
+
+  test("derives the key from the owning row id, matching keyForInventoryEntity", () => {
+    const model: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+
+    expect(model.entityKey).toBe(
+      keyForInventoryEntity(
+        PROJECT_ID.toString(),
+        EntityType.NetworkDevice,
+        RESOURCE_ID.toString(),
+      ),
+    );
+  });
+
+  test("a rename does not change identity", () => {
+    const before: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection({ displayName: "core-switch-1" }),
+      now: NOW,
+    });
+    const after: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection({ displayName: "core-switch-1-renamed" }),
+      now: NOW,
+    });
+
+    expect(after.entityKey).toBe(before.entityKey);
+    expect(after.displayName).not.toBe(before.displayName);
+  });
+
+  test("populates the polymorphic pointer back to the owning row", () => {
+    const model: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+
+    expect(model.resourceType).toBe("NetworkDevice");
+    expect(model.resourceId?.toString()).toBe(RESOURCE_ID.toString());
+  });
+
+  test("carries project, type, attributes and timestamps through", () => {
+    const model: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+
+    expect(model.projectId?.toString()).toBe(PROJECT_ID.toString());
+    expect(model.entityType).toBe(EntityType.NetworkDevice);
+    expect(model.descriptiveAttributes).toEqual({
+      "net.device.hostname": "core-switch-1.dc1",
+    });
+    expect(model.firstSeenAt).toEqual(NOW);
+    expect(model.lastSeenAt).toEqual(NOW);
+  });
+
+  test("records the owning row id as the identifying attribute", () => {
+    const model: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+
+    expect(model.identifyingAttributes).toEqual({
+      "oneuptime.resource.id": RESOURCE_ID.toString(),
+    });
+  });
+
+  test("clamps displayName to the column width", () => {
+    /*
+     * displayName is a bounded varchar; an over-long name would otherwise
+     * fail the INSERT with a 22001 and lose the row entirely.
+     */
+    const model: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection({ displayName: "n".repeat(ColumnLength.ShortText + 50) }),
+      now: NOW,
+    });
+
+    expect(model.displayName!.length).toBe(ColumnLength.ShortText);
+  });
+
+  test("distinct rows of one type produce distinct keys", () => {
+    const first: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+    const second: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection({
+        id: new ObjectID("11111111-2222-3333-4444-555555555555"),
+      }),
+      now: NOW,
+    });
+
+    expect(first.entityKey).not.toBe(second.entityKey);
+  });
+
+  test("the same row id under two types produces distinct keys", () => {
+    const asDevice: TelemetryEntity = buildInventoryEntityModel({
+      source: NETWORK_SOURCE,
+      row: projection(),
+      now: NOW,
+    });
+    const asIoT: TelemetryEntity = buildInventoryEntityModel({
+      source: { entityType: EntityType.IoTDevice, resourceType: "IoTDevice" },
+      row: projection(),
+      now: NOW,
+    });
+
+    expect(asDevice.entityKey).not.toBe(asIoT.entityKey);
+  });
+});
+
+describe("inventoryEntityNeedsUpdate", () => {
+  function pair(existingOverrides: Partial<InventoryRowProjection>): {
+    existing: TelemetryEntity;
+    desired: TelemetryEntity;
+  } {
+    return {
+      existing: buildInventoryEntityModel({
+        source: NETWORK_SOURCE,
+        row: projection(existingOverrides),
+        now: NOW,
+      }),
+      desired: buildInventoryEntityModel({
+        source: NETWORK_SOURCE,
+        row: projection(),
+        now: NOW,
+      }),
+    };
+  }
+
+  test("false in the steady state, so a quiet reconcile writes nothing", () => {
+    const { existing, desired } = pair({});
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(false);
+  });
+
+  test("true when the row was renamed", () => {
+    const { existing, desired } = pair({ displayName: "old-name" });
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(true);
+  });
+
+  test("true when descriptive attributes changed", () => {
+    const { existing, desired } = pair({
+      descriptiveAttributes: { "net.device.hostname": "old-host" },
+    });
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(true);
+  });
+
+  test("true when an attribute was added", () => {
+    const { existing, desired } = pair({ descriptiveAttributes: {} });
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(true);
+  });
+
+  test("true when the polymorphic pointer is missing", () => {
+    const { existing, desired } = pair({});
+    // Deleted rather than assigned undefined: exactOptionalPropertyTypes.
+    delete (existing as { resourceId?: ObjectID }).resourceId;
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(true);
+  });
+
+  test("true when the pointer type is wrong", () => {
+    const { existing, desired } = pair({});
+    existing.resourceType = "SomethingElse";
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(true);
+  });
+
+  test("ignores lastSeenAt, which never advances for mirrored rows", () => {
+    const { existing, desired } = pair({});
+    existing.lastSeenAt = new Date("2020-01-01T00:00:00.000Z");
+    expect(inventoryEntityNeedsUpdate({ existing, desired })).toBe(false);
+  });
+});
+
+describe("INVENTORY_SOURCES", () => {
+  test("covers exactly the declared inventory entity types", () => {
+    const covered: Array<EntityType> = INVENTORY_SOURCES.map(
+      (source: ErasedInventorySource) => {
+        return source.entityType;
+      },
+    );
+
+    expect(covered.sort()).toEqual(Array.from(INVENTORY_ENTITY_TYPES).sort());
+  });
+
+  test("registers each entity type exactly once", () => {
+    const seen: Set<EntityType> = new Set<EntityType>();
+
+    for (const source of INVENTORY_SOURCES) {
+      expect(seen.has(source.entityType)).toBe(false);
+      seen.add(source.entityType);
+    }
+  });
+
+  test("registers each resourceType exactly once", () => {
+    const seen: Set<string> = new Set<string>();
+
+    for (const source of INVENTORY_SOURCES) {
+      expect(seen.has(source.resourceType)).toBe(false);
+      seen.add(source.resourceType);
+    }
+  });
+
+  test("every source names a non-empty resourceType", () => {
+    for (const source of INVENTORY_SOURCES) {
+      expect(source.resourceType.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("no source mirrors a manually creatable type", () => {
+    for (const source of INVENTORY_SOURCES) {
+      expect(INVENTORY_ENTITY_TYPES.has(source.entityType)).toBe(true);
+    }
+  });
+});

package/Tests/Server/Utils/VM/VMAPISubstitution.test.ts

@@ -0,0 +1,243 @@
+/*
+ * Substitution behaviour of VMUtil.replaceValueInPlace, focused on the three
+ * ways a resolved value used to come out wrong: unescaped quotes when the
+ * caller passed an object, `$`-patterns in the replacement text, and
+ * `[last]` against a key that is not an array.
+ */
+
+jest.mock("../../../../Server/Utils/VM/VMRunner", () => {
+  return {
+    __esModule: true,
+    default: {
+      runCodeInSandbox: jest.fn(),
+    },
+  };
+});
+
+jest.mock("../../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      error: jest.fn(),
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+    },
+  };
+});
+
+jest.mock("../../../../Server/Utils/Telemetry/CaptureSpan", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return (
+        _target: any,
+        _propertyKey: string,
+        descriptor: PropertyDescriptor,
+      ) => {
+        return descriptor;
+      };
+    },
+  };
+});
+
+import VMUtil from "../../../../Server/Utils/VM/VMAPI";
+import { JSONObject, JSONValue } from "../../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+type MakeStorageFunction = (variables: JSONObject) => JSONObject;
+
+const makeStorage: MakeStorageFunction = (
+  variables: JSONObject,
+): JSONObject => {
+  return {
+    local: {
+      variables: variables,
+      components: {},
+    },
+    global: {
+      variables: {},
+    },
+  };
+};
+
+describe("replaceValueInPlace — object input (the key/value headers shape)", () => {
+  it("returns an object, not a string", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({ token: "abc" }),
+      { Authorization: "Bearer {{local.variables.token}}" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect(typeof result).toBe("object");
+    expect(result).toEqual({ Authorization: "Bearer abc" });
+  });
+
+  /*
+   * The regression this guards: the object is stringified, so every
+   * placeholder sits inside a JSON string literal. A resolved value carrying a
+   * quote used to be spliced in raw, the JSON.parse on the way back out threw,
+   * and the caller silently received a corrupted string where it asked for an
+   * object — which then spread into per-character HTTP headers.
+   */
+  it("escapes a resolved value containing a double quote", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({ note: 'he said "hi"' }),
+      { "X-Note": "{{local.variables.note}}" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect(typeof result).toBe("object");
+    expect(result).toEqual({ "X-Note": 'he said "hi"' });
+  });
+
+  it("escapes a resolved value containing a newline", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({ note: "line1\nline2" }),
+      { "X-Note": "{{local.variables.note}}" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect(typeof result).toBe("object");
+    expect(result).toEqual({ "X-Note": "line1\nline2" });
+  });
+
+  it("escapes a resolved value containing a backslash", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({ path: "C:\\Users" }),
+      { "X-Path": "{{local.variables.path}}" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect(typeof result).toBe("object");
+    expect((result as JSONObject)["X-Path"]).toBe("C:\\Users");
+  });
+
+  it("escapes a resolved value containing a regex", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({ pattern: "\\d+\\s" }),
+      { "X-Pattern": "{{local.variables.pattern}}" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect((result as JSONObject)["X-Pattern"]).toBe("\\d+\\s");
+  });
+
+  it("escapes a value carrying a backslash and a quote together", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({ v: 'a\\b"c' }),
+      { "X-V": "{{local.variables.v}}" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect((result as JSONObject)["X-V"]).toBe('a\\b"c');
+  });
+
+  it("leaves an object with no placeholders untouched", () => {
+    const result: JSONValue = VMUtil.replaceValueInPlace(
+      makeStorage({}),
+      { A: "b" } as never,
+      false,
+    ) as unknown as JSONValue;
+
+    expect(result).toEqual({ A: "b" });
+  });
+});
+
+describe("replaceValueInPlace — $ in resolved values", () => {
+  /*
+   * String.replace treats $&, $', $` and $1 in the REPLACEMENT as substitution
+   * patterns. A resolved value of "A$&B" used to render as "A{{v}}B", pasting
+   * the matched placeholder back into the output.
+   */
+  it("does not treat $& in a value as a substitution pattern", () => {
+    const result: string = VMUtil.replaceValueInPlace(
+      makeStorage({ v: "A$&B" }),
+      "start {{local.variables.v}} end",
+      false,
+    );
+
+    expect(result).toBe("start A$&B end");
+  });
+
+  it("does not treat $` or $' as substitution patterns", () => {
+    expect(
+      VMUtil.replaceValueInPlace(
+        makeStorage({ v: "x$`y" }),
+        "a {{local.variables.v}} b",
+        false,
+      ),
+    ).toBe("a x$`y b");
+
+    expect(
+      VMUtil.replaceValueInPlace(
+        makeStorage({ v: "x$'y" }),
+        "a {{local.variables.v}} b",
+        false,
+      ),
+    ).toBe("a x$'y b");
+  });
+
+  it("keeps a plain dollar amount intact", () => {
+    expect(
+      VMUtil.replaceValueInPlace(
+        makeStorage({ price: "$50" }),
+        "Total: {{local.variables.price}} today",
+        false,
+      ),
+    ).toBe("Total: $50 today");
+  });
+});
+
+describe("deepFind — [last] accessor", () => {
+  type FindFunction = (storage: JSONObject, path: string) => JSONValue;
+
+  const find: FindFunction = (storage: JSONObject, path: string): JSONValue => {
+    return VMUtil.deepFind(storage, path);
+  };
+
+  it("resolves the final element of an array", () => {
+    expect(find({ items: ["a", "b", "c"] }, "items[last]")).toBe("c");
+  });
+
+  it("returns undefined rather than throwing when the key is missing", () => {
+    expect(find({}, "items[last]")).toBeUndefined();
+  });
+
+  it("returns undefined rather than throwing when the key is not an array", () => {
+    expect(find({ items: "not an array" }, "items[last]")).toBeUndefined();
+    expect(find({ items: 5 }, "items[last]")).toBeUndefined();
+    expect(find({ items: null }, "items[last]")).toBeUndefined();
+  });
+
+  it("returns undefined for an empty array", () => {
+    expect(find({ items: [] }, "items[last]")).toBeUndefined();
+  });
+
+  it("still resolves a numeric accessor", () => {
+    expect(find({ items: ["a", "b"] }, "items[0]")).toBe("a");
+    expect(find({ items: ["a", "b"] }, "items[9]")).toBeUndefined();
+  });
+});
+
+describe("replaceValueInPlace — unresolved references", () => {
+  it("leaves the braces in place, which is what the builder warns about", () => {
+    expect(
+      VMUtil.replaceValueInPlace(
+        makeStorage({}),
+        "hello {{local.variables.missing}}",
+        false,
+      ),
+    ).toBe("hello {{local.variables.missing}}");
+  });
+
+  it("does not resolve a reference padded with spaces", () => {
+    expect(
+      VMUtil.replaceValueInPlace(
+        makeStorage({ v: "x" }),
+        "a {{ local.variables.v }} b",
+        false,
+      ),
+    ).toBe("a {{ local.variables.v }} b");
+  });
+});