@oneuptime/common 12.0.8 → 12.0.9

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

@@ -1,7 +1,9 @@
-import TelemetryEntity, {
+import InventoryItem, {
   EntityAttributes,
+  EntityExtractionResult,
   ExtractedEntity,
   ResourceEntityRef,
+  RetiredEntityIdentity,
 } from "../../../../Server/Utils/Telemetry/TelemetryEntity";
 import EntityType from "../../../../Types/Telemetry/EntityType";
 import {
@@ -21,11 +23,11 @@ function keysFor(
   attrs: EntityAttributes,
   projectId: string = PROJECT,
 ): Array<string> {
-  return TelemetryEntity.extractEntityKeys({ projectId, attributes: attrs });
+  return InventoryItem.extractEntityKeys({ projectId, attributes: attrs });
 }
 
 function typesFor(attrs: EntityAttributes): Array<EntityType> {
-  return TelemetryEntity.extractEntities({
+  return InventoryItem.extractEntities({
     projectId: PROJECT,
     attributes: attrs,
   }).map((e: ExtractedEntity) => {
@@ -37,7 +39,7 @@ function entityOfType(
   attrs: EntityAttributes,
   type: EntityType,
 ): ExtractedEntity | undefined {
-  return TelemetryEntity.extractEntities({
+  return InventoryItem.extractEntities({
     projectId: PROJECT,
     attributes: attrs,
   }).find((e: ExtractedEntity) => {
@@ -68,9 +70,9 @@ function expectedKey(
     .slice(0, 16);
 }
 
-describe("TelemetryEntity.computeEntityKey", () => {
+describe("InventoryItem.computeEntityKey", () => {
   test("matches the documented preimage format", () => {
-    const key: string = TelemetryEntity.computeEntityKey({
+    const key: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Service,
       identifyingAttributes: { "service.name": "checkout" },
@@ -82,7 +84,7 @@ describe("TelemetryEntity.computeEntityKey", () => {
   });
 
   test("is deterministic and order-independent", () => {
-    const a: string = TelemetryEntity.computeEntityKey({
+    const a: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Service,
       identifyingAttributes: {
@@ -90,7 +92,7 @@ describe("TelemetryEntity.computeEntityKey", () => {
         "service.namespace": "shop",
       },
     });
-    const b: string = TelemetryEntity.computeEntityKey({
+    const b: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Service,
       identifyingAttributes: {
@@ -102,12 +104,12 @@ describe("TelemetryEntity.computeEntityKey", () => {
   });
 
   test("canonicalizes casing and whitespace (no identity fork)", () => {
-    const a: string = TelemetryEntity.computeEntityKey({
+    const a: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Host,
       identifyingAttributes: { "host.name": "Web-1" },
     });
-    const b: string = TelemetryEntity.computeEntityKey({
+    const b: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Host,
       identifyingAttributes: { "host.name": "  web-1 " },
@@ -116,12 +118,12 @@ describe("TelemetryEntity.computeEntityKey", () => {
   });
 
   test("is tenant-scoped (projectId folds into the key)", () => {
-    const a: string = TelemetryEntity.computeEntityKey({
+    const a: string = InventoryItem.computeEntityKey({
       projectId: "projA",
       entityType: EntityType.Service,
       identifyingAttributes: { "service.name": "checkout" },
     });
-    const b: string = TelemetryEntity.computeEntityKey({
+    const b: string = InventoryItem.computeEntityKey({
       projectId: "projB",
       entityType: EntityType.Service,
       identifyingAttributes: { "service.name": "checkout" },
@@ -130,12 +132,12 @@ describe("TelemetryEntity.computeEntityKey", () => {
   });
 
   test("type discriminates the key (same value, different type)", () => {
-    const asService: string = TelemetryEntity.computeEntityKey({
+    const asService: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Service,
       identifyingAttributes: { name: "x" },
     });
-    const asHost: string = TelemetryEntity.computeEntityKey({
+    const asHost: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Host,
       identifyingAttributes: { name: "x" },
@@ -144,7 +146,7 @@ describe("TelemetryEntity.computeEntityKey", () => {
   });
 });
 
-describe("TelemetryEntity.extractEntities — per type", () => {
+describe("InventoryItem.extractEntities — per type", () => {
   test("service: from service.name, folds in namespace", () => {
     const e: ExtractedEntity | undefined = entityOfType(
       { "service.name": "checkout", "service.namespace": "shop" },
@@ -191,6 +193,99 @@ describe("TelemetryEntity.extractEntities — per type", () => {
     expect(typesFor({ "host.id": "h-123" })).not.toContain(EntityType.Host);
   });
 
+  test("host: a standalone host identity still produces a host", () => {
+    expect(
+      typesFor({
+        "host.name": "web-1",
+        "os.type": "linux",
+      }),
+    ).toEqual([EntityType.Host]);
+  });
+
+  test.each([
+    ["pod name", "k8s.pod.name", "checkout-7d9f", EntityType.KubernetesPod],
+    ["pod uid", "k8s.pod.uid", "pod-uid-1", EntityType.KubernetesPod],
+    ["node name", "k8s.node.name", "worker-1", EntityType.KubernetesNode],
+    ["node uid", "k8s.node.uid", "node-uid-1", EntityType.KubernetesNode],
+    ["cluster", "k8s.cluster.name", "prod-us", EntityType.KubernetesCluster],
+    ["namespace", "k8s.namespace.name", "shop", EntityType.KubernetesNamespace],
+    [
+      "deployment",
+      "k8s.deployment.name",
+      "checkout",
+      EntityType.KubernetesDeployment,
+    ],
+  ] as Array<[string, string, string, EntityType]>)(
+    "host.name beside a k8s %s identity does not create a phantom host",
+    (
+      _label: string,
+      identityKey: string,
+      identityValue: string,
+      expectedType: EntityType,
+    ) => {
+      const types: Array<EntityType> = typesFor({
+        "host.name": "checkout-7d9f",
+        "os.type": "linux",
+        [identityKey]: identityValue,
+      });
+
+      expect(types).toContain(expectedType);
+      expect(types).not.toContain(EntityType.Host);
+    },
+  );
+
+  test("a cluster UID alone does not hide a real host", () => {
+    const types: Array<EntityType> = typesFor({
+      "host.name": "web-1",
+      "os.type": "linux",
+      "k8s.cluster.uid": "cluster-uid-1",
+    });
+
+    /*
+     * Cluster rows are intentionally name-keyed, so a UID-only resource
+     * cannot produce a KubernetesCluster entity. Without an attachable
+     * Kubernetes entity, the UID must not suppress an otherwise valid Host.
+     */
+    expect(types).not.toContain(EntityType.KubernetesCluster);
+    expect(types).toEqual([EntityType.Host]);
+  });
+
+  test.each([
+    "k8s.cluster.name",
+    "k8s.cluster.uid",
+    "k8s.namespace.name",
+    "k8s.node.name",
+    "k8s.node.uid",
+    "k8s.pod.name",
+    "k8s.pod.uid",
+    "k8s.deployment.name",
+  ])("a blank %s value does not hide a real host", (identityKey: string) => {
+    expect(
+      typesFor({
+        "host.name": "web-1",
+        "os.type": "linux",
+        [identityKey]: "   ",
+      }),
+    ).toEqual([EntityType.Host]);
+  });
+
+  test.each([
+    ["k8s.pod.phase", "Running"],
+    ["k8s.pod.label.app", "checkout"],
+    ["k8s.wombat", "future-metadata"],
+  ])(
+    "an unrelated Kubernetes attribute %s does not hide a real host",
+    (attributeKey: string, attributeValue: string) => {
+      expect(
+        typesFor({
+          "host.name": "web-1",
+          "os.type": "linux",
+          [attributeKey]: attributeValue,
+        }),
+      ).toEqual([EntityType.Host]);
+    },
+  );
+
   test("k8s.cluster: keyed on name only, ignoring uid (read side is name-based)", () => {
     const e: ExtractedEntity | undefined = entityOfType(
       { "k8s.cluster.uid": "u-1", "k8s.cluster.name": "prod-us" },
@@ -352,14 +447,14 @@ describe("TelemetryEntity.extractEntities — per type", () => {
   });
 });
 
-describe("TelemetryEntity.extractEntities — composition & safety", () => {
+describe("InventoryItem.extractEntities — composition & safety", () => {
   test("no phantom entities when identity is absent", () => {
     expect(keysFor({})).toEqual([]);
     // host.* missing, only an unrelated attr present
     expect(typesFor({ "http.method": "GET" })).toEqual([]);
   });
 
-  test("a full k8s resource yields the whole entity set", () => {
+  test("a full k8s resource yields its proper entity set without a phantom host", () => {
     const types: Array<EntityType> = typesFor({
       "service.name": "checkout",
       "service.instance.id": "i-1",
@@ -377,7 +472,6 @@ describe("TelemetryEntity.extractEntities — composition & safety", () => {
       new Set([
         EntityType.Service,
         EntityType.ServiceInstance,
-        EntityType.Host,
         EntityType.KubernetesCluster,
         EntityType.KubernetesNamespace,
         EntityType.KubernetesNode,
@@ -418,7 +512,7 @@ describe("TelemetryEntity.extractEntities — composition & safety", () => {
     // deduped
     expect(new Set(keys).size).toBe(keys.length);
     // includes the service (primary) key
-    const serviceKey: string = TelemetryEntity.computeEntityKey({
+    const serviceKey: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.Service,
       identifyingAttributes: { "service.name": "checkout" },
@@ -427,7 +521,7 @@ describe("TelemetryEntity.extractEntities — composition & safety", () => {
   });
 
   test("same namespace name in two clusters does not collide", () => {
-    const clusterA: string = TelemetryEntity.computeEntityKey({
+    const clusterA: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.KubernetesNamespace,
       identifyingAttributes: {
@@ -435,7 +529,7 @@ describe("TelemetryEntity.extractEntities — composition & safety", () => {
         "k8s.namespace.name": "default",
       },
     });
-    const clusterB: string = TelemetryEntity.computeEntityKey({
+    const clusterB: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.KubernetesNamespace,
       identifyingAttributes: {
@@ -447,7 +541,7 @@ describe("TelemetryEntity.extractEntities — composition & safety", () => {
   });
 
   test("same vmid in two proxmox clusters does not collide", () => {
-    const clusterA: string = TelemetryEntity.computeEntityKey({
+    const clusterA: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.ProxmoxGuest,
       identifyingAttributes: {
@@ -455,7 +549,7 @@ describe("TelemetryEntity.extractEntities — composition & safety", () => {
         "proxmox.guest.vmid": "100",
       },
     });
-    const clusterB: string = TelemetryEntity.computeEntityKey({
+    const clusterB: string = InventoryItem.computeEntityKey({
       projectId: PROJECT,
       entityType: EntityType.ProxmoxGuest,
       identifyingAttributes: {
@@ -633,10 +727,60 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
       EntityType.KubernetesNode,
     );
     expect(e!.descriptiveAttributes).toEqual({
+      "k8s.node.name": "node-1",
       "node.kubernetes.io/instance-type": "n2-standard-4",
     });
   });
 
+  test.each([
+    {
+      label: "pod",
+      type: EntityType.KubernetesPod,
+      uidKey: "k8s.pod.uid",
+      uid: "pod-uid-1",
+      nameKey: "k8s.pod.name",
+      name: "checkout-7d9f",
+    },
+    {
+      label: "node",
+      type: EntityType.KubernetesNode,
+      uidKey: "k8s.node.uid",
+      uid: "node-uid-1",
+      nameKey: "k8s.node.name",
+      name: "worker-1",
+    },
+  ])(
+    "k8s.$label: keeps the stable UID identity and carries the name descriptively",
+    ({
+      type,
+      uidKey,
+      uid,
+      nameKey,
+      name,
+    }: {
+      label: string;
+      type: EntityType;
+      uidKey: string;
+      uid: string;
+      nameKey: string;
+      name: string;
+    }) => {
+      const uidOnly: ExtractedEntity | undefined = entityOfType(
+        { [uidKey]: uid },
+        type,
+      );
+      const named: ExtractedEntity | undefined = entityOfType(
+        { [uidKey]: uid, [nameKey]: name },
+        type,
+      );
+
+      expect(named).toBeDefined();
+      expect(named!.entityKey).toBe(uidOnly!.entityKey);
+      expect(named!.identifyingAttributes).toEqual({ [uidKey]: uid });
+      expect(named!.descriptiveAttributes).toEqual({ [nameKey]: name });
+    },
+  );
+
   test("container: image name/tag descriptive; array-valued tags accepted", () => {
     const e: ExtractedEntity | undefined = entityOfType(
       {
@@ -720,7 +864,7 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
   });
 
   test("oneuptime.label.* suffixes become labels on every extracted entity", () => {
-    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId: PROJECT,
       attributes: {
         "service.name": "checkout",
@@ -746,6 +890,162 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
   });
 });
 
+describe("extractEntitiesWithRetirements — legacy Kubernetes Host repair", () => {
+  test.each([
+    ["pod name", "k8s.pod.name", "checkout-7d9f"],
+    ["pod uid", "k8s.pod.uid", "pod-uid-1"],
+    ["node name", "k8s.node.name", "worker-1"],
+    ["node uid", "k8s.node.uid", "node-uid-1"],
+    ["cluster name", "k8s.cluster.name", "prod-us"],
+    ["namespace name", "k8s.namespace.name", "shop"],
+    ["deployment name", "k8s.deployment.name", "checkout"],
+  ])(
+    "returns the exact suppressed Host identity beside a Kubernetes %s identity",
+    (_label: string, identityKey: string, identityValue: string) => {
+      const result: EntityExtractionResult =
+        InventoryItem.extractEntitiesWithRetirements({
+          projectId: PROJECT,
+          attributes: {
+            "host.name": "  CHECKOUT-7D9F  ",
+            [identityKey]: identityValue,
+          },
+        });
+
+      expect(result.entities).not.toContainEqual(
+        expect.objectContaining({ entityType: EntityType.Host }),
+      );
+      expect(result.retiredEntities).toEqual([
+        {
+          entityType: EntityType.Host,
+          entityKey: keyForHost(PROJECT, "checkout-7d9f"),
+          identifyingAttributes: { "host.name": "checkout-7d9f" },
+        },
+      ]);
+    },
+  );
+
+  test("an empty entity_refs array remains heuristic and permits repair", () => {
+    const result: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: {
+          "host.name": "checkout-7d9f",
+          "k8s.pod.uid": "pod-uid-1",
+        },
+        entityRefs: [],
+      });
+
+    expect(result.retiredEntities?.[0]?.entityKey).toBe(
+      keyForHost(PROJECT, "checkout-7d9f"),
+    );
+  });
+
+  test.each([
+    ["standalone host", { "host.name": "web-1", "os.type": "linux" }],
+    ["host without a name", { "host.id": "h-1", "k8s.pod.uid": "p-1" }],
+    ["blank Kubernetes identity", { "host.name": "web-1", "k8s.pod.uid": " " }],
+    [
+      "unrelated Kubernetes metadata",
+      { "host.name": "web-1", "k8s.pod.phase": "Running" },
+    ],
+    [
+      "unsupported cluster UID alone",
+      { "host.name": "web-1", "k8s.cluster.uid": "c-1" },
+    ],
+  ] as Array<[string, EntityAttributes]>)(
+    "does not retire a %s",
+    (_label: string, attributes: EntityAttributes) => {
+      const result: EntityExtractionResult =
+        InventoryItem.extractEntitiesWithRetirements({
+          projectId: PROJECT,
+          attributes,
+        });
+
+      expect(result.retiredEntities).toBeUndefined();
+    },
+  );
+
+  test("an explicit Host ref on Kubernetes is authoritative and never retired", () => {
+    const result: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: {
+          "host.name": "checkout-7d9f",
+          "k8s.pod.uid": "pod-uid-1",
+        },
+        entityRefs: [{ type: "host", idKeys: ["host.name"] }],
+      });
+
+    expect(result.entities).toEqual([
+      expect.objectContaining({
+        entityType: EntityType.Host,
+        entityKey: keyForHost(PROJECT, "checkout-7d9f"),
+      }),
+    ]);
+    expect(result.retiredEntities).toBeUndefined();
+  });
+
+  test("any non-empty entity_refs authority boundary disables inferred repair", () => {
+    const result: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: {
+          "service.name": "checkout",
+          "host.name": "checkout-7d9f",
+          "k8s.pod.uid": "pod-uid-1",
+        },
+        entityRefs: [{ type: "service", idKeys: ["service.name"] }],
+      });
+
+    expect(result.retiredEntities).toBeUndefined();
+  });
+
+  test("even unusable non-empty refs disable retirement while entity fallback remains", () => {
+    const debugSpy: jest.SpyInstance = jest
+      .spyOn(logger, "debug")
+      .mockImplementation(() => {});
+    try {
+      const result: EntityExtractionResult =
+        InventoryItem.extractEntitiesWithRetirements({
+          projectId: PROJECT,
+          attributes: {
+            "host.name": "checkout-7d9f",
+            "k8s.pod.uid": "pod-uid-1",
+          },
+          entityRefs: [{ type: "unknown.widget", idKeys: ["missing"] }],
+        });
+
+      expect(result.entities).toContainEqual(
+        expect.objectContaining({ entityType: EntityType.KubernetesPod }),
+      );
+      expect(result.retiredEntities).toBeUndefined();
+    } finally {
+      debugSpy.mockRestore();
+    }
+  });
+
+  test("the retired Host key remains tenant-scoped", () => {
+    const attributes: EntityAttributes = {
+      "host.name": "checkout-7d9f",
+      "k8s.pod.uid": "pod-uid-1",
+    };
+    const first: RetiredEntityIdentity =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: "project-a",
+        attributes,
+      }).retiredEntities![0]!;
+    const second: RetiredEntityIdentity =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: "project-b",
+        attributes,
+      }).retiredEntities![0]!;
+
+    expect(first.entityKey).not.toBe(second.entityKey);
+    expect(first.entityKey).toBe(keyForHost("project-a", "checkout-7d9f"));
+    expect(second.entityKey).toBe(keyForHost("project-b", "checkout-7d9f"));
+  });
+});
+
 describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
   const attrs: EntityAttributes = {
     "service.name": "checkout",
@@ -755,7 +1055,7 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
   };
 
   test("builds entities from refs instead of the heuristics", () => {
-    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId: PROJECT,
       attributes: attrs,
       entityRefs: [
@@ -794,12 +1094,29 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
     expect(host.entityKey).toBe(keyForHost(PROJECT, "web-1"));
   });
 
+  test("an explicit host ref remains authoritative on a Kubernetes resource", () => {
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
+      projectId: PROJECT,
+      attributes: {
+        "host.name": "checkout-7d9f",
+        "k8s.cluster.name": "prod-us",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "checkout-7d9f",
+      },
+      entityRefs: [{ type: "host", idKeys: ["host.name"] }],
+    });
+
+    expect(entities).toHaveLength(1);
+    expect(entities[0]!.entityType).toBe(EntityType.Host);
+    expect(entities[0]!.entityKey).toBe(keyForHost(PROJECT, "checkout-7d9f"));
+  });
+
   test("unknown ref types are skipped (debug log), known refs still built", () => {
     const debugSpy: jest.SpyInstance = jest
       .spyOn(logger, "debug")
       .mockImplementation(() => {});
     try {
-      const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
         projectId: PROJECT,
         attributes: attrs,
         entityRefs: [
@@ -819,7 +1136,7 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
   });
 
   test("a ref whose identifying value is missing from the resource is skipped", () => {
-    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId: PROJECT,
       attributes: attrs,
       entityRefs: [
@@ -836,13 +1153,13 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
   });
 
   test("absent or empty refs fall back to the heuristic resolvers", () => {
-    const heuristic: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const heuristic: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId: PROJECT,
       attributes: attrs,
     });
     expect(heuristic.length).toBeGreaterThan(0);
     expect(
-      TelemetryEntity.extractEntities({
+      InventoryItem.extractEntities({
         projectId: PROJECT,
         attributes: attrs,
         entityRefs: [],
@@ -855,13 +1172,13 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
       .spyOn(logger, "debug")
       .mockImplementation(() => {});
     try {
-      const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
         projectId: PROJECT,
         attributes: attrs,
         entityRefs: [{ type: "acme.custom.widget", idKeys: ["whatever"] }],
       });
       expect(entities).toEqual(
-        TelemetryEntity.extractEntities({
+        InventoryItem.extractEntities({
           projectId: PROJECT,
           attributes: attrs,
         }),
@@ -876,7 +1193,7 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
       .spyOn(logger, "warn")
       .mockImplementation(() => {});
     try {
-      const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
         projectId: PROJECT,
         attributes: {
           "container.id": "c-1",
@@ -902,7 +1219,7 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
   });
 
   test("labels attach on the refs path too", () => {
-    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+    const entities: Array<ExtractedEntity> = InventoryItem.extractEntities({
       projectId: PROJECT,
       attributes: { ...attrs, "oneuptime.label.team": "payments" },
       entityRefs: [{ type: "service", idKeys: ["service.name"] }],
@@ -912,9 +1229,9 @@ describe("extractEntities — OTLP entity_refs (authoritative path)", () => {
   });
 });
 
-describe("TelemetryEntity.parseEntityRefs", () => {
+describe("InventoryItem.parseEntityRefs", () => {
   test("normalizes camelCase and snake_case shapes; drops malformed entries", () => {
-    const refs: Array<ResourceEntityRef> = TelemetryEntity.parseEntityRefs([
+    const refs: Array<ResourceEntityRef> = InventoryItem.parseEntityRefs([
       {
         type: "service",
         idKeys: ["service.name"],
@@ -949,9 +1266,9 @@ describe("TelemetryEntity.parseEntityRefs", () => {
   });
 
   test("non-array input yields no refs", () => {
-    expect(TelemetryEntity.parseEntityRefs(undefined)).toEqual([]);
-    expect(TelemetryEntity.parseEntityRefs(null)).toEqual([]);
-    expect(TelemetryEntity.parseEntityRefs({})).toEqual([]);
-    expect(TelemetryEntity.parseEntityRefs("nope")).toEqual([]);
+    expect(InventoryItem.parseEntityRefs(undefined)).toEqual([]);
+    expect(InventoryItem.parseEntityRefs(null)).toEqual([]);
+    expect(InventoryItem.parseEntityRefs({})).toEqual([]);
+    expect(InventoryItem.parseEntityRefs("nope")).toEqual([]);
   });
 });