@oneuptime/common 13.0.5 → 13.0.7

package/Tests/Server/Utils/Slo/SloRecordReferenceValidator.test.ts

@@ -0,0 +1,311 @@
+import SloRecordReferenceValidator from "../../../../Server/Utils/Slo/SloRecordReferenceValidator";
+import DatabaseService from "../../../../Server/Services/DatabaseService";
+import QueryHelper from "../../../../Server/Types/Database/QueryHelper";
+import ServiceLevelObjective from "../../../../Models/DatabaseModels/ServiceLevelObjective";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+import fs from "fs";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * Incident.serviceLevelObjectives and Alert.serviceLevelObjectives are
+ * writable by API callers. Nothing in the framework checks that a relation id
+ * belongs to the row's project. An IncidentMember holding another project's
+ * SLO id could therefore link it, and the created feed item, the lists, the AI
+ * context and the metrics would all show that SLO's name inside the caller's
+ * project.
+ *
+ * This validator is what the Incident and Alert write hooks call. The part
+ * that matters most is that its read is pinned to the record's project. The
+ * fake SLO table below answers an unpinned read with the foreign SLO too, so a
+ * validator that dropped the pin would accept it and the rejection tests would
+ * fail. The error must not name the foreign SLO either: that would leak the
+ * same name through the error message.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "0193c0de-dddd-4aaa-8bbb-000000000001",
+);
+const OTHER_PROJECT_ID: ObjectID = new ObjectID(
+  "0193c0de-dddd-4aaa-8bbb-000000000002",
+);
+const SLO_ID: string = "0193c0de-dddd-4aaa-8bbb-0000000000a1";
+const SECOND_SLO_ID: string = "0193c0de-dddd-4aaa-8bbb-0000000000a2";
+const FOREIGN_SLO_ID: string = "0193c0de-dddd-4aaa-8bbb-0000000000b1";
+const FOREIGN_SLO_NAME: string = "Payments SLO of another project";
+const MISSING_SLO_ID: string = "0193c0de-dddd-4aaa-8bbb-0000000000c1";
+
+interface StoredSlo {
+  id: string;
+  projectId: ObjectID;
+  name: string;
+}
+
+const SLO_TABLE: Array<StoredSlo> = [
+  { id: SLO_ID, projectId: PROJECT_ID, name: "Checkout availability" },
+  { id: SECOND_SLO_ID, projectId: PROJECT_ID, name: "Search latency" },
+  { id: FOREIGN_SLO_ID, projectId: OTHER_PROJECT_ID, name: FOREIGN_SLO_NAME },
+];
+
+interface LookupArgs {
+  query: JSONObject;
+  select: JSONObject;
+  limit: number;
+  skip: number;
+  props: JSONObject;
+}
+
+let anySpy: jest.SpyInstance;
+let lookup: jest.SpyInstance;
+
+// The ids the validator handed to QueryHelper.any for its latest read.
+function lastRequestedIds(): Array<string> {
+  const calls: Array<Array<unknown>> = anySpy.mock.calls as Array<
+    Array<unknown>
+  >;
+
+  return ((calls[calls.length - 1]?.[0] as Array<unknown>) || []).map(
+    (id: unknown): string => {
+      return String(id).toLowerCase();
+    },
+  );
+}
+
+function validate(serviceLevelObjectives: unknown): Promise<void> {
+  return SloRecordReferenceValidator.validateServiceLevelObjectivesBelongToProject(
+    {
+      projectId: PROJECT_ID,
+      subject: "incident",
+      serviceLevelObjectives: serviceLevelObjectives,
+    },
+  );
+}
+
+async function rejectionOf(promise: Promise<void>): Promise<Error> {
+  try {
+    await promise;
+  } catch (error) {
+    return error as Error;
+  }
+
+  throw new Error("Expected the validation to reject, but it resolved.");
+}
+
+beforeEach(() => {
+  // Calls through: only records the ids each read asked for.
+  anySpy = jest.spyOn(QueryHelper, "any");
+
+  lookup = jest
+    .spyOn(SloRecordReferenceValidator.getLookupService(), "findBy")
+    .mockImplementation((async (
+      args: LookupArgs,
+    ): Promise<Array<ServiceLevelObjective>> => {
+      const requestedIds: Array<string> = lastRequestedIds();
+      const pinnedProjectId: string | undefined = (
+        args.query["projectId"] as unknown as ObjectID | undefined
+      )?.toString();
+
+      return SLO_TABLE.filter((row: StoredSlo): boolean => {
+        return (
+          requestedIds.includes(row.id) &&
+          (!pinnedProjectId || row.projectId.toString() === pinnedProjectId)
+        );
+      }).map((row: StoredSlo): ServiceLevelObjective => {
+        const slo: ServiceLevelObjective = new ServiceLevelObjective();
+        slo._id = row.id;
+        slo.name = row.name;
+        slo.projectId = row.projectId;
+        return slo;
+      });
+    }) as never);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("SloRecordReferenceValidator.validateServiceLevelObjectivesBelongToProject", () => {
+  test("accepts SLOs of the record's own project, read as root, ids only, pinned to the project", async () => {
+    await expect(
+      validate([{ _id: SLO_ID }, { _id: SECOND_SLO_ID }]),
+    ).resolves.toBeUndefined();
+
+    expect(lookup).toHaveBeenCalledTimes(1);
+
+    const args: LookupArgs = lookup.mock.calls[0]![0] as LookupArgs;
+
+    expect((args.query["projectId"] as unknown as ObjectID).toString()).toBe(
+      PROJECT_ID.toString(),
+    );
+    expect(args.select).toEqual({ _id: true });
+    expect(args.props).toEqual({ isRoot: true });
+    expect(args.limit).toBe(2);
+    expect(lastRequestedIds()).toEqual([SLO_ID, SECOND_SLO_ID]);
+  });
+
+  test("rejects another project's SLO", async () => {
+    const error: Error = await rejectionOf(validate([{ _id: FOREIGN_SLO_ID }]));
+
+    expect(error).toBeInstanceOf(BadDataException);
+    expect(error.message).toBe(
+      `This incident references Service Level Objectives that do not exist in this project: "${FOREIGN_SLO_ID}". Please pick SLOs from this project and try again.`,
+    );
+  });
+
+  test("the rejection never names the foreign SLO", async () => {
+    const error: Error = await rejectionOf(validate([{ _id: FOREIGN_SLO_ID }]));
+
+    expect(error.message).not.toContain(FOREIGN_SLO_NAME);
+  });
+
+  test("a foreign id and an id that matches nothing get the same answer", async () => {
+    const foreign: Error = await rejectionOf(validate([FOREIGN_SLO_ID]));
+    const missing: Error = await rejectionOf(validate([MISSING_SLO_ID]));
+
+    expect(foreign.message.replace(FOREIGN_SLO_ID, "<id>")).toBe(
+      missing.message.replace(MISSING_SLO_ID, "<id>"),
+    );
+  });
+
+  test("names only the ids that are not in the project", async () => {
+    const error: Error = await rejectionOf(
+      validate([SLO_ID, FOREIGN_SLO_ID, MISSING_SLO_ID]),
+    );
+
+    expect(error.message).toContain(`"${FOREIGN_SLO_ID}", "${MISSING_SLO_ID}"`);
+    expect(error.message).not.toContain(SLO_ID);
+  });
+
+  test("every read is pinned to the record's project, whatever the outcome", async () => {
+    await validate([SLO_ID]);
+    await rejectionOf(validate([FOREIGN_SLO_ID]));
+
+    expect(lookup).toHaveBeenCalledTimes(2);
+
+    for (const call of lookup.mock.calls) {
+      const args: LookupArgs = call[0] as LookupArgs;
+
+      expect(
+        (
+          args.query["projectId"] as unknown as ObjectID | undefined
+        )?.toString(),
+      ).toBe(PROJECT_ID.toString());
+    }
+  });
+
+  test.each([
+    ["a bare uuid string (the update shape)", SLO_ID],
+    ["an upper-case uuid string", SLO_ID.toUpperCase()],
+    ["an ObjectID", new ObjectID(SLO_ID)],
+    ["an {_id} object (the API create shape)", { _id: SLO_ID }],
+    ["an {id: ObjectID} object", { id: new ObjectID(SLO_ID) }],
+  ])("accepts %s", async (_label: string, entry: unknown) => {
+    await expect(validate([entry])).resolves.toBeUndefined();
+
+    expect(lastRequestedIds()).toEqual([SLO_ID]);
+  });
+
+  test("accepts the burn-rate worker's id-stub model instance", async () => {
+    const stub: ServiceLevelObjective = new ServiceLevelObjective();
+    stub._id = SLO_ID;
+
+    await expect(validate([stub])).resolves.toBeUndefined();
+
+    expect(lastRequestedIds()).toEqual([SLO_ID]);
+  });
+
+  test("the same SLO twice is looked up once", async () => {
+    await validate([SLO_ID, { _id: SLO_ID.toUpperCase() }]);
+
+    expect(lastRequestedIds()).toEqual([SLO_ID]);
+    expect((lookup.mock.calls[0]![0] as LookupArgs).limit).toBe(1);
+  });
+
+  test("a malformed id is rejected without a query", async () => {
+    const error: Error = await rejectionOf(validate(["not-a-uuid"]));
+
+    expect(error).toBeInstanceOf(BadDataException);
+    expect(error.message).toContain('"not-a-uuid"');
+    expect(lookup).not.toHaveBeenCalled();
+  });
+
+  test.each([
+    ["undefined", undefined],
+    ["null", null],
+    ["an empty list", []],
+    ["entries without ids", [{ name: "Unsaved" }, null, ""]],
+  ])(
+    "%s links nothing, so nothing is read",
+    async (_label: string, value: unknown) => {
+      await expect(validate(value)).resolves.toBeUndefined();
+
+      expect(lookup).not.toHaveBeenCalled();
+    },
+  );
+
+  test("with no project to compare against the check is a no-op, as in ProjectScopedReferenceValidator", async () => {
+    await expect(
+      SloRecordReferenceValidator.validateServiceLevelObjectivesBelongToProject(
+        {
+          projectId: undefined,
+          subject: "alert",
+          serviceLevelObjectives: [FOREIGN_SLO_ID],
+        },
+      ),
+    ).resolves.toBeUndefined();
+
+    expect(lookup).not.toHaveBeenCalled();
+  });
+
+  test("the subject names the record in the message", async () => {
+    const error: Error = await rejectionOf(
+      SloRecordReferenceValidator.validateServiceLevelObjectivesBelongToProject(
+        {
+          projectId: PROJECT_ID,
+          subject: "alert",
+          serviceLevelObjectives: [FOREIGN_SLO_ID],
+        },
+      ),
+    );
+
+    expect(error.message.startsWith("This alert references")).toBe(true);
+  });
+});
+
+/*
+ * IncidentService and AlertService call this validator, and they cannot reach
+ * ServiceLevelObjectiveService: it imports the burn-rate rule service, which
+ * imports them. So the lookup must be a plain DatabaseService over the model.
+ * A hooked subclass would run SLO hooks, and importing an SLO service would
+ * bring the cycle back.
+ */
+describe("the SLO lookup does not reach the SLO services", () => {
+  test("is a plain DatabaseService over the ServiceLevelObjective model, created once", () => {
+    const service: DatabaseService<ServiceLevelObjective> =
+      SloRecordReferenceValidator.getLookupService();
+
+    expect(Object.getPrototypeOf(service)).toBe(DatabaseService.prototype);
+    expect(service.getModel()).toBeInstanceOf(ServiceLevelObjective);
+    expect(SloRecordReferenceValidator.getLookupService()).toBe(service);
+  });
+
+  test("the validator module imports DatabaseService and no other service", () => {
+    const source: string = fs.readFileSync(
+      path.join(
+        __dirname,
+        "../../../../Server/Utils/Slo/SloRecordReferenceValidator.ts",
+      ),
+      "utf8",
+    );
+
+    const serviceImports: Array<string> = (
+      source.match(/from "[^"]*\/Services\/[^"]*"/g) || []
+    ).map((specifier: string): string => {
+      return specifier.slice('from "'.length, -1);
+    });
+
+    expect(serviceImports).toEqual(["../../Services/DatabaseService"]);
+  });
+});

package/Tests/Server/Utils/StatusPageResource.test.ts

@@ -45,9 +45,9 @@ describe("StatusPageResourceUtil", () => {
        * Groups should be formatted as "GroupName: Resource1, Resource2"
        * Multiple groups separated by <br/> for HTML rendering
        */
-      expect(result).toContain("EU: Infrastructure, Website");
-      expect(result).toContain("UK: Infrastructure, API");
-      expect(result).toContain("<br/>");
+      expect(result).toBe(
+        "EU: Infrastructure, Website<br/>UK: Infrastructure, API",
+      );
     });
 
     it("should handle mixed grouped and ungrouped resources", () => {
@@ -121,6 +121,94 @@ describe("StatusPageResourceUtil", () => {
         StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
       expect(result).toBe("EU: Infrastructure, Website, API");
     });
+
+    it("should put each group on its own HTML line", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResourceWithGroup("API", "UK"),
+        createResource("Global API"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toBe("EU: Infrastructure<br/>UK: API<br/>Global API");
+    });
+  });
+
+  describe("getResourcesGroupedByGroupNameAsPlainText", () => {
+    it("should separate groups with semicolons instead of <br/>", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResourceWithGroup("Website", "EU"),
+        createResourceWithGroup("Infrastructure", "UK"),
+        createResourceWithGroup("API", "UK"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+          resources,
+        );
+      expect(result).toBe(
+        "EU: Infrastructure, Website; UK: Infrastructure, API",
+      );
+      expect(result).not.toContain("<");
+    });
+
+    it("should keep ungrouped resources on the same line as the groups", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResource("Global API"),
+        createResourceWithGroup("Website", "UK"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+          resources,
+        );
+      expect(result).toBe("EU: Infrastructure; UK: Website; Global API");
+    });
+
+    it("should return the same comma-separated list as the HTML form when nothing is grouped", () => {
+      const resources: Array<StatusPageResource> = [
+        createResource("API"),
+        createResourceWithoutDisplayName(),
+        createResource("Website"),
+      ];
+
+      expect(
+        StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+          resources,
+        ),
+      ).toBe("API, Website");
+      expect(
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources),
+      ).toBe("API, Website");
+    });
+
+    it("should return a single group unchanged", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResourceWithGroup("Website", "EU"),
+      ];
+
+      expect(
+        StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+          resources,
+        ),
+      ).toBe("EU: Infrastructure, Website");
+    });
+
+    it("should return the default value when there are no resources", () => {
+      expect(
+        StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText([]),
+      ).toBe("");
+      expect(
+        StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+          null as unknown as Array<StatusPageResource>,
+          "None",
+        ),
+      ).toBe("None");
+    });
   });
 });
 

package/Tests/Server/Utils/TailwindBuildCopy.test.ts

@@ -39,7 +39,14 @@ const CANONICAL: string = path.join(
   "tailwind-3.4.5.js",
 );
 
-const REPOSITORY_ROOT: string = path.resolve(__dirname, "..", "..", "..", "..");
+const REPOSITORY_ROOT: string = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "..",
+);
 
 const temporaryRoots: Array<string> = [];
 
@@ -181,7 +188,12 @@ describe("the frontend build's Tailwind copy", () => {
      * The version lives in the filename, so bumping Tailwind means editing five
      * views. This is the tripwire for doing one without the other.
      */
-    const featureSets: string = path.join(REPOSITORY_ROOT, "App", "FeatureSet");
+    const featureSets: string = path.join(
+      REPOSITORY_ROOT,
+      "packages",
+      "App",
+      "FeatureSet",
+    );
 
     const services: Array<[string, string]> = [
       ["Dashboard", "dashboard"],

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

@@ -0,0 +1,235 @@
+/*
+ * End-to-end for issue #3866, at the only seam that proves the feature
+ * works: a real OTLP resource-attribute payload, flattened exactly the way
+ * ingest flattens it, fed to the entity extractor.
+ *
+ * TelemetryEntity.test.ts covers the extractor against a hand-built
+ * dictionary, which is where the logic lives. It cannot catch the failure
+ * that actually matters here — that `host.ip` arrives from the wire in a
+ * shape the extractor does not recognise. An OTLP `arrayValue` has to
+ * survive `TelemetryUtil.getAttributes` as a real JS array under the same
+ * key; if it were ever flattened to `host.ip.0` / `host.ip.1`, or
+ * serialized to a string, every assertion in the other suite would still
+ * pass while the Attributes card stayed empty.
+ *
+ * Stub the DatabaseService base class out before TelemetryUtil's import
+ * graph drags the server-side service layer in. See
+ * TelemetryUtilAttributeKeys.test.ts for why the stub needs these methods.
+ */
+jest.mock("../../../../Server/Services/DatabaseService", () => {
+  return {
+    __esModule: true,
+    default: class DatabaseServiceStub {
+      public hardDeleteItemsOlderThanInDays(): void {
+        // no-op: retention config, nothing for a pure unit test to do.
+      }
+
+      public setDoNotAllowDelete(): void {
+        // no-op: delete-permission config, same.
+      }
+    },
+  };
+});
+
+import TelemetryUtil, {
+  AttributeType,
+} from "../../../../Server/Utils/Telemetry/Telemetry";
+import InventoryItem, {
+  EntityAttributes,
+  ExtractedEntity,
+} from "../../../../Server/Utils/Telemetry/TelemetryEntity";
+import EntityType from "../../../../Types/Telemetry/EntityType";
+import Dictionary from "../../../../Types/Dictionary";
+import { JSONArray, JSONObject } from "../../../../Types/JSON";
+import { normalizeHostIpAddresses } from "../../../../Utils/Telemetry/HostIpAddresses";
+import { describe, expect, test } from "@jest/globals";
+
+const PROJECT: string = "proj1";
+
+/*
+ * `OtelPayloadDecoder.decodeFromQueue` runs protobuf `message.toJSON()`,
+ * which camelCases field names — so camelCase is the shape ingest really
+ * sees. OTLP/JSON producers can send snake_case instead, and
+ * `getAttributeValues` handles both; the snake_case case is asserted below.
+ */
+function stringAttribute(key: string, value: string): JSONObject {
+  return { key: key, value: { stringValue: value } };
+}
+
+function stringArrayAttribute(key: string, values: Array<string>): JSONObject {
+  return {
+    key: key,
+    value: {
+      arrayValue: {
+        values: values.map((value: string) => {
+          return { stringValue: value };
+        }),
+      },
+    },
+  };
+}
+
+function snakeCaseStringArrayAttribute(
+  key: string,
+  values: Array<string>,
+): JSONObject {
+  return {
+    key: key,
+    value: {
+      array_value: {
+        values: values.map((value: string) => {
+          return { string_value: value };
+        }),
+      },
+    },
+  };
+}
+
+const IP_ADDRESSES: Array<string> = [
+  "10.1.2.3",
+  "10.1.2.4",
+  "fe80::42:acff:fe11:1",
+];
+
+/*
+ * The reporter's machine: a Windows host whose collector runs the `system`
+ * resource detector and has the three hardware values stamped onto the
+ * resource. Deliberately carries no container.runtime, which would route
+ * the batch to the DockerHost table instead.
+ */
+function windowsHostResourceAttributes(): JSONArray {
+  return [
+    stringAttribute("host.name", "wbprjdeais002"),
+    stringAttribute("host.arch", "amd64"),
+    stringAttribute("host.id", "4C4C4544-0037-5A10-8054-B4C04F335931"),
+    stringArrayAttribute("host.ip", IP_ADDRESSES),
+    stringAttribute("os.type", "windows"),
+    stringAttribute("os.description", "Microsoft Windows 11 Enterprise"),
+    stringAttribute("host.serial_number", "7XYZ123"),
+    stringAttribute("device.manufacturer", "Dell Inc."),
+    stringAttribute("device.model.name", "OptiPlex 7090"),
+  ] as JSONArray;
+}
+
+/** Exactly what `OTelIngestService.resolveTelemetryResource` does. */
+function extractHost(attributes: JSONArray): ExtractedEntity | undefined {
+  const flat: Dictionary<AttributeType | Array<AttributeType>> =
+    TelemetryUtil.getAttributes({
+      items: attributes,
+      prefixKeysWithString: "",
+    });
+
+  return InventoryItem.extractEntities({
+    projectId: PROJECT,
+    attributes: flat as EntityAttributes,
+  }).find((entity: ExtractedEntity) => {
+    return entity.entityType === EntityType.Host;
+  });
+}
+
+describe("host asset attributes survive the OTLP wire shape (issue #3866)", () => {
+  test("an OTLP arrayValue reaches the extractor as a real array under the same key", () => {
+    const flat: Dictionary<AttributeType | Array<AttributeType>> =
+      TelemetryUtil.getAttributes({
+        items: windowsHostResourceAttributes(),
+        prefixKeysWithString: "",
+      });
+
+    expect(Array.isArray(flat["host.ip"])).toBe(true);
+    expect(flat["host.ip"]).toEqual(IP_ADDRESSES);
+    // Not flattened into indexed keys, which would make the join unreachable.
+    expect(flat["host.ip.0"]).toBeUndefined();
+  });
+
+  test("the reporter's Windows host yields every requested attribute", () => {
+    const host: ExtractedEntity | undefined = extractHost(
+      windowsHostResourceAttributes(),
+    );
+
+    expect(host).toBeDefined();
+    expect(host!.descriptiveAttributes).toEqual({
+      "os.type": "windows",
+      "os.description": "Microsoft Windows 11 Enterprise",
+      "host.arch": "amd64",
+      "host.id": "4C4C4544-0037-5A10-8054-B4C04F335931",
+      "host.ip": "10.1.2.3, 10.1.2.4, fe80::42:acff:fe11:1",
+      "host.serial_number": "7XYZ123",
+      "device.manufacturer": "Dell Inc.",
+      "device.model.name": "OptiPlex 7090",
+    });
+  });
+
+  test("identity is still the host name alone", () => {
+    const host: ExtractedEntity | undefined = extractHost(
+      windowsHostResourceAttributes(),
+    );
+
+    expect(host!.identifyingAttributes).toEqual({
+      "host.name": "wbprjdeais002",
+    });
+  });
+
+  /*
+   * The key is a hash of the identifying set only. If any asset attribute
+   * leaked into it, the existing row would fork the moment a host got a new
+   * IP — which is exactly the duplicate-inventory failure mode.
+   */
+  test("the entity key is unchanged by every asset attribute", () => {
+    const withAssets: ExtractedEntity | undefined = extractHost(
+      windowsHostResourceAttributes(),
+    );
+    const nameOnly: ExtractedEntity | undefined = extractHost([
+      stringAttribute("host.name", "wbprjdeais002"),
+      stringAttribute("os.type", "windows"),
+    ] as JSONArray);
+
+    expect(withAssets!.entityKey).toBe(nameOnly!.entityKey);
+  });
+
+  test("a snake_case OTLP/JSON producer yields the identical entity", () => {
+    const camelCase: ExtractedEntity | undefined = extractHost(
+      windowsHostResourceAttributes(),
+    );
+    const snakeCase: ExtractedEntity | undefined = extractHost([
+      stringAttribute("host.name", "wbprjdeais002"),
+      stringAttribute("os.type", "windows"),
+      snakeCaseStringArrayAttribute("host.ip", IP_ADDRESSES),
+      stringAttribute("host.arch", "amd64"),
+      stringAttribute("host.id", "4C4C4544-0037-5A10-8054-B4C04F335931"),
+      stringAttribute("os.description", "Microsoft Windows 11 Enterprise"),
+      stringAttribute("host.serial_number", "7XYZ123"),
+      stringAttribute("device.manufacturer", "Dell Inc."),
+      stringAttribute("device.model.name", "OptiPlex 7090"),
+    ] as JSONArray);
+
+    expect(snakeCase!.entityKey).toBe(camelCase!.entityKey);
+    expect(snakeCase!.descriptiveAttributes).toEqual(
+      camelCase!.descriptiveAttributes,
+    );
+  });
+
+  test("the joined value matches what the Host column stores", () => {
+    const host: ExtractedEntity | undefined = extractHost(
+      windowsHostResourceAttributes(),
+    );
+
+    expect(host!.descriptiveAttributes!["host.ip"]).toBe(
+      normalizeHostIpAddresses(IP_ADDRESSES),
+    );
+  });
+
+  /*
+   * Unchanged behaviour, asserted here because the new attributes are
+   * exactly the kind of thing a Kubernetes node also reports: a resource
+   * carrying a Kubernetes identity must still mint no Host at all.
+   */
+  test("a Kubernetes resource still yields no Host entity", () => {
+    const host: ExtractedEntity | undefined = extractHost([
+      ...(windowsHostResourceAttributes() as Array<JSONObject>),
+      stringAttribute("k8s.cluster.name", "prod-us"),
+      stringAttribute("k8s.node.name", "node-1"),
+    ] as JSONArray);
+
+    expect(host).toBeUndefined();
+  });
+});