@oneuptime/common 12.0.12 → 12.0.13

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

@@ -0,0 +1,360 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import MonitorType, {
+  MonitorTypeCategory,
+  MonitorTypeHelper,
+  MonitorTypeProps,
+} from "../../../Types/Monitor/MonitorType";
+import {
+  CardSelectOption,
+  cardSelectOptionMatchesSearch,
+  getCardSelectOptionSearchScore,
+  getCardSelectSearchTokens,
+} from "../../../UI/Components/CardSelect/CardSelect";
+
+/*
+ * The monitor type picker offers 29 types. Whether someone finds the right one
+ * comes down to whether the words they already use - "k8s", "postgres",
+ * "heartbeat", "tls" - are attached to the card, because none of them appear
+ * in its title or its copy. These are the searches this catalog promises to
+ * answer.
+ */
+
+const allProps: Array<MonitorTypeProps> =
+  MonitorTypeHelper.getAllMonitorTypeProps();
+
+type PropsForFunction = (monitorType: MonitorType) => MonitorTypeProps;
+
+const propsFor: PropsForFunction = (
+  monitorType: MonitorType,
+): MonitorTypeProps => {
+  const found: MonitorTypeProps | undefined = allProps.find(
+    (item: MonitorTypeProps) => {
+      return item.monitorType === monitorType;
+    },
+  );
+
+  if (!found) {
+    throw new Error(`No props for ${monitorType}`);
+  }
+
+  return found;
+};
+
+type ToCardOptionFunction = (monitorType: MonitorType) => CardSelectOption;
+
+const toCardOption: ToCardOptionFunction = (
+  monitorType: MonitorType,
+): CardSelectOption => {
+  const props: MonitorTypeProps = propsFor(monitorType);
+
+  return {
+    value: props.monitorType,
+    title: props.title,
+    description: props.description,
+    icon: props.icon,
+    keywords: props.keywords,
+  };
+};
+
+/*
+ * Runs a search over the whole catalog exactly the way the picker does, and
+ * returns the monitor types in the order they would be shown.
+ */
+type SearchCatalogFunction = (search: string) => Array<MonitorType>;
+
+const searchCatalog: SearchCatalogFunction = (
+  search: string,
+): Array<MonitorType> => {
+  const tokens: Array<string> = getCardSelectSearchTokens(search);
+  const categories: Array<MonitorTypeCategory> =
+    MonitorTypeHelper.getMonitorTypeCategories();
+
+  const results: Array<{ monitorType: MonitorType; score: number }> = [];
+
+  for (const category of categories) {
+    for (const monitorType of category.monitorTypes) {
+      const option: CardSelectOption = toCardOption(monitorType);
+
+      if (!cardSelectOptionMatchesSearch(option, tokens, category.label)) {
+        continue;
+      }
+
+      results.push({
+        monitorType: monitorType,
+        score: getCardSelectOptionSearchScore(option, tokens, category.label),
+      });
+    }
+  }
+
+  return results
+    .sort(
+      (
+        a: { monitorType: MonitorType; score: number },
+        b: { monitorType: MonitorType; score: number },
+      ) => {
+        const scoreDifference: number = b.score - a.score;
+
+        if (scoreDifference !== 0) {
+          return scoreDifference;
+        }
+
+        return propsFor(a.monitorType).title.localeCompare(
+          propsFor(b.monitorType).title,
+        );
+      },
+    )
+    .map((result: { monitorType: MonitorType; score: number }) => {
+      return result.monitorType;
+    });
+};
+
+describe("MonitorType keywords", () => {
+  describe("every monitor type carries usable keywords", () => {
+    test("no monitor type is left without any", () => {
+      for (const props of allProps) {
+        expect(Array.isArray(props.keywords)).toBe(true);
+        expect(props.keywords.length).toBeGreaterThan(0);
+      }
+    });
+
+    test("every enum member has props, so nothing can be searched for and missed", () => {
+      const covered: Array<MonitorType> = allProps.map(
+        (props: MonitorTypeProps) => {
+          return props.monitorType;
+        },
+      );
+
+      for (const monitorType of Object.values(MonitorType)) {
+        expect(covered).toContain(monitorType);
+      }
+    });
+
+    test("keywords are lower case, so a search never misses on case alone", () => {
+      for (const props of allProps) {
+        for (const keyword of props.keywords) {
+          expect(keyword).toBe(keyword.toLowerCase());
+        }
+      }
+    });
+
+    test("keywords are trimmed and non-empty", () => {
+      for (const props of allProps) {
+        for (const keyword of props.keywords) {
+          expect(keyword).toBe(keyword.trim());
+          expect(keyword.length).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    test("a monitor type does not repeat the same keyword", () => {
+      for (const props of allProps) {
+        expect(new Set(props.keywords).size).toBe(props.keywords.length);
+      }
+    });
+
+    /*
+     * A keyword that only repeats the title earns nothing - the title is
+     * already searched. Every type must add at least one word the card does
+     * not already say.
+     */
+    test("each type adds at least one word its title does not already contain", () => {
+      for (const props of allProps) {
+        const title: string = props.title.toLowerCase();
+
+        const addsSomething: boolean = props.keywords.some(
+          (keyword: string) => {
+            return !title.includes(keyword);
+          },
+        );
+
+        expect({
+          monitorType: props.monitorType,
+          addsSomething: addsSomething,
+        }).toEqual({ monitorType: props.monitorType, addsSomething: true });
+      }
+    });
+  });
+
+  describe("getKeywords", () => {
+    test("returns the configured keywords", () => {
+      expect(MonitorTypeHelper.getKeywords(MonitorType.Kubernetes)).toContain(
+        "k8s",
+      );
+    });
+
+    test("throws BadDataException for a type without props", () => {
+      expect(() => {
+        MonitorTypeHelper.getKeywords("NonExistent" as MonitorType);
+      }).toThrowError(BadDataException);
+    });
+  });
+
+  describe("card copy is scannable", () => {
+    /*
+     * Every description used to open with "This monitor type lets you
+     * monitor", so the first five words of all 29 cards were identical and
+     * carried nothing. Reading the grid meant skipping them 29 times.
+     */
+    test("no description opens with the old boilerplate", () => {
+      for (const props of allProps) {
+        expect({
+          monitorType: props.monitorType,
+          startsWithBoilerplate: props.description
+            .toLowerCase()
+            .startsWith("this monitor type"),
+        }).toEqual({
+          monitorType: props.monitorType,
+          startsWithBoilerplate: false,
+        });
+      }
+    });
+
+    test("descriptions stay short enough to keep the cards an even height", () => {
+      for (const props of allProps) {
+        expect({
+          monitorType: props.monitorType,
+          tooLong: props.description.length > 100,
+        }).toEqual({ monitorType: props.monitorType, tooLong: false });
+      }
+    });
+
+    test("descriptions are still there and still say something", () => {
+      for (const props of allProps) {
+        expect(props.description.trim().length).toBeGreaterThan(20);
+      }
+    });
+  });
+
+  describe("the searches the catalog promises to answer", () => {
+    test.each([
+      ["k8s", MonitorType.Kubernetes],
+      ["kubernetes", MonitorType.Kubernetes],
+      ["eks", MonitorType.Kubernetes],
+      ["postgres", MonitorType.SQLQuery],
+      ["postgresql", MonitorType.SQLQuery],
+      ["mysql", MonitorType.SQLQuery],
+      ["database", MonitorType.SQLQuery],
+      ["heartbeat", MonitorType.IncomingRequest],
+      ["cron", MonitorType.IncomingRequest],
+      ["webhook", MonitorType.IncomingRequest],
+      ["tls", MonitorType.SSLCertificate],
+      ["cert", MonitorType.SSLCertificate],
+      ["x509", MonitorType.SSLCertificate],
+      ["url", MonitorType.Website],
+      ["icmp", MonitorType.Ping],
+      ["tcp", MonitorType.Port],
+      ["udp", MonitorType.Port],
+      ["ipv6", MonitorType.IP],
+      ["whois", MonitorType.Domain],
+      ["aws", MonitorType.ExternalStatusPage],
+      ["cloudflare", MonitorType.ExternalStatusPage],
+      ["cname", MonitorType.DNS],
+      ["dnskey", MonitorType.DNSSEC],
+      ["snmp", MonitorType.NetworkDevice],
+      ["router", MonitorType.NetworkDevice],
+      ["prometheus", MonitorType.Metrics],
+      ["apm", MonitorType.Traces],
+      ["stack trace", MonitorType.Exceptions],
+      ["playwright", MonitorType.SyntheticMonitor],
+      ["javascript", MonitorType.CustomJavaScriptCode],
+      ["rootless", MonitorType.Podman],
+      ["lxc", MonitorType.Proxmox],
+      ["osd", MonitorType.Ceph],
+      ["sensor", MonitorType.IoTDevice],
+      ["imap", MonitorType.IncomingEmail],
+    ])(
+      "ranks %s first, and it is %s",
+      (search: string, expected: MonitorType) => {
+        const results: Array<MonitorType> = searchCatalog(search);
+
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0]).toBe(expected);
+      },
+    );
+
+    test("a plain title search still wins over anything that merely mentions it", () => {
+      expect(searchCatalog("ping")[0]).toBe(MonitorType.Ping);
+      expect(searchCatalog("domain")[0]).toBe(MonitorType.Domain);
+      expect(searchCatalog("logs")[0]).toBe(MonitorType.Logs);
+    });
+
+    test("words describing the job, in any order, find the type", () => {
+      expect(searchCatalog("expiry certificate")).toContain(
+        MonitorType.SSLCertificate,
+      );
+      expect(searchCatalog("certificate expiry")).toContain(
+        MonitorType.SSLCertificate,
+      );
+    });
+
+    test("a category name gathers everything under it", () => {
+      const results: Array<MonitorType> = searchCatalog("infrastructure");
+
+      expect(results).toContain(MonitorType.Kubernetes);
+      expect(results).toContain(MonitorType.Docker);
+      expect(results).toContain(MonitorType.Ceph);
+      expect(results).not.toContain(MonitorType.Website);
+    });
+
+    test("a word nothing uses returns nothing rather than everything", () => {
+      expect(searchCatalog("mainframe")).toEqual([]);
+    });
+
+    test("an empty search returns the whole catalog", () => {
+      const categories: Array<MonitorTypeCategory> =
+        MonitorTypeHelper.getMonitorTypeCategories();
+
+      const total: number = categories.reduce(
+        (count: number, category: MonitorTypeCategory) => {
+          return count + category.monitorTypes.length;
+        },
+        0,
+      );
+
+      expect(searchCatalog("").length).toBe(total);
+    });
+  });
+
+  describe("the catalog the picker actually offers", () => {
+    test("every categorised type has props to render", () => {
+      const categories: Array<MonitorTypeCategory> =
+        MonitorTypeHelper.getMonitorTypeCategories();
+
+      for (const category of categories) {
+        for (const monitorType of category.monitorTypes) {
+          expect(() => {
+            return propsFor(monitorType);
+          }).not.toThrow();
+        }
+      }
+    });
+
+    test("no monitor type is listed under two categories, which would render it twice", () => {
+      const categories: Array<MonitorTypeCategory> =
+        MonitorTypeHelper.getMonitorTypeCategories();
+
+      const seen: Array<MonitorType> = [];
+
+      for (const category of categories) {
+        for (const monitorType of category.monitorTypes) {
+          expect(seen).not.toContain(monitorType);
+          seen.push(monitorType);
+        }
+      }
+    });
+
+    /*
+     * The first category is the one the picker leaves open, so it has to be
+     * the one most people want. Everything else starts closed behind a count.
+     */
+    test("the category shown open by default is the everyday one", () => {
+      const categories: Array<MonitorTypeCategory> =
+        MonitorTypeHelper.getMonitorTypeCategories();
+
+      expect(categories[0]?.label).toBe("Basic Monitoring");
+      expect(categories[0]?.monitorTypes).toContain(MonitorType.Website);
+      expect(categories[0]?.monitorTypes).toContain(MonitorType.API);
+      expect(categories[0]?.monitorTypes).toContain(MonitorType.Ping);
+    });
+  });
+});

package/Tests/Types/StatusPage/SearchEngineIndexing.test.ts

@@ -0,0 +1,86 @@
+/**
+ * The single place that decides "is this status page indexable?".
+ *
+ * Every renderer feeds this the raw flag off the /seo API response, and the
+ * answer decides whether a <meta name="robots"> and an X-Robots-Tag go out.
+ * The interesting half is what it does with values that are NOT an explicit
+ * off - a missing field, a null, an API that did not answer - because that is
+ * the state the internal HTTP call lands in whenever anything goes wrong, and
+ * it must resolve to "indexable" rather than silently de-indexing pages whose
+ * owners never asked for it.
+ */
+
+import {
+  NOINDEX_ROBOTS_DIRECTIVE,
+  SEARCH_ENGINE_INDEXING_FLAG_NAME,
+  X_ROBOTS_TAG_HEADER_NAME,
+  isSearchEngineIndexingEnabled,
+} from "../../../Types/StatusPage/SearchEngineIndexing";
+import { describe, expect, test } from "@jest/globals";
+
+describe("isSearchEngineIndexingEnabled", () => {
+  test("the owner turning the toggle off is the only thing that blocks indexing", () => {
+    expect(isSearchEngineIndexingEnabled(false)).toBe(false);
+  });
+
+  test("the toggle left on indexes", () => {
+    expect(isSearchEngineIndexingEnabled(true)).toBe(true);
+  });
+
+  test("a JSON round-trip that stringified the boolean still reads as off", () => {
+    /*
+     * The flag crosses an HTTP boundary between the API and the two frontend
+     * servers. A serializer that renders booleans as strings must not turn an
+     * opt-out back into an opt-in.
+     */
+    expect(isSearchEngineIndexingEnabled("false")).toBe(false);
+    expect(isSearchEngineIndexingEnabled("true")).toBe(true);
+  });
+
+  describe("anything that is not an explicit off leaves the page indexable", () => {
+    /*
+     * These are the shapes an unreachable or older /seo API produces. Reading
+     * any of them as "noindex" would take a page out of Google over a blip on
+     * an internal HTTP call - a failure the owner never asked for and would
+     * have no way to see.
+     */
+    const notAnExplicitOff: Array<[string, unknown]> = [
+      ["field absent from the response", undefined],
+      ["field present but null", null],
+      ["empty string", ""],
+      ["zero", 0],
+      ["the string 'no'", "no"],
+      ["the string 'FALSE' in the wrong case", "FALSE"],
+      ["an object", {}],
+    ];
+
+    test.each(notAnExplicitOff)("%s", (_label: string, value: unknown) => {
+      expect(isSearchEngineIndexingEnabled(value)).toBe(true);
+    });
+  });
+});
+
+describe("the directives that go on the wire", () => {
+  /*
+   * Pinned strings. Crawlers parse these literally, so a typo here is a
+   * feature that silently does nothing - the page keeps being indexed and
+   * nothing errors.
+   */
+  test("the robots directive is noindex, nofollow", () => {
+    expect(NOINDEX_ROBOTS_DIRECTIVE).toBe("noindex, nofollow");
+  });
+
+  test("the response header is X-Robots-Tag", () => {
+    expect(X_ROBOTS_TAG_HEADER_NAME).toBe("X-Robots-Tag");
+  });
+
+  test("the API/template flag name matches the model column name", () => {
+    /*
+     * The /seo API keys its response off this constant, and index.ejs reads a
+     * variable of the same name. Renaming the column without renaming this
+     * would leave the template reading undefined - which reads as indexable,
+     * so the toggle would just stop working, quietly.
+     */
+    expect(SEARCH_ENGINE_INDEXING_FLAG_NAME).toBe("enableSearchEngineIndexing");
+  });
+});

package/Tests/Types/Telemetry/ResourceEntityFacet.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  ALL_RESOURCE_FACET_KEYS,
+  MAX_RESOURCE_IDS_PER_FACET,
+  RESOURCE_ENTITY_FACET_KEYS,
+  ResourceEntityFacetSelections,
+  SERVICE_FACET_KEYS,
+  collectResourceEntityFacetSelections,
+  collectServiceFacetSelections,
+  hasResourceEntityFacetSelections,
+  isResourceEntityFacetKey,
+  isResourceFacetKey,
+  isServiceFacetKey,
+  parseResourceEntityFacetSelections,
+} from "../../../Types/Telemetry/ResourceEntityFacet";
+
+/*
+ * The split this module encodes is the whole fix for issue #3216: the
+ * Services facet reads out of `primaryEntityId`, every other resource facet
+ * has to be resolved through the resource's entity key. Getting a key into
+ * the wrong bucket silently reintroduces the bug (a cluster id compared
+ * against a column that only holds Service ids), so the classification is
+ * pinned here rather than left to the call sites.
+ */
+
+const CLUSTER_ID: string = "8c0f2f1e-2e4f-4a8c-9a1a-2f5b6c7d8e9f";
+const OTHER_CLUSTER_ID: string = "1a2b3c4d-5e6f-4071-8293-a4b5c6d7e8f9";
+const HOST_ID: string = "5f4e3d2c-1b0a-4998-8776-655443322110";
+const SERVICE_ID: string = "0d1c2b3a-4958-4867-9776-8574a3b2c1d0";
+
+function facetMap(
+  entries: Record<string, Array<string>>,
+): Map<string, Set<string>> {
+  const map: Map<string, Set<string>> = new Map();
+
+  for (const [key, values] of Object.entries(entries)) {
+    map.set(key, new Set(values));
+  }
+
+  return map;
+}
+
+describe("ResourceEntityFacet", () => {
+  describe("facet classification", () => {
+    test("the Services facet and its pre-rename alias read out of primaryEntityId", () => {
+      expect(isServiceFacetKey("primaryEntityId")).toBe(true);
+      expect(isServiceFacetKey("serviceId")).toBe(true);
+      expect(isResourceEntityFacetKey("primaryEntityId")).toBe(false);
+      expect(isResourceEntityFacetKey("serviceId")).toBe(false);
+    });
+
+    test("every non-Service resource facet needs entity-key resolution", () => {
+      for (const facetKey of [
+        "hostId",
+        "dockerHostId",
+        "podmanHostId",
+        "kubernetesClusterId",
+      ]) {
+        expect(isResourceEntityFacetKey(facetKey)).toBe(true);
+        expect(isServiceFacetKey(facetKey)).toBe(false);
+      }
+    });
+
+    test("non-resource facets belong to neither group", () => {
+      for (const facetKey of [
+        "severityText",
+        "traceId",
+        "spanId",
+        "attributes.k8s.cluster.name",
+        "",
+      ]) {
+        expect(isResourceFacetKey(facetKey)).toBe(false);
+      }
+    });
+
+    test("the combined list is exactly the two groups, with no overlap", () => {
+      expect(ALL_RESOURCE_FACET_KEYS).toEqual([
+        ...SERVICE_FACET_KEYS,
+        ...RESOURCE_ENTITY_FACET_KEYS,
+      ]);
+      expect(new Set(ALL_RESOURCE_FACET_KEYS).size).toBe(
+        ALL_RESOURCE_FACET_KEYS.length,
+      );
+    });
+  });
+
+  describe("collectResourceEntityFacetSelections", () => {
+    test("keeps each facet's ids under its own key", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          facetMap({
+            kubernetesClusterId: [CLUSTER_ID],
+            hostId: [HOST_ID],
+          }).entries(),
+        );
+
+      expect(selections).toEqual({
+        kubernetesClusterId: [CLUSTER_ID],
+        hostId: [HOST_ID],
+      });
+    });
+
+    test("leaves Service selections out — they are not entity-key resolved", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          facetMap({
+            primaryEntityId: [SERVICE_ID],
+            serviceId: [SERVICE_ID],
+            severityText: ["Error"],
+          }).entries(),
+        );
+
+      expect(selections).toEqual({});
+    });
+
+    test("accepts a plain record via Object.entries (the traces explorer's shape)", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({
+            kubernetesClusterId: [CLUSTER_ID, OTHER_CLUSTER_ID],
+          }),
+        );
+
+      expect(selections["kubernetesClusterId"]).toEqual([
+        CLUSTER_ID,
+        OTHER_CLUSTER_ID,
+      ]);
+    });
+
+    test("de-duplicates repeated ids within one facet", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({
+            kubernetesClusterId: [CLUSTER_ID, CLUSTER_ID],
+          }),
+        );
+
+      expect(selections["kubernetesClusterId"]).toEqual([CLUSTER_ID]);
+    });
+
+    test("drops a facet whose last chip was just removed rather than emitting []", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          facetMap({ kubernetesClusterId: [] }).entries(),
+        );
+
+      expect(selections).toEqual({});
+      expect(hasResourceEntityFacetSelections(selections)).toBe(false);
+    });
+
+    test("skips blank values", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({ hostId: ["", HOST_ID] }),
+        );
+
+      expect(selections["hostId"]).toEqual([HOST_ID]);
+    });
+  });
+
+  describe("collectServiceFacetSelections", () => {
+    test("unions the canonical key and its alias", () => {
+      expect(
+        collectServiceFacetSelections(
+          facetMap({
+            primaryEntityId: [SERVICE_ID],
+            serviceId: [SERVICE_ID, HOST_ID],
+          }).entries(),
+        ),
+      ).toEqual([SERVICE_ID, HOST_ID]);
+    });
+
+    test("ignores non-Service resource facets", () => {
+      expect(
+        collectServiceFacetSelections(
+          facetMap({ kubernetesClusterId: [CLUSTER_ID] }).entries(),
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("parseResourceEntityFacetSelections", () => {
+    test("accepts a well-formed selection map", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: [CLUSTER_ID],
+        }),
+      ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
+    });
+
+    test("drops unknown facet keys", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: [CLUSTER_ID],
+          primaryEntityId: [SERVICE_ID],
+          somethingElse: [CLUSTER_ID],
+        }),
+      ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
+    });
+
+    test("drops ids that are not ObjectID strings", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: [CLUSTER_ID, "not-an-id", "'; DROP TABLE --"],
+        }),
+      ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
+    });
+
+    test("a facet left with no valid id is dropped entirely", () => {
+      expect(parseResourceEntityFacetSelections({ hostId: ["nope"] })).toEqual(
+        {},
+      );
+    });
+
+    test("non-array values carry no filter", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: CLUSTER_ID,
+        }),
+      ).toEqual({});
+    });
+
+    test("junk input parses to no constraint rather than throwing", () => {
+      for (const junk of [undefined, null, "", 0, [], "string", true]) {
+        expect(parseResourceEntityFacetSelections(junk)).toEqual({});
+      }
+    });
+
+    test("caps the id list so a crafted request cannot send an unbounded IN", () => {
+      const many: Array<string> = Array.from(
+        { length: MAX_RESOURCE_IDS_PER_FACET + 25 },
+        (_unused: unknown, index: number): string => {
+          return `00000000-0000-4000-8000-${String(index).padStart(12, "0")}`;
+        },
+      );
+
+      const parsed: ResourceEntityFacetSelections =
+        parseResourceEntityFacetSelections({ kubernetesClusterId: many });
+
+      expect(parsed["kubernetesClusterId"]).toHaveLength(
+        MAX_RESOURCE_IDS_PER_FACET,
+      );
+    });
+
+    test("de-duplicates before capping", () => {
+      const parsed: ResourceEntityFacetSelections =
+        parseResourceEntityFacetSelections({
+          hostId: [HOST_ID, HOST_ID, HOST_ID],
+        });
+
+      expect(parsed["hostId"]).toEqual([HOST_ID]);
+    });
+  });
+});