@oneuptime/common 13.0.4 → 13.0.5

package/Tests/App/Dashboard/LogsEntityChipNames.test.tsx

@@ -0,0 +1,316 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * Reported as: "In real user monitoring, when I click on metrics / logs, why
+ * does it show service id as locked filters? Why not show service name
+ * instead?"
+ *
+ * This renders the real chip component with chips built exactly the way
+ * DashboardLogsViewer builds them — the generic entity-name hook, the scope
+ * chip builder, the user-chip relabeller and the attribute chip builder —
+ * against a mocked ModelAPI, so what is asserted is the text a person sees.
+ * The wiring of these calls inside the viewer is pinned separately by
+ * App/Tests/Dashboard/LogsEntityNamesWiring.test.ts.
+ */
+
+const getListMock: MockFunction = getJestMockFunction();
+
+/*
+ * The arrow wrapper is load bearing: jest.mock is hoisted above the
+ * compiled requires, so getListMock is still unassigned when the factory
+ * runs.
+ */
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (...args: Array<any>) => {
+        return getListMock(...args);
+      },
+    },
+  };
+});
+
+import {
+  applyLogsEntityChipDisplay,
+  buildLogsEntityTypeHints,
+  buildLogsScopeEntityChips,
+  collectLogsEntityIds,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Logs/LogsEntityChipDisplay";
+import { buildAttributeFilterChips } from "../../../../App/FeatureSet/Dashboard/src/Components/Logs/LogsAttributeFilterChips";
+import ActiveFilterChips from "../../../UI/Components/LogsViewer/components/ActiveFilterChips";
+import { ActiveFilter } from "../../../UI/Components/LogsViewer/types";
+import useTelemetryEntityNames from "../../../UI/Utils/Telemetry/UseTelemetryEntityNames";
+import TelemetryEntityNameResolver, {
+  TelemetryEntityNameMap,
+} from "../../../UI/Utils/Telemetry/TelemetryEntityNames";
+import Dictionary from "../../../Types/Dictionary";
+import { DictionaryEntryValue } from "../../../UI/Components/Dictionary/DictionaryFilterOperator";
+import ObjectID from "../../../Types/ObjectID";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import ProjectUtil from "../../../UI/Utils/Project";
+
+const PROJECT_ID: string = "9e1b6b0e-0000-4000-8000-000000000021";
+const RUM_APP_ID: string = "84858d6c-0000-4000-8000-000000000001";
+const SERVICE_ID: string = "11111111-0000-4000-8000-000000000001";
+const HOST_ID: string = "33333333-0000-4000-8000-000000000001";
+
+interface GetListArgs {
+  modelType: { name: string };
+  query: { _id: { values?: Array<string>; _values?: Array<string> } };
+}
+
+/*
+ * One row per table the resolver may consult; any other table answers with
+ * nothing, the way an id that is not there would.
+ */
+const ROWS_BY_MODEL: Record<string, Array<{ id: string; name: string }>> = {
+  RumApplication: [{ id: RUM_APP_ID, name: "checkout-web" }],
+  Service: [{ id: SERVICE_ID, name: "payments-api" }],
+  Host: [{ id: HOST_ID, name: "web-01" }],
+};
+
+const queriedModels: () => Array<string> = (): Array<string> => {
+  return getListMock.mock.calls.map((call: Array<unknown>): string => {
+    return (call[0] as GetListArgs).modelType.name;
+  });
+};
+
+interface HarnessProps {
+  serviceIds?: Array<ObjectID> | undefined;
+  scopeEntityType?: ServiceType | undefined;
+  appliedFacetFilters?: Map<string, Set<string>> | undefined;
+  attributes?: Dictionary<DictionaryEntryValue> | undefined;
+  attributeFilterDisplayKeys?: Record<string, string> | undefined;
+  attributeFilterDisplayValues?: Record<string, string> | undefined;
+  onRemove?: ((facetKey: string, value: string) => void) | undefined;
+}
+
+const Harness: React.FunctionComponent<HarnessProps> = (
+  props: HarnessProps,
+): React.ReactElement => {
+  const ids: Array<string> = React.useMemo(() => {
+    return collectLogsEntityIds({
+      scopeIds: props.serviceIds,
+      appliedFacetFilters: props.appliedFacetFilters,
+    });
+  }, [props.serviceIds, props.appliedFacetFilters]);
+
+  const typeHints: Record<string, ServiceType> | undefined =
+    React.useMemo(() => {
+      return buildLogsEntityTypeHints(props.serviceIds, props.scopeEntityType);
+    }, [props.serviceIds, props.scopeEntityType]);
+
+  const nameMap: TelemetryEntityNameMap = useTelemetryEntityNames(ids, {
+    typeHints,
+  });
+
+  const baseChips: Array<ActiveFilter> = [
+    ...buildLogsScopeEntityChips({
+      scopeIds: props.serviceIds,
+      nameMap,
+      scopeEntityType: props.scopeEntityType,
+    }),
+    ...buildAttributeFilterChips(props.attributes, {
+      displayKeys: props.attributeFilterDisplayKeys,
+      displayValues: props.attributeFilterDisplayValues,
+    }),
+  ];
+
+  const userChips: Array<ActiveFilter> = [];
+  for (const [facetKey, values] of (
+    props.appliedFacetFilters || new Map<string, Set<string>>()
+  ).entries()) {
+    for (const value of values) {
+      userChips.push({
+        facetKey,
+        value,
+        displayKey: "Service",
+        displayValue: value,
+      });
+    }
+  }
+
+  return (
+    <ActiveFilterChips
+      filters={[
+        ...baseChips,
+        ...applyLogsEntityChipDisplay(userChips, {
+          nameMap,
+          scopeIds: props.serviceIds,
+          scopeEntityType: props.scopeEntityType,
+        }),
+      ]}
+      onRemove={(facetKey: string, value: string) => {
+        props.onRemove?.(facetKey, value);
+      }}
+      onClearAll={() => {}}
+    />
+  );
+};
+
+const chipText: () => string = (): string => {
+  return document.body.textContent || "";
+};
+
+beforeEach(() => {
+  TelemetryEntityNameResolver.clearCache();
+  getListMock.mockReset();
+  getListMock.mockImplementation((args: GetListArgs) => {
+    return Promise.resolve({
+      data: (ROWS_BY_MODEL[args.modelType.name] || []).map(
+        (row: { id: string; name: string }) => {
+          return { id: new ObjectID(row.id), name: row.name };
+        },
+      ),
+      count: 0,
+    });
+  });
+  jest
+    .spyOn(ProjectUtil, "getCurrentProjectId")
+    .mockReturnValue(new ObjectID(PROJECT_ID));
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("logs viewer entity chips (rendered)", () => {
+  test("RUM logs tab: the locked chip reads 'RUM Application: checkout-web', never the id", async () => {
+    render(
+      <Harness
+        serviceIds={[new ObjectID(RUM_APP_ID)]}
+        scopeEntityType={ServiceType.RealUserMonitor}
+      />,
+    );
+
+    // The type is known up front, so the key is right before the name lands.
+    expect(screen.getByText("RUM Application:")).toBeInTheDocument();
+
+    await waitFor(() => {
+      expect(screen.getByText("checkout-web")).toBeInTheDocument();
+    });
+
+    expect(chipText()).not.toContain(RUM_APP_ID);
+    expect(chipText()).not.toContain("Service:");
+  });
+
+  test("a hinted scope goes straight to its own table in one request", async () => {
+    render(
+      <Harness
+        serviceIds={[new ObjectID(RUM_APP_ID)]}
+        scopeEntityType={ServiceType.RealUserMonitor}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText("checkout-web")).toBeInTheDocument();
+    });
+
+    expect(queriedModels()).toEqual(["RumApplication"]);
+  });
+
+  test("an unhinted RUM id is still found and labelled by its real type", async () => {
+    render(<Harness serviceIds={[new ObjectID(RUM_APP_ID)]} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("checkout-web")).toBeInTheDocument();
+    });
+
+    expect(screen.getByText("RUM Application:")).toBeInTheDocument();
+    expect(chipText()).not.toContain(RUM_APP_ID);
+  });
+
+  test("a Service page is unchanged: 'Service: payments-api'", async () => {
+    render(<Harness serviceIds={[new ObjectID(SERVICE_ID)]} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("payments-api")).toBeInTheDocument();
+    });
+
+    expect(screen.getByText("Service:")).toBeInTheDocument();
+    expect(queriedModels()).toEqual(["Service"]);
+  });
+
+  test("user / URL / saved-view entity chips are named too, in the same lookup", async () => {
+    const removed: Array<[string, string]> = [];
+
+    render(
+      <Harness
+        serviceIds={[new ObjectID(RUM_APP_ID)]}
+        scopeEntityType={ServiceType.RealUserMonitor}
+        appliedFacetFilters={
+          new Map<string, Set<string>>([
+            ["primaryEntityId", new Set([HOST_ID])],
+            ["serviceId", new Set([SERVICE_ID])],
+          ])
+        }
+        onRemove={(facetKey: string, value: string) => {
+          removed.push([facetKey, value]);
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText("web-01")).toBeInTheDocument();
+    });
+
+    expect(screen.getByText("checkout-web")).toBeInTheDocument();
+    expect(screen.getByText("payments-api")).toBeInTheDocument();
+    expect(screen.getByText("Host:")).toBeInTheDocument();
+    expect(screen.getByText("RUM Application:")).toBeInTheDocument();
+    expect(chipText()).not.toContain(HOST_ID);
+    expect(chipText()).not.toContain(SERVICE_ID);
+
+    // Removing a chip still hands the viewer the id, not the name.
+    fireEvent.click(screen.getByTitle("Remove Host: web-01"));
+    expect(removed).toEqual([["primaryEntityId", HOST_ID]]);
+  });
+
+  test("resource page attribute chips show the friendly key and the page's name", () => {
+    render(
+      <Harness
+        attributes={{ "networkDevice.id": RUM_APP_ID }}
+        attributeFilterDisplayValues={{ "networkDevice.id": "core-switch-1" }}
+      />,
+    );
+
+    expect(screen.getByText("Network Device:")).toBeInTheDocument();
+    expect(screen.getByText("core-switch-1")).toBeInTheDocument();
+    expect(chipText()).not.toContain(RUM_APP_ID);
+    expect(chipText()).not.toContain("networkDevice.id");
+    // Attribute chips never trigger an entity lookup.
+    expect(getListMock).not.toHaveBeenCalled();
+  });
+
+  test("an id nobody can name falls back to 'Service: <id>' without erroring", async () => {
+    const unknownId: string = "44444444-0000-4000-8000-000000000001";
+
+    render(<Harness serviceIds={[new ObjectID(unknownId)]} />);
+
+    await waitFor(() => {
+      expect(getListMock).toHaveBeenCalled();
+    });
+
+    expect(screen.getByText("Service:")).toBeInTheDocument();
+    expect(screen.getByText(unknownId)).toBeInTheDocument();
+  });
+});

package/Tests/App/Dashboard/LogsResourceFacetChips.test.tsx

@@ -0,0 +1,361 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * "We only have some resources added to the list": a Proxmox cluster,
+ * vCenter, Ceph cluster, Docker Swarm cluster, serverless function, cloud
+ * resource, RUM application or IoT fleet chip in the Logs explorer used to
+ * read its raw facet key and a UUID ("proxmoxClusterId: 0195…").
+ *
+ * This renders the real chip component with chips built the way the
+ * Dashboard LogsViewer builds them (catalog-derived chip key labels) and
+ * then named the way the shared LogsViewer names them (one resolver request
+ * with per-facet table hints, then enrichLogsActiveFilters), against a
+ * mocked ModelAPI — so what is asserted is the text a person reads and the
+ * tables that were actually queried. The wiring of these calls inside the
+ * viewers is pinned by App/Tests/Dashboard/LogsResourceFacetsWiring.test.ts.
+ */
+
+const getListMock: MockFunction = getJestMockFunction();
+
+/*
+ * The arrow wrapper is load bearing: jest.mock is hoisted above the
+ * compiled requires, so getListMock is still unassigned when the factory
+ * runs.
+ */
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (...args: Array<any>) => {
+        return getListMock(...args);
+      },
+    },
+  };
+});
+
+import { getLogsFacetChipDisplayKey } from "../../../../App/FeatureSet/Dashboard/src/Components/Logs/LogsFacetFilters";
+import ActiveFilterChips from "../../../UI/Components/LogsViewer/components/ActiveFilterChips";
+import {
+  LogsEntityLookupMaps,
+  LogsEntityResolutionRequest,
+  collectLogsEntityIdsToResolve,
+  enrichLogsActiveFilters,
+} from "../../../UI/Components/LogsViewer/LogsEntityNames";
+import {
+  ActiveFilter,
+  FacetData,
+} from "../../../UI/Components/LogsViewer/types";
+import useTelemetryEntityNames from "../../../UI/Utils/Telemetry/UseTelemetryEntityNames";
+import TelemetryEntityNameResolver, {
+  TelemetryEntityNameMap,
+} from "../../../UI/Utils/Telemetry/TelemetryEntityNames";
+import {
+  RESOURCE_FACET_CATALOG,
+  ResourceFacetDefinition,
+} from "../../../Types/Telemetry/ResourceFacetCatalog";
+import ObjectID from "../../../Types/ObjectID";
+import ProjectUtil from "../../../UI/Utils/Project";
+
+const PROJECT_ID: string = "9e1b6b0e-0000-4000-8000-000000000031";
+
+interface CatalogCase {
+  definition: ResourceFacetDefinition;
+  id: string;
+  name: string;
+}
+
+// The table each catalog type's ids live in (TELEMETRY_ENTITY_TYPES).
+const MODEL_NAME_BY_FACET_KEY: Record<string, string> = {
+  hostId: "Host",
+  dockerHostId: "DockerHost",
+  podmanHostId: "PodmanHost",
+  kubernetesClusterId: "KubernetesCluster",
+  dockerSwarmClusterId: "DockerSwarmCluster",
+  proxmoxClusterId: "ProxmoxCluster",
+  vmwareVCenterId: "VMwareVCenter",
+  cephClusterId: "CephCluster",
+  serverlessFunctionId: "ServerlessFunction",
+  cloudResourceId: "CloudResource",
+  rumApplicationId: "RumApplication",
+  iotFleetId: "IoTFleet",
+};
+
+const CASES: Array<CatalogCase> = RESOURCE_FACET_CATALOG.map(
+  (definition: ResourceFacetDefinition, index: number): CatalogCase => {
+    const suffix: string = String(index + 1).padStart(12, "0");
+    return {
+      definition,
+      id: `c0ffee00-0000-4000-8000-${suffix}`,
+      name: `prod-resource-${index + 1}`,
+    };
+  },
+);
+
+const caseFor: (facetKey: string) => CatalogCase = (
+  facetKey: string,
+): CatalogCase => {
+  const found: CatalogCase | undefined = CASES.find((entry: CatalogCase) => {
+    return entry.definition.facetKey === facetKey;
+  });
+  expect(found).toBeDefined();
+  return found!;
+};
+
+interface GetListArgs {
+  modelType: { name: string };
+}
+
+const queriedModels: () => Array<string> = (): Array<string> => {
+  return getListMock.mock.calls.map((call: Array<unknown>): string => {
+    return (call[0] as GetListArgs).modelType.name;
+  });
+};
+
+// The viewer preloads nothing in this harness: every name is the resolver's.
+const NO_PRELOADED_MAPS: LogsEntityLookupMaps = { serviceMap: {} };
+
+interface HarnessProps {
+  appliedFacetFilters: Map<string, Set<string>>;
+  facetData?: FacetData | undefined;
+  onRemove?: ((facetKey: string, value: string) => void) | undefined;
+}
+
+const Harness: React.FunctionComponent<HarnessProps> = (
+  props: HarnessProps,
+): React.ReactElement => {
+  // Dashboard LogsViewer: one chip per applied value, keyed by facet label.
+  const chips: Array<ActiveFilter> = React.useMemo(() => {
+    const filters: Array<ActiveFilter> = [];
+    for (const [facetKey, values] of props.appliedFacetFilters.entries()) {
+      for (const value of values) {
+        filters.push({
+          facetKey,
+          value,
+          displayKey: getLogsFacetChipDisplayKey(facetKey),
+          displayValue: value,
+        });
+      }
+    }
+    return filters;
+  }, [props.appliedFacetFilters]);
+
+  // Shared LogsViewer: one resolver request, then enrichment.
+  const request: LogsEntityResolutionRequest = React.useMemo(() => {
+    return collectLogsEntityIdsToResolve({
+      filters: chips,
+      facetData: props.facetData,
+      maps: NO_PRELOADED_MAPS,
+    });
+  }, [chips, props.facetData]);
+
+  const nameMap: TelemetryEntityNameMap = useTelemetryEntityNames(request.ids, {
+    typeHints: request.typeHints,
+  });
+
+  return (
+    <ActiveFilterChips
+      filters={enrichLogsActiveFilters(chips, NO_PRELOADED_MAPS, nameMap)}
+      onRemove={(facetKey: string, value: string) => {
+        props.onRemove?.(facetKey, value);
+      }}
+      onClearAll={() => {}}
+    />
+  );
+};
+
+const chipText: () => string = (): string => {
+  return document.body.textContent || "";
+};
+
+beforeEach(() => {
+  TelemetryEntityNameResolver.clearCache();
+  getListMock.mockReset();
+  getListMock.mockImplementation((args: GetListArgs) => {
+    /*
+     * Each table holds its own catalog row; the resolver itself drops rows
+     * it did not ask for.
+     */
+    return Promise.resolve({
+      data: CASES.filter((entry: CatalogCase) => {
+        return (
+          MODEL_NAME_BY_FACET_KEY[entry.definition.facetKey] ===
+          args.modelType.name
+        );
+      }).map((entry: CatalogCase) => {
+        return { id: new ObjectID(entry.id), name: entry.name };
+      }),
+      count: 0,
+    });
+  });
+  jest
+    .spyOn(ProjectUtil, "getCurrentProjectId")
+    .mockReturnValue(new ObjectID(PROJECT_ID));
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("logs explorer resource chips (rendered)", () => {
+  test.each(
+    CASES.map((entry: CatalogCase): [string, CatalogCase] => {
+      return [entry.definition.facetKey, entry];
+    }),
+  )(
+    "a %s chip reads '<Type>: <name>' and queries only its own table",
+    async (_facetKey: string, entry: CatalogCase) => {
+      render(
+        <Harness
+          appliedFacetFilters={
+            new Map([[entry.definition.facetKey, new Set([entry.id])]])
+          }
+        />,
+      );
+
+      // The key is right before the name lands — no raw facet key.
+      expect(
+        screen.getByText(`${entry.definition.label}:`),
+      ).toBeInTheDocument();
+      expect(chipText()).not.toContain(entry.definition.facetKey);
+
+      await waitFor(() => {
+        expect(screen.getByText(entry.name)).toBeInTheDocument();
+      });
+
+      expect(chipText()).not.toContain(entry.id);
+      expect(queriedModels()).toEqual([
+        MODEL_NAME_BY_FACET_KEY[entry.definition.facetKey],
+      ]);
+    },
+  );
+
+  test("chips for every catalog type are named in one pass, each from its own table", async () => {
+    render(
+      <Harness
+        appliedFacetFilters={
+          new Map(
+            CASES.map((entry: CatalogCase): [string, Set<string>] => {
+              return [entry.definition.facetKey, new Set([entry.id])];
+            }),
+          )
+        }
+      />,
+    );
+
+    await waitFor(() => {
+      for (const entry of CASES) {
+        expect(screen.getByText(entry.name)).toBeInTheDocument();
+      }
+    });
+
+    for (const entry of CASES) {
+      expect(
+        screen.getByText(`${entry.definition.label}:`),
+      ).toBeInTheDocument();
+      expect(chipText()).not.toContain(entry.id);
+    }
+
+    // Straight to each table; the Service-first probe never ran.
+    expect([...queriedModels()].sort()).toEqual(
+      Object.values(MODEL_NAME_BY_FACET_KEY).sort(),
+    );
+    expect(queriedModels()).not.toContain("Service");
+  });
+
+  test("removing a named new-type chip still hands the viewer the id", async () => {
+    const removed: Array<[string, string]> = [];
+    const proxmox: CatalogCase = caseFor("proxmoxClusterId");
+
+    render(
+      <Harness
+        appliedFacetFilters={
+          new Map([
+            ["proxmoxClusterId", new Set([proxmox.id])],
+            ["severityText", new Set(["Error"])],
+          ])
+        }
+        onRemove={(facetKey: string, value: string) => {
+          removed.push([facetKey, value]);
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText(proxmox.name)).toBeInTheDocument();
+    });
+
+    fireEvent.click(
+      screen.getByTitle(`Remove Proxmox Cluster: ${proxmox.name}`),
+    );
+
+    expect(removed).toEqual([["proxmoxClusterId", proxmox.id]]);
+  });
+
+  test("a new-type chip the resolver cannot name keeps its label and shows the id", async () => {
+    const unknownId: string = "c0ffee00-0000-4000-8000-00000000ffff";
+
+    render(
+      <Harness
+        appliedFacetFilters={new Map([["cephClusterId", new Set([unknownId])]])}
+      />,
+    );
+
+    /*
+     * The hinted table is asked first; a miss there falls through to the
+     * general pass (Service first, then the rest), which ends with the
+     * last table in the resolution order.
+     */
+    await waitFor(() => {
+      expect(queriedModels()).toContain("ScheduledMaintenance");
+    });
+
+    expect(queriedModels()[0]).toBe("CephCluster");
+    expect(
+      queriedModels().filter((model: string): boolean => {
+        return model === "CephCluster";
+      }),
+    ).toHaveLength(1);
+    expect(screen.getByText("Ceph Cluster:")).toBeInTheDocument();
+    expect(screen.getByText(unknownId)).toBeInTheDocument();
+  });
+
+  test("sidebar rows for a new type ride the same request as the chips", async () => {
+    const iot: CatalogCase = caseFor("iotFleetId");
+    const rum: CatalogCase = caseFor("rumApplicationId");
+
+    render(
+      <Harness
+        appliedFacetFilters={new Map([["iotFleetId", new Set([iot.id])]])}
+        facetData={{
+          rumApplicationId: [{ value: rum.id, count: 0 }],
+          iotFleetId: [{ value: iot.id, count: 4 }],
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText(iot.name)).toBeInTheDocument();
+    });
+
+    expect(screen.getByText("IoT Fleet:")).toBeInTheDocument();
+    expect([...queriedModels()].sort()).toEqual(["IoTFleet", "RumApplication"]);
+  });
+});