@oneuptime/common 10.8.1 → 11.0.0

package/Tests/Types/Monitor/MonitorStepEntityScope.test.ts

@@ -0,0 +1,275 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import Log from "../../../Models/AnalyticsModels/Log";
+import Span from "../../../Models/AnalyticsModels/Span";
+import ExceptionInstance from "../../../Models/AnalyticsModels/ExceptionInstance";
+import Profile from "../../../Models/AnalyticsModels/Profile";
+import Metric from "../../../Models/AnalyticsModels/Metric";
+import MonitorStepLogMonitor, {
+  MonitorStepLogMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepLogMonitor";
+import MonitorStepTraceMonitor, {
+  MonitorStepTraceMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepTraceMonitor";
+import MonitorStepExceptionMonitor, {
+  MonitorStepExceptionMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepExceptionMonitor";
+import MonitorStepProfileMonitor, {
+  MonitorStepProfileMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepProfileMonitor";
+import MonitorStepMetricMonitor, {
+  MonitorStepMetricMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * Entity scoping on telemetry monitor steps (entityKeys -> hasAny membership
+ * predicate). The contract these tests lock in:
+ *
+ *   1. Backward compatibility — monitors saved before the field existed
+ *      deserialize with no entityKeys (or an empty array), and the query
+ *      compile treats undefined/empty as a strict no-op (no `entityKeys`
+ *      predicate in the generated Query<Model>).
+ *   2. When 1+ keys are present, the compile emits an Includes on the
+ *      `entityKeys` column, which StatementGenerator turns into
+ *      hasAny(entityKeys, [...]) for Array(String) columns.
+ */
+
+const TWO_KEYS: Array<string> = ["a1b2c3d4e5f60708", "1122334455667788"];
+
+type ExpectIncludesFunction = (
+  value: unknown,
+  expectedKeys: Array<string>,
+) => void;
+
+const expectIncludes: ExpectIncludesFunction = (
+  value: unknown,
+  expectedKeys: Array<string>,
+): void => {
+  expect(value).toBeInstanceOf(Includes);
+  expect((value as Includes).values).toEqual(expectedKeys);
+};
+
+describe("MonitorStepLogMonitorUtil.toQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined (pre-existing saved monitors)", () => {
+    const step: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+    expect(Object.keys(query)).not.toContain("entityKeys");
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepLogMonitor = MonitorStepLogMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Log> = MonitorStepLogMonitorUtil.toQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON tolerates legacy JSON without entityKeys and round-trips keys", () => {
+    const legacyJson: JSONObject = MonitorStepLogMonitorUtil.toJSON(
+      MonitorStepLogMonitorUtil.getDefault(),
+    );
+    delete legacyJson["entityKeys"];
+
+    const legacyStep: MonitorStepLogMonitor =
+      MonitorStepLogMonitorUtil.fromJSON(legacyJson);
+    expect(legacyStep.entityKeys).toEqual([]);
+
+    const stepWithKeys: MonitorStepLogMonitor =
+      MonitorStepLogMonitorUtil.getDefault();
+    stepWithKeys.entityKeys = TWO_KEYS;
+
+    const roundTripped: MonitorStepLogMonitor =
+      MonitorStepLogMonitorUtil.fromJSON(
+        MonitorStepLogMonitorUtil.toJSON(stepWithKeys),
+      );
+    expect(roundTripped.entityKeys).toEqual(TWO_KEYS);
+  });
+});
+
+describe("MonitorStepTraceMonitorUtil.toQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined", () => {
+    const step: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Span> = MonitorStepTraceMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Span> = MonitorStepTraceMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Span> = MonitorStepTraceMonitorUtil.toQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON tolerates legacy JSON without entityKeys", () => {
+    const legacyJson: JSONObject = MonitorStepTraceMonitorUtil.toJSON(
+      MonitorStepTraceMonitorUtil.getDefault(),
+    );
+    delete legacyJson["entityKeys"];
+
+    const legacyStep: MonitorStepTraceMonitor =
+      MonitorStepTraceMonitorUtil.fromJSON(legacyJson);
+    expect(legacyStep.entityKeys).toEqual([]);
+  });
+});
+
+describe("MonitorStepExceptionMonitorUtil.toAnalyticsQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined", () => {
+    const step: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<ExceptionInstance> =
+      MonitorStepExceptionMonitorUtil.toAnalyticsQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<ExceptionInstance> =
+      MonitorStepExceptionMonitorUtil.toAnalyticsQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<ExceptionInstance> =
+      MonitorStepExceptionMonitorUtil.toAnalyticsQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON tolerates legacy JSON without entityKeys", () => {
+    const legacyJson: JSONObject = MonitorStepExceptionMonitorUtil.toJSON(
+      MonitorStepExceptionMonitorUtil.getDefault(),
+    );
+    delete legacyJson["entityKeys"];
+
+    const legacyStep: MonitorStepExceptionMonitor =
+      MonitorStepExceptionMonitorUtil.fromJSON(legacyJson);
+    expect(legacyStep.entityKeys).toEqual([]);
+  });
+});
+
+describe("MonitorStepProfileMonitorUtil.toQuery entity scoping", () => {
+  test("omits entityKeys predicate when field is undefined", () => {
+    const step: MonitorStepProfileMonitor =
+      MonitorStepProfileMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("omits entityKeys predicate when field is an empty array", () => {
+    const step: MonitorStepProfileMonitor =
+      MonitorStepProfileMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("compiles two entity keys to an Includes on entityKeys", () => {
+    const step: MonitorStepProfileMonitor =
+      MonitorStepProfileMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(step);
+
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+});
+
+describe("MonitorStepMetricMonitorUtil.applyEntityScopeToQuery", () => {
+  test("is a no-op when entityKeys is undefined (pre-existing saved monitors)", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    delete step.entityKeys;
+
+    const query: Query<Metric> = {};
+    MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
+
+    expect(query.entityKeys).toBeUndefined();
+    expect(Object.keys(query)).toHaveLength(0);
+  });
+
+  test("is a no-op when entityKeys is an empty array", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    step.entityKeys = [];
+
+    const query: Query<Metric> = {};
+    MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
+
+    expect(query.entityKeys).toBeUndefined();
+  });
+
+  test("stamps an Includes on entityKeys for two keys and preserves other predicates", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const query: Query<Metric> = { name: "cpu.usage" };
+    const returned: Query<Metric> =
+      MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
+
+    expect(returned).toBe(query);
+    expect(query.name).toBe("cpu.usage");
+    expectIncludes(query.entityKeys, TWO_KEYS);
+  });
+
+  test("fromJSON preserves entityKeys (pass-through serialization)", () => {
+    const step: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+    step.entityKeys = TWO_KEYS;
+
+    const roundTripped: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON(
+        MonitorStepMetricMonitorUtil.toJSON(step),
+      );
+
+    expect(roundTripped.entityKeys).toEqual(TWO_KEYS);
+  });
+});

package/Tests/Types/Text.test.ts

@@ -5,4 +5,56 @@ describe("class Text", () => {
     expect(Text.uppercaseFirstLetter("text")).toEqual("Text");
     expect(Text.uppercaseFirstLetter("another test")).toEqual("Another test");
   });
+
+  describe("Text.convertOtlpIdToHex", () => {
+    test("passes 32-char hex trace ids through, normalised to lowercase", () => {
+      const hexTraceId: string = "4BF92F3577B34DA6A3CE929D0E0E4736";
+      expect(Text.convertOtlpIdToHex(hexTraceId)).toEqual(
+        "4bf92f3577b34da6a3ce929d0e0e4736",
+      );
+      expect(
+        Text.convertOtlpIdToHex("4bf92f3577b34da6a3ce929d0e0e4736"),
+      ).toEqual("4bf92f3577b34da6a3ce929d0e0e4736");
+    });
+
+    test("passes 16-char hex span ids through, normalised to lowercase", () => {
+      expect(Text.convertOtlpIdToHex("00F067AA0BA902B7")).toEqual(
+        "00f067aa0ba902b7",
+      );
+    });
+
+    test("decodes base64 ids (the OTLP/protobuf wire form) to hex", () => {
+      // 16-byte trace id -> 24-char base64 -> 32-char hex
+      const traceIdBytes: Buffer = Buffer.from(
+        "4bf92f3577b34da6a3ce929d0e0e4736",
+        "hex",
+      );
+      expect(Text.convertOtlpIdToHex(traceIdBytes.toString("base64"))).toEqual(
+        "4bf92f3577b34da6a3ce929d0e0e4736",
+      );
+
+      // 8-byte span id -> 12-char base64 -> 16-char hex
+      const spanIdBytes: Buffer = Buffer.from("00f067aa0ba902b7", "hex");
+      expect(Text.convertOtlpIdToHex(spanIdBytes.toString("base64"))).toEqual(
+        "00f067aa0ba902b7",
+      );
+    });
+
+    test("returns empty string for missing ids", () => {
+      expect(Text.convertOtlpIdToHex(undefined)).toEqual("");
+      expect(Text.convertOtlpIdToHex("")).toEqual("");
+    });
+
+    test("hex detection requires the exact id lengths — other hex-looking strings still take the base64 path", () => {
+      /*
+       * A 24-char hex-only string is a valid base64 payload and is NOT
+       * an OTLP hex id (ids are exactly 16 or 32 chars), so it must be
+       * treated as base64 — same behaviour as convertBase64ToHex.
+       */
+      const ambiguous: string = "abcdefabcdefabcdefabcdef";
+      expect(Text.convertOtlpIdToHex(ambiguous)).toEqual(
+        Text.convertBase64ToHex(ambiguous),
+      );
+    });
+  });
 });

package/Tests/Utils/Telemetry/EntityKey.test.ts

@@ -0,0 +1,150 @@
+import {
+  canonicalizeEntityValue,
+  computeEntityKey,
+  keyForService,
+  setSha256Provider,
+} from "../../../Utils/Telemetry/EntityKey";
+import Crypto from "../../../Utils/Crypto";
+import EntityType from "../../../Types/Telemetry/EntityType";
+import { describe, expect, test } from "@jest/globals";
+import { createHash } from "crypto";
+import CryptoJS from "crypto-js";
+
+const PROJECT: string = "proj1";
+
+describe("canonicalizeEntityValue", () => {
+  test("trims and lowercases", () => {
+    expect(canonicalizeEntityValue("  Web-1 ")).toBe("web-1");
+    expect(canonicalizeEntityValue("PRIMARY01")).toBe("primary01");
+  });
+
+  test("undefined coerces to empty string", () => {
+    expect(canonicalizeEntityValue(undefined)).toBe("");
+  });
+});
+
+describe("computeEntityKey — preimage escaping", () => {
+  test("values containing separators do not collide with structurally different identity sets", () => {
+    /*
+     * Without escaping, both would build the preimage
+     * `proj1|service|service.name=a|service.namespace=b`.
+     */
+    const smuggled: string = computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.Service,
+      identifyingAttributes: { "service.name": "a|service.namespace=b" },
+    });
+    const split: string = computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.Service,
+      identifyingAttributes: {
+        "service.name": "a",
+        "service.namespace": "b",
+      },
+    });
+    expect(smuggled).not.toBe(split);
+  });
+
+  test("the escape character itself is escaped (no backslash smuggling)", () => {
+    /*
+     * A literal backslash in a value must be doubled in the preimage, so a
+     * trailing backslash cannot masquerade as an escape of the following
+     * separator.
+     */
+    const trailingBackslash: string = computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.Service,
+      identifyingAttributes: { a: "x\\", b: "y" },
+    });
+    expect(trailingBackslash).toBe(
+      createHash("sha256")
+        .update("proj1|service|a=x\\\\|b=y")
+        .digest("hex")
+        .slice(0, 16),
+    );
+    const literalSeparators: string = computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.Service,
+      identifyingAttributes: { a: "x\\|b=y" },
+    });
+    expect(trailingBackslash).not.toBe(literalSeparators);
+  });
+
+  test("normal values keep the historical preimage (already-stamped keys unchanged)", () => {
+    const key: string = computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.Service,
+      identifyingAttributes: { "service.name": "checkout" },
+    });
+    // Unescaped preimage, exactly as stamped before escaping existed.
+    const historical: string = createHash("sha256")
+      .update("proj1|service|service.name=checkout")
+      .digest("hex")
+      .slice(0, 16);
+    expect(key).toBe(historical);
+    /*
+     * Pinned so any preimage drift (separator, ordering, hash, slice
+     * length) fails loudly — this exact key is stamped in ClickHouse rows.
+     */
+    expect(key).toBe("904989abd67aec3f");
+    expect(keyForService(PROJECT, "checkout")).toBe("904989abd67aec3f");
+  });
+});
+
+describe("sha256 provider injection", () => {
+  test("node:crypto and crypto-js produce identical hex for the same input", () => {
+    const inputs: Array<string> = [
+      "proj1|service|service.name=checkout",
+      "projB|k8s.cluster|k8s.cluster.name=prod-us",
+      "p|host|host.name=ünïcode-höst",
+    ];
+    for (const input of inputs) {
+      expect(CryptoJS.SHA256(input).toString()).toBe(
+        createHash("sha256").update(input).digest("hex"),
+      );
+    }
+  });
+
+  test("setSha256Provider is honored by computeEntityKey", () => {
+    try {
+      setSha256Provider(() => {
+        return "f".repeat(64);
+      });
+      expect(
+        computeEntityKey({
+          projectId: PROJECT,
+          entityType: EntityType.Host,
+          identifyingAttributes: { "host.name": "web-1" },
+        }),
+      ).toBe("f".repeat(16));
+    } finally {
+      setSha256Provider((input: string) => {
+        return Crypto.getSha256Hash(input);
+      });
+    }
+  });
+
+  test("swapping in the node:crypto provider does not change keys", () => {
+    const before: string = computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.Host,
+      identifyingAttributes: { "host.name": "web-1" },
+    });
+    try {
+      setSha256Provider((input: string) => {
+        return createHash("sha256").update(input).digest("hex");
+      });
+      expect(
+        computeEntityKey({
+          projectId: PROJECT,
+          entityType: EntityType.Host,
+          identifyingAttributes: { "host.name": "web-1" },
+        }),
+      ).toBe(before);
+    } finally {
+      setSha256Provider((input: string) => {
+        return Crypto.getSha256Hash(input);
+      });
+    }
+  });
+});

package/Tests/Utils/Telemetry/EntityKeySqlParity.test.ts

@@ -0,0 +1,40 @@
+import { keyForHost } from "../../../Utils/Telemetry/EntityKey";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Pins keyForHost against the ClickHouse SQL formula used by the
+ * RekeyMetricHostRollupToEntityKey migration to backfill
+ * MetricItemAggMV1mByHostV2 from the old hostIdentifier-keyed rollup:
+ *
+ *   substring(lower(hex(SHA256(concat(
+ *     projectId, '|host|host.name=', lower(trimBoth(hostIdentifier))
+ *   )))), 1, 16)
+ *
+ * The expected values below are the literal outputs of that SQL run on a
+ * live ClickHouse (25.7) — if keyForHost's canonicalization, preimage
+ * layout, hash, or slice length ever drifts, this fails loudly and the
+ * backfilled rollup rows stop matching ingest-stamped hostEntityKeys.
+ *
+ * (Hostnames containing '\\', '|' or '=' are escaped by keyForHost but
+ * not by the SQL — a documented, vanishingly-rare caveat of the backfill,
+ * deliberately not pinned here.)
+ */
+describe("keyForHost — parity with the migration's SQL key computation", () => {
+  test("matches ClickHouse-computed keys for representative hostnames", () => {
+    // [projectId, raw hostIdentifier, SQL-computed key from live ClickHouse]
+    const vectors: Array<[string, string, string]> = [
+      // Mixed case + trailing whitespace exercise canonicalization.
+      ["proj-123", "Web-Server-01 ", "dba90fb9cca1242e"],
+      [
+        "8f3c2a1e-0000-4a4a-9c9c-aabbccddeeff",
+        "ip-10-0-1-23.ec2.internal",
+        "7f5d90eeeeb0b48b",
+      ],
+      ["proj-xyz", "NODE.example.COM", "8825a6c0687b16d9"],
+    ];
+
+    for (const [projectId, hostIdentifier, sqlKey] of vectors) {
+      expect(keyForHost(projectId, hostIdentifier)).toBe(sqlKey);
+    }
+  });
+});

package/Tests/Utils/Telemetry/EntityRelationship.test.ts

@@ -0,0 +1,150 @@
+import {
+  EntityRelationshipEdge,
+  deriveRelationships,
+  inferRelationshipType,
+} from "../../../Utils/Telemetry/EntityRelationship";
+import EntityRelationshipType from "../../../Types/Telemetry/EntityRelationshipType";
+import EntityType from "../../../Types/Telemetry/EntityType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("inferRelationshipType", () => {
+  test("infers documented directed relationships", () => {
+    expect(
+      inferRelationshipType(
+        EntityType.KubernetesPod,
+        EntityType.KubernetesNode,
+      ),
+    ).toBe(EntityRelationshipType.RunsOn);
+    expect(
+      inferRelationshipType(
+        EntityType.KubernetesPod,
+        EntityType.KubernetesCluster,
+      ),
+    ).toBe(EntityRelationshipType.MemberOf);
+    expect(inferRelationshipType(EntityType.Service, EntityType.Host)).toBe(
+      EntityRelationshipType.HostedOn,
+    );
+    expect(
+      inferRelationshipType(EntityType.Container, EntityType.KubernetesPod),
+    ).toBe(EntityRelationshipType.PartOf);
+    expect(
+      inferRelationshipType(EntityType.ServiceInstance, EntityType.Service),
+    ).toBe(EntityRelationshipType.InstanceOf);
+  });
+
+  test("is directional (the reverse pair yields nothing)", () => {
+    expect(
+      inferRelationshipType(
+        EntityType.KubernetesNode,
+        EntityType.KubernetesPod,
+      ),
+    ).toBeNull();
+    expect(
+      inferRelationshipType(EntityType.Host, EntityType.Service),
+    ).toBeNull();
+  });
+
+  test("unrelated or self type pairs yield null", () => {
+    expect(
+      inferRelationshipType(EntityType.TelemetrySdk, EntityType.Host),
+    ).toBeNull();
+    expect(
+      inferRelationshipType(EntityType.Service, EntityType.Service),
+    ).toBeNull();
+  });
+
+  test("depends-on is never inferred from co-occurrence (span-derived only)", () => {
+    /*
+     * Service → service dependency edges come from cross-service
+     * parent/child span pairs (the ComputeServiceDependencies cron) —
+     * a caller and its callee never share one resource, so no ordered
+     * type pair may ever infer DependsOn.
+     */
+    const types: Array<EntityType> = Object.values(EntityType);
+    for (const fromType of types) {
+      for (const toType of types) {
+        expect(inferRelationshipType(fromType, toType)).not.toBe(
+          EntityRelationshipType.DependsOn,
+        );
+      }
+    }
+  });
+});
+
+describe("EntityRelationshipType", () => {
+  test("pins the depends-on wire value (stored in Postgres rows)", () => {
+    expect(EntityRelationshipType.DependsOn).toBe("depends-on");
+  });
+});
+
+describe("deriveRelationships", () => {
+  function hasEdge(
+    edges: Array<EntityRelationshipEdge>,
+    from: string,
+    to: string,
+    rel: EntityRelationshipType,
+  ): boolean {
+    return edges.some((e: EntityRelationshipEdge) => {
+      return (
+        e.fromEntityKey === from &&
+        e.toEntityKey === to &&
+        e.relationshipType === rel
+      );
+    });
+  }
+
+  test("derives the full directed edge set for a k8s resource", () => {
+    const edges: Array<EntityRelationshipEdge> = deriveRelationships([
+      { entityType: EntityType.Service, entityKey: "svc" },
+      { entityType: EntityType.Host, entityKey: "host" },
+      { entityType: EntityType.KubernetesPod, entityKey: "pod" },
+      { entityType: EntityType.KubernetesNode, entityKey: "node" },
+      { entityType: EntityType.KubernetesCluster, entityKey: "cluster" },
+      { entityType: EntityType.Container, entityKey: "ctr" },
+    ]);
+
+    expect(hasEdge(edges, "svc", "host", EntityRelationshipType.HostedOn)).toBe(
+      true,
+    );
+    expect(hasEdge(edges, "svc", "pod", EntityRelationshipType.RunsOn)).toBe(
+      true,
+    );
+    expect(hasEdge(edges, "pod", "node", EntityRelationshipType.RunsOn)).toBe(
+      true,
+    );
+    expect(
+      hasEdge(edges, "pod", "cluster", EntityRelationshipType.MemberOf),
+    ).toBe(true);
+    expect(
+      hasEdge(edges, "node", "cluster", EntityRelationshipType.MemberOf),
+    ).toBe(true);
+    expect(hasEdge(edges, "ctr", "pod", EntityRelationshipType.PartOf)).toBe(
+      true,
+    );
+    // No reverse edge.
+    expect(hasEdge(edges, "host", "svc", EntityRelationshipType.HostedOn)).toBe(
+      false,
+    );
+  });
+
+  test("empty / single-entity sets produce no edges", () => {
+    expect(deriveRelationships([])).toEqual([]);
+    expect(
+      deriveRelationships([{ entityType: EntityType.Host, entityKey: "h" }]),
+    ).toEqual([]);
+  });
+
+  test("deduplicates repeated entities", () => {
+    const edges: Array<EntityRelationshipEdge> = deriveRelationships([
+      { entityType: EntityType.KubernetesPod, entityKey: "pod" },
+      { entityType: EntityType.KubernetesCluster, entityKey: "cluster" },
+      { entityType: EntityType.KubernetesCluster, entityKey: "cluster" },
+    ]);
+    const memberEdges: Array<EntityRelationshipEdge> = edges.filter(
+      (e: EntityRelationshipEdge) => {
+        return e.relationshipType === EntityRelationshipType.MemberOf;
+      },
+    );
+    expect(memberEdges.length).toBe(1);
+  });
+});