@oneuptime/common 13.0.6 → 13.0.7

package/Tests/Utils/HTTPResponseBodyReader.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, test } from "@jest/globals";
+import { describe, expect, jest, test } from "@jest/globals";
 import BadDataException from "../../Types/Exception/BadDataException";
 import HTTPResponseBodyReader, {
   HTTPResponseBodyBudget,
 } from "../../Utils/HTTPResponseBodyReader";
 import { Readable } from "stream";
+import type { Mock, MockInstance } from "jest-mock";
 
 const read: (
   body: AsyncIterable<unknown>,
@@ -14,6 +15,7 @@ const read: (
     headers?: unknown;
     isHeadResponse?: boolean;
     maximumResponseBytes?: number;
+    signal?: AbortSignal;
   },
 ) => Promise<Buffer> = async (
   body: AsyncIterable<unknown>,
@@ -24,6 +26,7 @@ const read: (
     headers?: unknown;
     isHeadResponse?: boolean;
     maximumResponseBytes?: number;
+    signal?: AbortSignal;
   } = {},
 ): Promise<Buffer> => {
   return await HTTPResponseBodyReader.read(body, {
@@ -33,10 +36,194 @@ const read: (
     headers: options.headers,
     isHeadResponse: options.isHeadResponse,
     maximumResponseBytes: options.maximumResponseBytes,
+    signal: options.signal,
   });
 };
 
 describe("HTTPResponseBodyReader", () => {
+  test.each([200, 400, 503])(
+    "destroys a stalled status %s body and removes its listener on abort",
+    async (statusCode: number) => {
+      const controller: AbortController = new AbortController();
+      const addListener: MockInstance<AbortSignal["addEventListener"]> =
+        jest.spyOn(controller.signal, "addEventListener");
+      const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+        jest.spyOn(controller.signal, "removeEventListener");
+      const body: Readable = new Readable({ read: (): void => {} });
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+      const pending: Promise<Buffer> = read(body, budget, {
+        statusCode: statusCode,
+        signal: controller.signal,
+      });
+      const rejected: Promise<void> = expect(pending).rejects.toMatchObject({
+        name: "AbortError",
+      });
+
+      controller.abort();
+      await rejected;
+
+      expect(body.destroyed).toBe(true);
+      expect(budget.remainingBytes).toBe(10);
+      expect(removeListener).toHaveBeenCalledWith(
+        "abort",
+        addListener.mock.calls[0]![1],
+      );
+    },
+  );
+
+  test("destroys an already-aborted body without starting its iterator", async () => {
+    const controller: AbortController = new AbortController();
+    controller.abort();
+    const body: Readable = Readable.from([Buffer.from("unread")]);
+    const iterate: MockInstance<Readable[typeof Symbol.asyncIterator]> =
+      jest.spyOn(body, Symbol.asyncIterator);
+    const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+      jest.spyOn(controller.signal, "removeEventListener");
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+
+    await expect(
+      read(body, budget, { signal: controller.signal }),
+    ).rejects.toMatchObject({ name: "AbortError" });
+
+    expect(iterate).not.toHaveBeenCalled();
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(10);
+    expect(removeListener).toHaveBeenCalledTimes(1);
+  });
+
+  test("removes its abort listener after a successful duck-typed stream", async () => {
+    const controller: AbortController = new AbortController();
+    const destroy: Mock<() => void> = jest.fn<() => void>();
+    const body: AsyncIterable<Buffer> & { destroy: () => void } = {
+      async *[Symbol.asyncIterator](): ReturnType<
+        AsyncIterable<Buffer>[typeof Symbol.asyncIterator]
+      > {
+        yield Buffer.from("data");
+      },
+      destroy: destroy,
+    };
+    const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+      jest.spyOn(controller.signal, "removeEventListener");
+
+    await expect(
+      read(body, new HTTPResponseBodyBudget(10), { signal: controller.signal }),
+    ).resolves.toEqual(Buffer.from("data"));
+    controller.abort();
+
+    expect(removeListener).toHaveBeenCalledTimes(1);
+    expect(destroy).not.toHaveBeenCalled();
+  });
+
+  test("removes its abort listener after the source iterator fails", async () => {
+    const controller: AbortController = new AbortController();
+    const destroy: Mock<() => void> = jest.fn<() => void>();
+    const sourceError: Error = new Error("source failed");
+    const body: AsyncIterable<Buffer> & { destroy: () => void } = {
+      [Symbol.asyncIterator](): AsyncIterator<Buffer> {
+        return {
+          next: (): Promise<IteratorResult<Buffer>> => {
+            return Promise.reject(sourceError);
+          },
+        };
+      },
+      destroy: destroy,
+    };
+    const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+      jest.spyOn(controller.signal, "removeEventListener");
+
+    await expect(
+      read(body, new HTTPResponseBodyBudget(10), { signal: controller.signal }),
+    ).rejects.toBe(sourceError);
+    controller.abort();
+
+    expect(removeListener).toHaveBeenCalledTimes(1);
+    expect(destroy).not.toHaveBeenCalled();
+  });
+
+  test.each(["declared length", "streamed length", "exhausted budget"])(
+    "removes its abort listener after rejecting %s",
+    async (failure: string) => {
+      const controller: AbortController = new AbortController();
+      const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+        jest.spyOn(controller.signal, "removeEventListener");
+      const body: Readable = Readable.from([Buffer.from("12345")]);
+      const destroy: MockInstance<Readable["destroy"]> = jest.spyOn(
+        body,
+        "destroy",
+      );
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(
+        failure === "exhausted budget" ? 0 : 4,
+      );
+
+      await expect(
+        read(body, budget, {
+          signal: controller.signal,
+          headers:
+            failure === "declared length" ? { "content-length": "5" } : {},
+        }),
+      ).rejects.toBeInstanceOf(BadDataException);
+      const destroyCalls: number = destroy.mock.calls.length;
+      controller.abort();
+
+      expect(body.destroyed).toBe(true);
+      expect(removeListener).toHaveBeenCalledTimes(1);
+      expect(destroy).toHaveBeenCalledTimes(destroyCalls);
+    },
+  );
+
+  test("settles on abort without destroy and never charges a late chunk", async () => {
+    const controller: AbortController = new AbortController();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+    let resolveWaiting: () => void = (): void => {};
+    const waiting: Promise<void> = new Promise((resolve: () => void) => {
+      resolveWaiting = resolve;
+    });
+    let resolveLateChunk: (
+      chunk: IteratorResult<Buffer>,
+    ) => void = (): void => {};
+    const lateChunk: Promise<IteratorResult<Buffer>> = new Promise(
+      (resolve: (chunk: IteratorResult<Buffer>) => void) => {
+        resolveLateChunk = resolve;
+      },
+    );
+    let nextCalls: number = 0;
+    const body: AsyncIterable<Buffer> = {
+      [Symbol.asyncIterator](): AsyncIterator<Buffer> {
+        return {
+          next: (): Promise<IteratorResult<Buffer>> => {
+            nextCalls++;
+            if (nextCalls === 1) {
+              return Promise.resolve({
+                done: false,
+                value: Buffer.from("abc"),
+              });
+            }
+            resolveWaiting();
+            return lateChunk;
+          },
+        };
+      },
+    };
+    const pending: Promise<Buffer> = read(body, budget, {
+      signal: controller.signal,
+    });
+    const rejected: Promise<void> = expect(pending).rejects.toMatchObject({
+      name: "AbortError",
+    });
+
+    await waiting;
+    expect(budget.remainingBytes).toBe(7);
+    controller.abort();
+    await rejected;
+    resolveLateChunk({ done: false, value: Buffer.from("late") });
+    await new Promise<void>((resolve: () => void) => {
+      setTimeout(resolve, 0);
+    });
+
+    expect(budget.remainingBytes).toBe(7);
+    expect(nextCalls).toBe(2);
+  });
+
   test("charges sequential responses against one cumulative byte budget", async () => {
     const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(6);
 

package/Tests/Utils/Metrics/MetricEventScopeUrl.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "@jest/globals";
+import MetricExplorerUrl, {
+  MetricExplorerUrlParam,
+  SerializedMetricQuery,
+} from "../../../Utils/Metrics/MetricExplorerUrl";
+import { buildQueryConfigsFromSerializedQueries } from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/MetricConfigReconstruct";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+
+const RESOURCE_ID: string = "11111111-0000-4000-8000-000000000001";
+
+function roundTrip(config: MetricQueryConfigData): MetricQueryConfigData {
+  const params: Record<string, string> =
+    MetricExplorerUrl.buildQueryParamsFromMetricViewData({
+      queryConfigs: [config],
+      formulaConfigs: [],
+      startAndEndDate: null,
+    });
+  const parsed: Array<SerializedMetricQuery> =
+    MetricExplorerUrl.parseMetricQueriesParam(
+      params[MetricExplorerUrlParam.MetricQueries]!,
+    );
+  expect(parsed).toHaveLength(1);
+  return buildQueryConfigsFromSerializedQueries(parsed)[0]!;
+}
+
+describe("metric event scope URL round trip", () => {
+  test("preserves RUM identity without adding identifiers to the metric attribute filter", () => {
+    const config: MetricQueryConfigData = {
+      metricQueryData: {
+        filterData: {
+          metricName: "browser.page_load",
+          attributes: { environment: "prod" },
+        },
+      },
+      eventScope: {
+        primaryEntityId: new Includes([RESOURCE_ID]),
+        primaryEntityType: ServiceType.RealUserMonitor,
+      },
+    };
+    const rebuilt: MetricQueryConfigData = roundTrip(config);
+    expect(rebuilt.eventScope?.["primaryEntityId"]).toBeInstanceOf(Includes);
+    expect(
+      (rebuilt.eventScope?.["primaryEntityId"] as Includes).values,
+    ).toEqual([RESOURCE_ID]);
+    expect(rebuilt.eventScope?.["primaryEntityType"]).toBe(
+      ServiceType.RealUserMonitor,
+    );
+    expect(rebuilt.metricQueryData.filterData.attributes).toEqual({
+      environment: "prod",
+    });
+    expect(roundTrip(rebuilt).eventScope).toEqual(rebuilt.eventScope);
+  });
+
+  test("preserves all opaque inventory memberships through a share and reload", () => {
+    const rebuilt: MetricQueryConfigData = roundTrip({
+      metricQueryData: { filterData: { metricName: "cpu.usage" } },
+      eventScope: { entityKeys: new Includes(["entity-a", "entity-b"]) },
+    });
+    expect((rebuilt.eventScope?.["entityKeys"] as Includes).values).toEqual([
+      "entity-a",
+      "entity-b",
+    ]);
+    expect(rebuilt.metricQueryData.filterData.attributes).toEqual({});
+  });
+
+  test("keeps an explicitly empty scope distinct from a project-wide view", () => {
+    const rebuilt: MetricQueryConfigData = roundTrip({
+      metricQueryData: { filterData: { metricName: "", attributes: {} } },
+      eventScope: {},
+    });
+    expect(rebuilt.eventScope).toEqual({});
+  });
+
+  test.each([
+    null,
+    "bad-scope",
+    { entityKeys: { nested: "invalid" } },
+    { entityKeys: { _type: "Includes", value: [] } },
+  ])(
+    "sanitizing malformed scope %p cannot erase the explicit scope boundary",
+    (eventScope: unknown) => {
+      const parsed: Array<SerializedMetricQuery> =
+        MetricExplorerUrl.parseMetricQueriesParam(
+          JSON.stringify([{ metricName: "cpu.usage", eventScope }]),
+        );
+      expect(parsed[0]?.eventScope).toEqual({});
+      expect(
+        buildQueryConfigsFromSerializedQueries(parsed)[0]?.eventScope,
+      ).toEqual({});
+    },
+  );
+
+  test("older unscoped views stay unscoped", () => {
+    const rebuilt: MetricQueryConfigData = roundTrip({
+      metricQueryData: { filterData: { metricName: "cpu.usage" } },
+    });
+    expect(rebuilt.eventScope).toBeUndefined();
+  });
+});

package/Tests/Utils/Monitor/MonitorTestAvailabilityUtil.test.ts

@@ -0,0 +1,256 @@
+import MonitorTestAvailabilityUtil, {
+  MonitorTestAvailability,
+} from "../../../Utils/Monitor/MonitorTestAvailabilityUtil";
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType, {
+  MonitorTypeHelper,
+} from "../../../Types/Monitor/MonitorType";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * https://github.com/OneUptime/oneuptime/issues/3867
+ *
+ * "Test Monitor" was reachable only from Monitors > View Monitor > Criteria.
+ * Putting it on the Monitor Overview's summary card puts it in front of far
+ * more monitors than the criteria page ever did - including every monitor type
+ * that no probe runs, monitors that have not been given any steps, and
+ * monitors with nothing attached to test with.
+ *
+ * Each of those three is a dead end that a user only discovers after
+ * committing, and two of them look like the same thing (a timeout) even though
+ * one is a configuration gap and the other is a client-side mistake:
+ *
+ *   - no steps: the probe returns before reporting anything, so the dashboard
+ *     polls for two and a half minutes and then says the test "took too long";
+ *   - no probes: the modal's required "Select Probe" dropdown has no options,
+ *     so "Run Test" can never be submitted.
+ *
+ * This is the rule that keeps the button from being offered in any of them.
+ */
+
+function stepsWith(count: number): MonitorSteps {
+  const monitorSteps: MonitorSteps = new MonitorSteps();
+
+  monitorSteps.data = {
+    monitorStepsInstanceArray: Array.from({ length: count }, () => {
+      return new MonitorStep();
+    }),
+  };
+
+  return monitorSteps;
+}
+
+const ONE_STEP: MonitorSteps = stepsWith(1);
+
+describe("MonitorTestAvailabilityUtil.getAvailability", () => {
+  it("offers the test for a probeable monitor that has steps and a probe", () => {
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Website,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 1,
+      }),
+    ).toBe(MonitorTestAvailability.Available);
+  });
+
+  it("refuses a monitor type that no probe runs", () => {
+    /*
+     * A telemetry monitor is evaluated by the server against ingested data;
+     * there is no probe to hand it to, and MonitorTestForm renders nothing for
+     * it - which would leave an empty slot in the card header.
+     */
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Logs,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 3,
+      }),
+    ).toBe(MonitorTestAvailability.MonitorTypeNotProbeable);
+  });
+
+  it("refuses a manual monitor", () => {
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Manual,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 3,
+      }),
+    ).toBe(MonitorTestAvailability.MonitorTypeNotProbeable);
+  });
+
+  it("refuses while the monitor type is still unknown", () => {
+    /*
+     * The overview page renders a loader until the monitor arrives, but the
+     * card must not depend on that: an undefined type is not yet an answer.
+     */
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: undefined,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 3,
+      }),
+    ).toBe(MonitorTestAvailability.MonitorTypeNotProbeable);
+  });
+
+  it("refuses when the monitor has no steps object at all", () => {
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Ping,
+        monitorSteps: undefined,
+        attachedProbeCount: 2,
+      }),
+    ).toBe(MonitorTestAvailability.NoMonitorSteps);
+  });
+
+  it("refuses when monitorSteps is null rather than undefined", () => {
+    // ModelAPI hands back null for an unset column, not undefined.
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Ping,
+        monitorSteps: null,
+        attachedProbeCount: 2,
+      }),
+    ).toBe(MonitorTestAvailability.NoMonitorSteps);
+  });
+
+  it("refuses when the steps object carries no data", () => {
+    const empty: MonitorSteps = new MonitorSteps();
+    empty.data = undefined;
+
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Ping,
+        monitorSteps: empty,
+        attachedProbeCount: 2,
+      }),
+    ).toBe(MonitorTestAvailability.NoMonitorSteps);
+  });
+
+  it("refuses when the steps array is empty", () => {
+    /*
+     * The case that matters most: the row would be created and accepted, and
+     * the probe would return without reporting, so the only thing the user
+     * would ever see is "took too long to complete".
+     */
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Ping,
+        monitorSteps: stepsWith(0),
+        attachedProbeCount: 2,
+      }),
+    ).toBe(MonitorTestAvailability.NoMonitorSteps);
+  });
+
+  it("refuses when nothing is attached to run the test on", () => {
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.API,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 0,
+      }),
+    ).toBe(MonitorTestAvailability.NoProbesAttached);
+  });
+
+  it("refuses a negative probe count rather than trusting it", () => {
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.API,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: -1,
+      }),
+    ).toBe(MonitorTestAvailability.NoProbesAttached);
+  });
+
+  it("reports the monitor type first when more than one thing is missing", () => {
+    /*
+     * Order matters for a caller that explains itself: the type is the reason
+     * that can never be fixed by editing this monitor.
+     */
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.Manual,
+        monitorSteps: undefined,
+        attachedProbeCount: 0,
+      }),
+    ).toBe(MonitorTestAvailability.MonitorTypeNotProbeable);
+  });
+
+  it("reports missing steps before missing probes", () => {
+    expect(
+      MonitorTestAvailabilityUtil.getAvailability({
+        monitorType: MonitorType.API,
+        monitorSteps: stepsWith(0),
+        attachedProbeCount: 0,
+      }),
+    ).toBe(MonitorTestAvailability.NoMonitorSteps);
+  });
+
+  it("agrees with MonitorTypeHelper.isProbableMonitor for every monitor type", () => {
+    /*
+     * The set of probeable types is not a list this rule keeps its own copy of.
+     * If a new monitor type becomes probeable, the button must follow without
+     * anyone remembering to edit this file.
+     */
+    const allTypes: Array<MonitorType> = Object.values(MonitorType);
+
+    expect(allTypes.length).toBeGreaterThan(20);
+
+    for (const monitorType of allTypes) {
+      const availability: MonitorTestAvailability =
+        MonitorTestAvailabilityUtil.getAvailability({
+          monitorType: monitorType,
+          monitorSteps: ONE_STEP,
+          attachedProbeCount: 1,
+        });
+
+      if (MonitorTypeHelper.isProbableMonitor(monitorType)) {
+        expect(availability).toBe(MonitorTestAvailability.Available);
+      } else {
+        expect(availability).toBe(
+          MonitorTestAvailability.MonitorTypeNotProbeable,
+        );
+      }
+    }
+  });
+});
+
+describe("MonitorTestAvailabilityUtil.isAvailable", () => {
+  it("is true only for the Available verdict", () => {
+    expect(
+      MonitorTestAvailabilityUtil.isAvailable({
+        monitorType: MonitorType.Port,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 1,
+      }),
+    ).toBe(true);
+
+    expect(
+      MonitorTestAvailabilityUtil.isAvailable({
+        monitorType: MonitorType.Port,
+        monitorSteps: ONE_STEP,
+        attachedProbeCount: 0,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("MonitorTestAvailabilityUtil.getMonitorStepCount", () => {
+  it("counts the steps a test would run", () => {
+    expect(MonitorTestAvailabilityUtil.getMonitorStepCount(stepsWith(3))).toBe(
+      3,
+    );
+  });
+
+  it("answers zero for every shape of missing steps", () => {
+    const noData: MonitorSteps = new MonitorSteps();
+    noData.data = undefined;
+
+    expect(MonitorTestAvailabilityUtil.getMonitorStepCount(undefined)).toBe(0);
+    expect(MonitorTestAvailabilityUtil.getMonitorStepCount(null)).toBe(0);
+    expect(MonitorTestAvailabilityUtil.getMonitorStepCount(noData)).toBe(0);
+    expect(MonitorTestAvailabilityUtil.getMonitorStepCount(stepsWith(0))).toBe(
+      0,
+    );
+  });
+});

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

@@ -1,6 +1,8 @@
 import {
   MAX_HOST_IP_ADDRESSES_LENGTH,
   MAX_HOST_IP_ADDRESS_COUNT,
+  MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH,
+  MAX_INVENTORY_HOST_IP_ADDRESS_COUNT,
   normalizeHostIpAddresses,
 } from "../../../Utils/Telemetry/HostIpAddresses";
 import { describe, expect, test } from "@jest/globals";
@@ -288,4 +290,107 @@ describe("normalizeHostIpAddresses", () => {
       expect(twice).toBe(once);
     });
   });
+
+  /*
+   * Issue #3866 gave the Inventory item's `host.ip` attribute its own, much
+   * smaller caps. The Host column stays the lossless record; the inventory
+   * value is a CMDB summary that has to fit one row of a definition list.
+   */
+  describe("inventory caps (issue #3866)", () => {
+    const INVENTORY: { maxCount: number; maxLength: number } = {
+      maxCount: MAX_INVENTORY_HOST_IP_ADDRESS_COUNT,
+      maxLength: MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH,
+    };
+
+    test("omitting options reproduces the Host column behaviour exactly", () => {
+      const addresses: Array<string> = issueReporterAddresses();
+      expect(normalizeHostIpAddresses(addresses, {})).toBe(
+        normalizeHostIpAddresses(addresses),
+      );
+      expect(
+        normalizeHostIpAddresses(addresses, {
+          maxCount: undefined,
+          maxLength: undefined,
+        }),
+      ).toBe(normalizeHostIpAddresses(addresses));
+    });
+
+    test("the inventory caps are far below the Host column's", () => {
+      expect(MAX_INVENTORY_HOST_IP_ADDRESS_COUNT).toBeLessThan(
+        MAX_HOST_IP_ADDRESS_COUNT,
+      );
+      expect(MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH).toBeLessThan(
+        MAX_HOST_IP_ADDRESSES_LENGTH,
+      );
+    });
+
+    /*
+     * The property that matters: for every host small enough to fit, the
+     * Network card and a CMDB export read the same string. Truncation is
+     * the only thing the two surfaces are allowed to disagree about.
+     */
+    test("a host below both cap sets serializes identically either way", () => {
+      const addresses: Array<string> = [
+        "192.168.1.42",
+        "10.0.0.7",
+        "fe80::42:acff:fe11:1",
+      ];
+      expect(normalizeHostIpAddresses(addresses, INVENTORY)).toBe(
+        normalizeHostIpAddresses(addresses),
+      );
+    });
+
+    test("the issue-#3006 payload truncates to a prefix of the full result", () => {
+      const addresses: Array<string> = issueReporterAddresses();
+      const full: string = normalizeHostIpAddresses(addresses) as string;
+      const capped: string = normalizeHostIpAddresses(
+        addresses,
+        INVENTORY,
+      ) as string;
+
+      expect(capped.length).toBeLessThan(full.length);
+      expect(full.startsWith(capped)).toBe(true);
+    });
+
+    test("truncation drops whole addresses, never a fragment", () => {
+      const addresses: Array<string> = issueReporterAddresses();
+      const capped: string = normalizeHostIpAddresses(
+        addresses,
+        INVENTORY,
+      ) as string;
+
+      expect(capped.length).toBeLessThanOrEqual(
+        MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH,
+      );
+      for (const address of capped.split(", ")) {
+        expect(addresses).toContain(address);
+      }
+    });
+
+    test("the count cap bites before the length cap on short addresses", () => {
+      const addresses: Array<string> = [];
+      for (let i: number = 0; i < 100; i++) {
+        addresses.push(`10.0.${i}.1`);
+      }
+      const capped: string = normalizeHostIpAddresses(
+        addresses,
+        INVENTORY,
+      ) as string;
+      expect(capped.split(", ")).toHaveLength(
+        MAX_INVENTORY_HOST_IP_ADDRESS_COUNT,
+      );
+    });
+
+    test.each([
+      ["an empty list", []],
+      ["whitespace only", ["  ", "\t"]],
+    ])(
+      "%s is null under the inventory caps too",
+      (_l: string, input: unknown) => {
+        expect(
+          normalizeHostIpAddresses(input as Array<string>, INVENTORY),
+        ).toBeNull();
+      },
+    );
+  });
 });