@oneuptime/common 13.0.3 → 13.0.5

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

@@ -0,0 +1,304 @@
+import { describe, expect, test } from "@jest/globals";
+import IconProp from "../../../Types/Icon/IconProp";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import {
+  RESOURCE_FACET_CATALOG,
+  RESOURCE_FACET_CATALOG_KEYS,
+  ResourceFacetDefinition,
+  getResourceFacetDefinition,
+  getResourceFacetLabelMap,
+  getResourceFacetServiceTypeMap,
+  isCatalogResourceFacetKey,
+} from "../../../Types/Telemetry/ResourceFacetCatalog";
+
+/*
+ * The catalog is the single list every resource facet table is derived from
+ * — the facet keys the explorers request, the ServiceType each aggregation
+ * service counts under, the keys the server lists from Postgres and the keys
+ * a selection is parsed for. A wrong row here is wrong everywhere at once,
+ * so its contents are pinned explicitly rather than re-derived.
+ */
+
+type CatalogRow = [
+  facetKey: string,
+  serviceType: ServiceType,
+  label: string,
+  pluralLabel: string,
+  icon: IconProp,
+];
+
+// Catalog (= sidebar) order.
+const EXPECTED_CATALOG: Array<CatalogRow> = [
+  ["hostId", ServiceType.Host, "Host", "Hosts", IconProp.Server],
+  [
+    "dockerHostId",
+    ServiceType.DockerHost,
+    "Docker Host",
+    "Docker Hosts",
+    IconProp.Docker,
+  ],
+  [
+    "podmanHostId",
+    ServiceType.PodmanHost,
+    "Podman Host",
+    "Podman Hosts",
+    IconProp.Podman,
+  ],
+  [
+    "kubernetesClusterId",
+    ServiceType.KubernetesCluster,
+    "Kubernetes Cluster",
+    "Kubernetes Clusters",
+    IconProp.Kubernetes,
+  ],
+  [
+    "dockerSwarmClusterId",
+    ServiceType.DockerSwarmCluster,
+    "Docker Swarm Cluster",
+    "Docker Swarm Clusters",
+    IconProp.DockerSwarm,
+  ],
+  [
+    "proxmoxClusterId",
+    ServiceType.ProxmoxCluster,
+    "Proxmox Cluster",
+    "Proxmox Clusters",
+    IconProp.Proxmox,
+  ],
+  [
+    "vmwareVCenterId",
+    ServiceType.VMwareVCenter,
+    "vCenter",
+    "vCenters",
+    IconProp.VMware,
+  ],
+  [
+    "cephClusterId",
+    ServiceType.CephCluster,
+    "Ceph Cluster",
+    "Ceph Clusters",
+    IconProp.Ceph,
+  ],
+  [
+    "serverlessFunctionId",
+    ServiceType.ServerlessFunction,
+    "Serverless Function",
+    "Serverless Functions",
+    IconProp.Bolt,
+  ],
+  [
+    "cloudResourceId",
+    ServiceType.CloudResource,
+    "Cloud Resource",
+    "Cloud Resources",
+    IconProp.Cloud,
+  ],
+  [
+    "rumApplicationId",
+    ServiceType.RealUserMonitor,
+    "RUM Application",
+    "RUM Applications",
+    IconProp.Globe,
+  ],
+  [
+    "iotFleetId",
+    ServiceType.IoTDevice,
+    "IoT Fleet",
+    "IoT Fleets",
+    IconProp.IoT,
+  ],
+];
+
+const EXPECTED_KEYS: Array<string> = EXPECTED_CATALOG.map(
+  (row: CatalogRow): string => {
+    return row[0];
+  },
+);
+
+describe("ResourceFacetCatalog", () => {
+  describe("contents", () => {
+    test("lists exactly the twelve non-Service resource types, in sidebar order", () => {
+      expect(RESOURCE_FACET_CATALOG).toHaveLength(12);
+      expect([...RESOURCE_FACET_CATALOG_KEYS]).toEqual(EXPECTED_KEYS);
+    });
+
+    test.each(EXPECTED_CATALOG)(
+      "%s is counted as %s, labelled %s / %s with the %s icon",
+      (
+        facetKey: string,
+        serviceType: ServiceType,
+        label: string,
+        pluralLabel: string,
+        icon: IconProp,
+      ) => {
+        expect(getResourceFacetDefinition(facetKey)).toEqual({
+          facetKey,
+          serviceType,
+          label,
+          pluralLabel,
+          icon,
+        });
+      },
+    );
+
+    test("RESOURCE_FACET_CATALOG_KEYS mirrors the catalog entry by entry", () => {
+      expect([...RESOURCE_FACET_CATALOG_KEYS]).toEqual(
+        RESOURCE_FACET_CATALOG.map(
+          (definition: ResourceFacetDefinition): string => {
+            return definition.facetKey;
+          },
+        ),
+      );
+    });
+  });
+
+  describe("invariants", () => {
+    test("facet keys are unique", () => {
+      expect(new Set(RESOURCE_FACET_CATALOG_KEYS).size).toBe(
+        RESOURCE_FACET_CATALOG_KEYS.length,
+      );
+    });
+
+    test.each(EXPECTED_KEYS)(
+      "%s is a lowerCamelCase id key ending in Id",
+      (facetKey: string) => {
+        expect(facetKey).toMatch(/^[a-z][A-Za-z0-9]*Id$/);
+      },
+    );
+
+    test("no entry reuses a Service facet key or a ClickHouse column", () => {
+      for (const reserved of [
+        "primaryEntityId",
+        "serviceId",
+        "traceId",
+        "spanId",
+        "parentSpanId",
+      ]) {
+        expect(RESOURCE_FACET_CATALOG_KEYS).not.toContain(reserved);
+      }
+    });
+
+    test("no entry is counted as a Service", () => {
+      for (const definition of RESOURCE_FACET_CATALOG) {
+        expect(definition.serviceType).not.toBe(ServiceType.OpenTelemetry);
+        expect(definition.serviceType).not.toBe(ServiceType.Unknown);
+        expect(Object.values(ServiceType)).toContain(definition.serviceType);
+      }
+    });
+
+    test("every entry counts under its own ServiceType, so no two facets share rows", () => {
+      const serviceTypes: Array<ServiceType> = RESOURCE_FACET_CATALOG.map(
+        (definition: ResourceFacetDefinition): ServiceType => {
+          return definition.serviceType;
+        },
+      );
+
+      expect(new Set(serviceTypes).size).toBe(serviceTypes.length);
+    });
+
+    test("IoT fleets count under IoTDevice — ingest stamps the fleet id with that type", () => {
+      expect(getResourceFacetDefinition("iotFleetId")?.serviceType).toBe(
+        ServiceType.IoTDevice,
+      );
+    });
+
+    test("RUM applications count under RealUserMonitor", () => {
+      expect(getResourceFacetDefinition("rumApplicationId")?.serviceType).toBe(
+        ServiceType.RealUserMonitor,
+      );
+    });
+
+    test("labels and plural labels are non-blank, trimmed and distinct", () => {
+      const labels: Array<string> = [];
+      const pluralLabels: Array<string> = [];
+
+      for (const definition of RESOURCE_FACET_CATALOG) {
+        expect(definition.label.trim()).toBe(definition.label);
+        expect(definition.label.length).toBeGreaterThan(0);
+        expect(definition.pluralLabel.trim()).toBe(definition.pluralLabel);
+        expect(definition.pluralLabel.length).toBeGreaterThan(0);
+        expect(definition.pluralLabel).not.toBe(definition.label);
+
+        labels.push(definition.label);
+        pluralLabels.push(definition.pluralLabel);
+      }
+
+      expect(new Set(labels).size).toBe(labels.length);
+      expect(new Set(pluralLabels).size).toBe(pluralLabels.length);
+    });
+
+    test("every entry has a real icon", () => {
+      for (const definition of RESOURCE_FACET_CATALOG) {
+        expect(definition.icon).toBeDefined();
+        expect(Object.values(IconProp)).toContain(definition.icon);
+      }
+    });
+  });
+
+  describe("lookups", () => {
+    test.each(EXPECTED_KEYS)("%s is a catalog key", (facetKey: string) => {
+      expect(isCatalogResourceFacetKey(facetKey)).toBe(true);
+      expect(getResourceFacetDefinition(facetKey)?.facetKey).toBe(facetKey);
+    });
+
+    test.each([
+      "primaryEntityId",
+      "serviceId",
+      "severityText",
+      "statusCode",
+      "",
+      "HostId",
+      "hostid",
+      " hostId",
+      "hostId ",
+      "resource.host.name",
+      "constructor",
+      "toString",
+      "__proto__",
+      "iotDeviceId",
+    ])("%j is not a catalog key", (facetKey: string) => {
+      expect(isCatalogResourceFacetKey(facetKey)).toBe(false);
+      expect(getResourceFacetDefinition(facetKey)).toBeUndefined();
+    });
+  });
+
+  describe("derived tables", () => {
+    test("getResourceFacetServiceTypeMap maps every key to its ServiceType, in catalog order", () => {
+      const map: Map<string, ServiceType> = getResourceFacetServiceTypeMap();
+
+      expect(Array.from(map.entries())).toEqual(
+        EXPECTED_CATALOG.map((row: CatalogRow): [string, ServiceType] => {
+          return [row[0], row[1]];
+        }),
+      );
+    });
+
+    test("getResourceFacetServiceTypeMap returns a fresh map each call, so a caller cannot corrupt another's", () => {
+      const first: Map<string, ServiceType> = getResourceFacetServiceTypeMap();
+      first.delete("hostId");
+      first.set("bogusId", ServiceType.Host);
+
+      const second: Map<string, ServiceType> = getResourceFacetServiceTypeMap();
+
+      expect(second.get("hostId")).toBe(ServiceType.Host);
+      expect(second.has("bogusId")).toBe(false);
+    });
+
+    test("getResourceFacetLabelMap maps every key to its singular label", () => {
+      expect(getResourceFacetLabelMap()).toEqual(
+        Object.fromEntries(
+          EXPECTED_CATALOG.map((row: CatalogRow): [string, string] => {
+            return [row[0], row[2]];
+          }),
+        ),
+      );
+    });
+
+    test("getResourceFacetLabelMap returns a fresh record each call", () => {
+      const first: Record<string, string> = getResourceFacetLabelMap();
+      first["hostId"] = "Mutated";
+
+      expect(getResourceFacetLabelMap()["hostId"]).toBe("Host");
+    });
+  });
+});

package/Tests/UI/Components/ActiveFilterChipsLockedFilters.test.tsx

@@ -0,0 +1,357 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+} from "@testing-library/react";
+import React from "react";
+import ActiveFilterChips from "../../../UI/Components/LogsViewer/components/ActiveFilterChips";
+import { ActiveFilter } from "../../../UI/Components/LogsViewer/types";
+import { getLockedFilterChipAriaLabel } from "../../../UI/Components/TelemetryViewer/components/LockedFilterChip";
+import {
+  getCopyLockedFiltersAriaLabel,
+  getOpenExplorerAriaLabel,
+} from "../../../UI/Components/TelemetryViewer/components/LockedFilterActions";
+import Route from "../../../Types/API/Route";
+import Includes from "../../../Types/BaseDatabase/Includes";
+
+/*
+ * The logs chip list, now that its read-only chips are LockedFilterChips: a
+ * locked chip explains itself through its detail, the copy / open actions
+ * follow the locked group, and everything the list already did — remove
+ * buttons, "Clear all", the open-trace icon-link, the operator-value
+ * backstop — is untouched.
+ */
+
+beforeEach(() => {
+  jest.useFakeTimers();
+  Object.defineProperty(navigator, "clipboard", {
+    value: {
+      writeText: jest.fn<(text: string) => Promise<void>>(
+        async (): Promise<void> => {},
+      ),
+    },
+    configurable: true,
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  jest.useRealTimers();
+});
+
+function lockedClusterChip(
+  overrides: Partial<ActiveFilter> = {},
+): ActiveFilter {
+  return {
+    facetKey: "attributes.resource.k8s.cluster.name",
+    value: "prod-eks-01",
+    displayKey: "Cluster",
+    displayValue: "production",
+    readOnly: true,
+    lockedDetail: {
+      source: "Pinned by this page",
+      summary: "Only logs from this Kubernetes cluster are shown.",
+      predicates: [
+        {
+          label: "Attribute",
+          expression: 'resource.k8s.cluster.name = "prod-eks-01"',
+        },
+      ],
+      searchToken: "@resource.k8s.cluster.name:prod-eks-01",
+    },
+    ...overrides,
+  };
+}
+
+function removableChip(overrides: Partial<ActiveFilter> = {}): ActiveFilter {
+  return {
+    facetKey: "severityText",
+    value: "Error",
+    displayKey: "Severity",
+    displayValue: "Error",
+    ...overrides,
+  };
+}
+
+async function hover(trigger: HTMLElement): Promise<void> {
+  fireEvent.mouseEnter(trigger);
+  await act(async () => {
+    jest.advanceTimersByTime(150);
+  });
+}
+
+describe("ActiveFilterChips — locked chips", () => {
+  test("a read-only chip renders as a locked chip: a named button, no remove control", () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip()]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    const chip: HTMLElement = screen.getByRole("button", {
+      name: getLockedFilterChipAriaLabel("Cluster", "production", true),
+    });
+
+    expect(chip).toHaveTextContent("Cluster:");
+    expect(chip).toHaveTextContent("production");
+    expect(screen.queryByTitle(/^Remove /)).not.toBeInTheDocument();
+  });
+
+  test("hovering the locked chip explains the filter", async () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip()]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    await hover(
+      screen.getByRole("button", {
+        name: getLockedFilterChipAriaLabel("Cluster", "production", true),
+      }),
+    );
+
+    const tooltip: HTMLElement = screen.getByRole("tooltip");
+
+    expect(tooltip).toHaveTextContent(
+      "Only logs from this Kubernetes cluster are shown.",
+    );
+    expect(tooltip).toHaveTextContent("@resource.k8s.cluster.name:prod-eks-01");
+    // The list is the logs list: it names its explorer without being told.
+    expect(tooltip).toHaveTextContent(
+      "Paste into the Logs explorer search bar.",
+    );
+  });
+
+  test("a read-only chip without a detail keeps the plain title", () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip({ lockedDetail: undefined })]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    expect(
+      document.querySelector("[title='Cluster: production (applied filter)']"),
+    ).not.toBeNull();
+  });
+
+  test("a read-only chip with an openRoute keeps its icon-link inside the pill", () => {
+    render(
+      <ActiveFilterChips
+        filters={[
+          lockedClusterChip({
+            facetKey: "traceId",
+            value: "trace-1",
+            displayKey: "Trace",
+            displayValue: "trace-1",
+            openRoute: new Route("/traces/view/trace-1"),
+          }),
+        ]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    const pill: HTMLElement = screen.getByTestId("locked-filter-chip");
+    const control: HTMLElement = screen.getByRole("button", {
+      name: getLockedFilterChipAriaLabel("Trace", "trace-1", true),
+    });
+    const link: HTMLElement = screen.getByRole("link", {
+      name: "Open trace view",
+    });
+
+    expect(pill).toContainElement(link);
+    // Beside the chip's own control, never inside it.
+    expect(control).not.toContainElement(link);
+    expect(link).toHaveAttribute("href", "/traces/view/trace-1");
+  });
+
+  test("a read-only chip without a detail is not a tab stop and has no name of its own", () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip({ lockedDetail: undefined })]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    const pill: HTMLElement = screen.getByTestId("locked-filter-chip");
+
+    expect(pill).not.toHaveAttribute("tabindex");
+    expect(pill).not.toHaveAttribute("aria-label");
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+  });
+
+  test("an operator-valued read-only chip still renders as text (the backstop)", () => {
+    render(
+      <ActiveFilterChips
+        filters={[
+          lockedClusterChip({
+            facetKey: "attributes.logtype",
+            value: new Includes(["web"]) as unknown as string,
+            displayKey: "logtype",
+            displayValue: new Includes(["web"]) as unknown as string,
+            lockedDetail: undefined,
+          }),
+        ]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    expect(document.body.textContent).not.toContain("[object Object]");
+    expect(screen.getByText("is any of web")).toBeInTheDocument();
+    expect(
+      document.querySelector(
+        "[title='logtype: is any of web (applied filter)']",
+      ),
+    ).not.toBeNull();
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+  });
+});
+
+describe("ActiveFilterChips — locked filter actions", () => {
+  test("renders the actions after the locked chips and before the removable ones", () => {
+    render(
+      <ActiveFilterChips
+        filters={[removableChip(), lockedClusterChip()]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+        lockedFilterActions={{
+          copyText: "@resource.k8s.cluster.name:prod-eks-01",
+          openExplorerRoute: new Route("/dashboard/p1/logs?filters=x"),
+        }}
+      />,
+    );
+
+    const locked: HTMLElement = screen.getByRole("button", {
+      name: getLockedFilterChipAriaLabel("Cluster", "production", true),
+    });
+    const actions: HTMLElement = screen.getByTestId("locked-filter-actions");
+    const remove: HTMLElement = screen.getByTitle("Remove Severity: Error");
+
+    expect(
+      locked.compareDocumentPosition(actions) &
+        Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy();
+    expect(
+      actions.compareDocumentPosition(remove) &
+        Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy();
+
+    expect(
+      screen.getByRole("button", {
+        name: getCopyLockedFiltersAriaLabel("Logs"),
+      }),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("link", { name: getOpenExplorerAriaLabel("Logs") }),
+    ).toHaveAttribute("href", "/dashboard/p1/logs?filters=x");
+  });
+
+  test("renders no actions when there is no locked chip, even if the host offers them", () => {
+    render(
+      <ActiveFilterChips
+        filters={[removableChip()]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+        lockedFilterActions={{ copyText: "@k:v" }}
+      />,
+    );
+
+    expect(
+      screen.queryByTestId("locked-filter-actions"),
+    ).not.toBeInTheDocument();
+  });
+
+  test("renders no actions when the host offers none", () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip()]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    expect(
+      screen.queryByTestId("locked-filter-actions"),
+    ).not.toBeInTheDocument();
+  });
+
+  test("a signal other than logs names that explorer instead", () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip()]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+        signal="traces"
+        lockedFilterActions={{ copyText: "@k:v" }}
+      />,
+    );
+
+    expect(
+      screen.getByRole("button", {
+        name: getCopyLockedFiltersAriaLabel("Traces"),
+      }),
+    ).toBeInTheDocument();
+  });
+});
+
+describe("ActiveFilterChips — unchanged behaviour", () => {
+  test("removable chips still remove and Clear all still appears for two or more", () => {
+    const removed: Array<[string, string]> = [];
+    let cleared: number = 0;
+
+    render(
+      <ActiveFilterChips
+        filters={[
+          lockedClusterChip(),
+          removableChip(),
+          removableChip({ value: "Warning", displayValue: "Warning" }),
+        ]}
+        onRemove={(facetKey: string, value: string) => {
+          removed.push([facetKey, value]);
+        }}
+        onClearAll={() => {
+          cleared += 1;
+        }}
+        lockedFilterActions={{ copyText: "@k:v" }}
+      />,
+    );
+
+    fireEvent.click(screen.getByTitle("Remove Severity: Error"));
+    expect(removed).toEqual([["severityText", "Error"]]);
+
+    fireEvent.click(screen.getByText("Clear all"));
+    expect(cleared).toBe(1);
+  });
+
+  test("renders nothing at all for an empty list", () => {
+    const { container } = render(
+      <ActiveFilterChips
+        filters={[]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+        lockedFilterActions={{ copyText: "@k:v" }}
+      />,
+    );
+
+    expect(container).toBeEmptyDOMElement();
+  });
+});