@oneuptime/common 13.0.6 → 13.0.8

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

@@ -465,13 +465,15 @@ afterEach(() => {
 });
 
 describe("InvestigationPanel report lifecycle", () => {
-  test("renders nothing and briefly discovers a run when none exists yet", async () => {
+  test("explains a missing run and briefly checks whether one appears", async () => {
     postMock.mockResolvedValue(noInvestigationResponse() as never);
 
-    const { container } = renderPanel();
+    renderPanel();
     await flush();
 
-    expect(container).toBeEmptyDOMElement();
+    expect(
+      screen.getByText("No investigation has been recorded"),
+    ).toBeVisible();
     expect(jest.getTimerCount()).toBe(1);
 
     await advanceFastPolls(4);
@@ -706,7 +708,8 @@ describe("InvestigationPanel report lifecycle", () => {
     );
     await flush();
 
-    expect(view.container).toBeEmptyDOMElement();
+    expect(screen.getByText("Checking investigation status…")).toBeVisible();
+    expect(screen.queryByTestId("investigation-markdown")).toBeNull();
     expect(onAnalysisAvailable).not.toHaveBeenCalled();
 
     await resolveDeferred(

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

@@ -148,7 +148,7 @@ describe("InvestigationPanel status reporting", () => {
       ),
     );
 
-    const { container } = render(
+    render(
       <InvestigationPanel
         subjectType="incident"
         subjectId={SUBJECT_ID}
@@ -164,7 +164,9 @@ describe("InvestigationPanel status reporting", () => {
     });
 
     expect(onStatusChange).toHaveBeenCalledWith(null);
-    expect(container).toBeEmptyDOMElement();
+    expect(
+      screen.getByText("No investigation has been recorded"),
+    ).toBeVisible();
   });
 
   test("discovers an AI run that is enqueued after the incident page loads", async () => {
@@ -447,13 +449,13 @@ describe("InvestigationPanel status reporting", () => {
     expect(jest.getTimerCount()).toBe(0);
   });
 
-  test("degrades silently when the initial request fails", async () => {
+  test("shows an unavailable status when the initial request fails", async () => {
     const onStatusChange: MockFunction = getJestMockFunction();
     postMock.mockResolvedValue(
       new HTTPErrorResponse(500, { message: "boom" }, {}),
     );
 
-    const { container } = render(
+    render(
       <InvestigationPanel
         subjectType="incident"
         subjectId={SUBJECT_ID}
@@ -464,7 +466,10 @@ describe("InvestigationPanel status reporting", () => {
     await waitFor(() => {
       expect(onStatusChange).toHaveBeenCalledWith(null);
     });
-    expect(container).toBeEmptyDOMElement();
+    expect(
+      screen.getByText("Investigation status is unavailable"),
+    ).toBeVisible();
+    expect(screen.queryByText("Not investigated")).toBeNull();
   });
 
   test("preserves the last active status through a transient polling failure", async () => {
@@ -534,7 +539,7 @@ describe("InvestigationPanel status reporting", () => {
         new HTTPErrorResponse(503, { message: "try again" }, {}),
       );
 
-    const { container, rerender } = render(
+    const { rerender } = render(
       <InvestigationPanel
         subjectType="incident"
         subjectId={SUBJECT_ID}
@@ -552,10 +557,13 @@ describe("InvestigationPanel status reporting", () => {
     );
 
     await waitFor(() => {
-      expect(container).toBeEmptyDOMElement();
+      expect(
+        screen.getByText("Investigation status is unavailable"),
+      ).toBeVisible();
       expect(onStatusChange).toHaveBeenLastCalledWith(null);
     });
     expect(postMock).toHaveBeenCalledTimes(2);
+    expect(screen.queryByText("Investigating…")).toBeNull();
   });
 
   test("ignores a late response from the previous subject", async () => {

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

@@ -0,0 +1,264 @@
+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 * as React from "react";
+import MetricsViewer from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricsViewer";
+import MetricExplorerUrl, {
+  SerializedMetricQuery,
+} from "../../../Utils/Metrics/MetricExplorerUrl";
+import { buildQueryConfigsFromSerializedQueries } from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/MetricConfigReconstruct";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricType from "../../../Models/DatabaseModels/MetricType";
+import ObjectID from "../../../Types/ObjectID";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import Navigation from "../../../UI/Utils/Navigation";
+import ProjectUtil from "../../../UI/Utils/Project";
+
+/*
+ * Render the real list's row navigation with the data-loading and table
+ * chrome replaced. These boundaries do not participate in URL generation.
+ */
+jest.mock("../../../UI/Components/TelemetryViewer/TelemetryViewer", () => {
+  return {
+    __esModule: true,
+    default: (props: {
+      renderRow: (metric: MetricType) => React.ReactElement;
+    }) => {
+      return props.renderRow({ name: "cpu.usage" } as MetricType);
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: { onClick: () => void }) => {
+        return <button onClick={props.onClick}>Open metric</button>;
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: () => {
+        return Promise.resolve({ data: [], count: 0 });
+      },
+      getCommonHeaders: () => {
+        return {};
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/AnalyticsModelAPI/AnalyticsModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: () => {
+        return Promise.resolve({ data: [] });
+      },
+      aggregate: () => {
+        return Promise.resolve({ data: [] });
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      post: () => {
+        return Promise.resolve({ data: { facets: {} } });
+      },
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/Metrics",
+  () => {
+    return {
+      __esModule: true,
+      default: {
+        getTelemetryAttributes: () => {
+          return Promise.resolve([]);
+        },
+        fetchSparklineAggregates: () => {
+          return Promise.resolve(new Map());
+        },
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Utils/Telemetry/UseTelemetryEntityNames", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {};
+    },
+  };
+});
+
+const FIRST_ID: ObjectID = new ObjectID("11111111-0000-4000-8000-000000000001");
+const SECOND_ID: ObjectID = new ObjectID(
+  "22222222-0000-4000-8000-000000000002",
+);
+let navigateSpy: ReturnType<typeof jest.spyOn>;
+
+type ViewerProps = React.ComponentProps<typeof MetricsViewer>;
+
+async function openMetric(props: ViewerProps): Promise<MetricQueryConfigData> {
+  await act(async () => {
+    render(<MetricsViewer {...props} disableUrlSync={true} />);
+  });
+  fireEvent.click(screen.getByRole("button", { name: "Open metric" }));
+  const url: globalThis.URL = new globalThis.URL(
+    navigateSpy.mock.calls[0]![0]!.toString(),
+  );
+  const queries: Array<SerializedMetricQuery> =
+    MetricExplorerUrl.parseMetricQueriesParam(
+      url.searchParams.get("metricQueries")!,
+    );
+  expect(queries).toHaveLength(1);
+  return buildQueryConfigsFromSerializedQueries(queries)[0]!;
+}
+
+beforeEach(() => {
+  jest.spyOn(ProjectUtil, "getCurrentProjectId").mockReturnValue(FIRST_ID);
+  navigateSpy = jest.spyOn(Navigation, "navigate").mockImplementation(() => {
+    return undefined;
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("metric-list resource scope on row navigation", () => {
+  test("RUM's polymorphic entity id remains RUM when its metric has no attribute filter", async () => {
+    const query: MetricQueryConfigData = await openMetric({
+      serviceIds: [FIRST_ID],
+      scopeEntityType: ServiceType.RealUserMonitor,
+    });
+    expect(query.eventScope?.["primaryEntityType"]).toBe(
+      ServiceType.RealUserMonitor,
+    );
+    expect((query.eventScope?.["primaryEntityId"] as Includes).values).toEqual([
+      FIRST_ID.toString(),
+    ]);
+    expect(query.metricQueryData.filterData.attributes).toEqual({});
+  });
+
+  test("service scope retains every selected service id", async () => {
+    const query: MetricQueryConfigData = await openMetric({
+      serviceIds: [FIRST_ID, SECOND_ID],
+    });
+    expect(query.eventScope?.["primaryEntityType"]).toBe(
+      ServiceType.OpenTelemetry,
+    );
+    expect((query.eventScope?.["primaryEntityId"] as Includes).values).toEqual([
+      FIRST_ID.toString(),
+      SECOND_ID.toString(),
+    ]);
+  });
+
+  test("Inventory's opaque entity membership survives navigation", async () => {
+    const query: MetricQueryConfigData = await openMetric({
+      entityKeysFilter: ["inventory-entity"],
+    });
+    expect((query.eventScope?.["entityKeys"] as Includes).values).toEqual([
+      "inventory-entity",
+    ]);
+    expect(query.metricQueryData.filterData.attributes).toEqual({});
+  });
+
+  test.each<Record<string, string>>([
+    { "resource.host.name": "Web-01" },
+    { "resource.service.name": "Checkout" },
+    {
+      "resource.k8s.cluster.name": "Prod",
+      "resource.k8s.namespace.name": "Apps",
+      "resource.k8s.pod.name": "Checkout-1",
+    },
+  ])(
+    "Inventory's natural identity %p survives without losing its original case",
+    async (searchAttributes: Record<string, string>) => {
+      const query: MetricQueryConfigData = await openMetric({
+        entityKeysFilter: ["inventory-entity"],
+        entityKeyDisplays: {
+          "inventory-entity": {
+            displayKey: "Resource",
+            displayValue: "Example",
+            searchAttributes,
+          },
+        },
+      });
+      expect(query.eventScope).toEqual(searchAttributes);
+      expect(query.metricQueryData.filterData.attributes).toEqual({});
+    },
+  );
+
+  test("multiple inventory memberships remain bounded when one natural identity cannot represent them", async () => {
+    const query: MetricQueryConfigData = await openMetric({
+      entityKeysFilter: ["entity-a", "entity-b"],
+      entityKeyDisplays: {
+        "entity-a": {
+          displayKey: "Host",
+          displayValue: "Web-01",
+          searchAttributes: { "resource.host.name": "Web-01" },
+        },
+      },
+    });
+    expect((query.eventScope?.["entityKeys"] as Includes).values).toEqual([
+      "entity-a",
+      "entity-b",
+    ]);
+  });
+
+  test("legacy membership scopes survive without becoming synthetic attribute filters", async () => {
+    const query: MetricQueryConfigData = await openMetric({
+      entityScope: {
+        entityKeys: ["host-entity"],
+        attributeKey: "resource.host.name",
+        attributeValue: "web-01",
+      },
+      attributeFilters: { "resource.host.name": "web-01" },
+    });
+    expect(query.eventScope).toEqual({ "resource.host.name": "web-01" });
+    expect(query.metricQueryData.filterData.attributes).toEqual({
+      "resource.host.name": "web-01",
+    });
+  });
+
+  test("ordinary attribute-scoped charts retain their existing scope", async () => {
+    const query: MetricQueryConfigData = await openMetric({
+      attributeFilters: { "resource.k8s.cluster.name": "prod" },
+    });
+    expect(query.eventScope).toBeUndefined();
+    expect(query.metricQueryData.filterData.attributes).toEqual({
+      "resource.k8s.cluster.name": "prod",
+    });
+  });
+});

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

@@ -0,0 +1,342 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen, within } from "@testing-library/react";
+import * as React from "react";
+import Permission from "../../../Types/Permission";
+
+/*
+ * https://github.com/OneUptime/oneuptime/issues/3867
+ *
+ * "Test Monitor" on the Monitor Overview's summary card.
+ *
+ * The card is where a reader already asks "is this working right now", so it
+ * is where the on-demand version of that question belongs. What these pin is
+ * when the action is offered at all - because the summary card renders for
+ * every monitor type except Manual, while a test only means something for the
+ * fourteen types a probe actually runs, and only when there are steps to run
+ * and something to run them on.
+ *
+ * The other half is coexistence: the card's right-hand slot already holds the
+ * "Showing results from:" probe picker, and an implementation that reached for
+ * the same slot would silently replace it - the regression that issue #2899
+ * was about. So every test that expects the button also checks the picker is
+ * still there.
+ *
+ * ModelAPI is stubbed because MonitorTestForm imports it; nothing here presses
+ * the button, so the stub only has to exist.
+ */
+
+let currentPermissions: Array<Permission> = [Permission.ProjectAdmin];
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      create: (): Promise<never> => {
+        return Promise.reject(new Error("not used"));
+      },
+      getItem: (): Promise<null> => {
+        return Promise.resolve(null);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Permission", () => {
+  return {
+    __esModule: true,
+    default: {
+      getAllPermissions: (): Array<Permission> => {
+        return currentPermissions;
+      },
+      getProjectPermissions: (): null => {
+        return null;
+      },
+      getGlobalPermissions: (): null => {
+        return null;
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: (): boolean => {
+        return false;
+      },
+      getUserId: (): null => {
+        return null;
+      },
+    },
+  };
+});
+
+import Summary from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/SummaryView/Summary";
+import Probe from "../../../Models/DatabaseModels/Probe";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+
+const MONITOR_ID: string = "11111111-1111-4111-8111-111111111111";
+const PROBE_ID: string = "44444444-4444-4444-8444-444444444444";
+const DISABLED_PROBE_ID: string = "55555555-5555-4555-8555-555555555555";
+
+function probe(id: string, name: string): Probe {
+  return Object.assign(new Probe(), { _id: id, name: name });
+}
+
+const ATTACHED_PROBES: Array<Probe> = [probe(PROBE_ID, "Ohio Probe")];
+
+function stepsWith(count: number): MonitorSteps {
+  const monitorSteps: MonitorSteps = new MonitorSteps();
+
+  monitorSteps.data = {
+    monitorStepsInstanceArray: Array.from({ length: count }, () => {
+      return new MonitorStep();
+    }),
+  };
+
+  return monitorSteps;
+}
+
+interface SummaryOptions {
+  monitorType?: MonitorType | undefined;
+  monitorSteps?: MonitorSteps | undefined;
+  /*
+   * Spelled as its own flag rather than `monitorSteps: undefined`, which a
+   * `?? default` in this helper would silently turn back into the default -
+   * and the test would then assert the opposite of what it says.
+   */
+  withoutMonitorSteps?: boolean | undefined;
+  probes?: Array<Probe> | undefined;
+  disabledProbeIds?: Array<string> | undefined;
+  withoutMonitorId?: boolean | undefined;
+}
+
+function renderSummary(options: SummaryOptions = {}): void {
+  const monitorSteps: MonitorSteps | undefined = options.withoutMonitorSteps
+    ? undefined
+    : options.monitorSteps || stepsWith(1);
+
+  if (options.withoutMonitorId) {
+    render(
+      <Summary
+        monitorType={options.monitorType || MonitorType.Website}
+        monitorSteps={monitorSteps}
+        probes={options.probes || ATTACHED_PROBES}
+        disabledProbeIds={options.disabledProbeIds}
+      />,
+    );
+
+    return;
+  }
+
+  render(
+    <Summary
+      monitorType={options.monitorType || MonitorType.Website}
+      monitorSteps={monitorSteps}
+      monitorId={new ObjectID(MONITOR_ID)}
+      probes={options.probes || ATTACHED_PROBES}
+      disabledProbeIds={options.disabledProbeIds}
+    />,
+  );
+}
+
+function testButton(): HTMLElement | null {
+  return screen.queryByTestId("test-monitor-button");
+}
+
+function probePicker(): HTMLElement | null {
+  return screen.queryByRole("combobox");
+}
+
+beforeEach(() => {
+  currentPermissions = [Permission.ProjectAdmin];
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("the summary card offers a test", () => {
+  test("a probeable monitor with steps and a probe gets the button", () => {
+    renderSummary();
+
+    expect(testButton()).toBeInTheDocument();
+  });
+
+  test("the button lives on the Monitor Summary card itself", () => {
+    /*
+     * Queried through the card rather than the page, because a second
+     * component in the dashboard also renders a card titled "Monitor Summary"
+     * (the snapshot card on incident and alert pages). This one is the
+     * overview's.
+     */
+    renderSummary();
+
+    const card: HTMLElement = screen.getByTestId("card");
+
+    expect(
+      within(card).getByRole("heading", { name: "Monitor Summary" }),
+    ).toBeInTheDocument();
+    expect(within(card).getByTestId("test-monitor-button")).toBeInTheDocument();
+  });
+
+  test("the probe picker is still there next to it", () => {
+    /*
+     * The card's right-hand slot was already taken by "Showing results from:".
+     * Putting the button there instead of in the card's own actions slot would
+     * have removed the picker - and would have shipped green, because nothing
+     * else asserts the picker renders.
+     */
+    renderSummary();
+
+    expect(testButton()).toBeInTheDocument();
+    expect(probePicker()).toBeInTheDocument();
+    expect(screen.getByText("Showing results from:")).toBeInTheDocument();
+  });
+
+  test("the button is offered for every probeable monitor type", () => {
+    const probeableTypes: Array<MonitorType> = [
+      MonitorType.API,
+      MonitorType.Website,
+      MonitorType.IP,
+      MonitorType.Ping,
+      MonitorType.Port,
+      MonitorType.SSLCertificate,
+      MonitorType.SyntheticMonitor,
+      MonitorType.CustomJavaScriptCode,
+      MonitorType.DNS,
+      MonitorType.DNSSEC,
+      MonitorType.Domain,
+      MonitorType.SQLQuery,
+      MonitorType.Database,
+      MonitorType.ExternalStatusPage,
+    ];
+
+    for (const monitorType of probeableTypes) {
+      renderSummary({ monitorType: monitorType });
+
+      expect(testButton()).toBeInTheDocument();
+
+      cleanup();
+    }
+  });
+
+  test("an attached probe that is switched off can still be tested against", () => {
+    /*
+     * A disabled probe stops WATCHING the monitor; it still picks up a test,
+     * because the queue is claimed by probe id alone. Being able to test with
+     * it is how an operator checks a probe before switching it back on.
+     */
+    renderSummary({
+      probes: [
+        probe(PROBE_ID, "Ohio Probe"),
+        probe(DISABLED_PROBE_ID, "Attic"),
+      ],
+      disabledProbeIds: [DISABLED_PROBE_ID],
+    });
+
+    expect(testButton()).toBeInTheDocument();
+  });
+});
+
+describe("the summary card withholds a test", () => {
+  test("a monitor type no probe runs gets no button", () => {
+    /*
+     * The card still renders for these - they have their own summary - so the
+     * button has to be withheld at this call site rather than left to the form
+     * to render nothing, which would leave an empty slot in the header.
+     */
+    renderSummary({ monitorType: MonitorType.Logs });
+
+    expect(testButton()).not.toBeInTheDocument();
+  });
+
+  test("an incoming-request monitor gets no button", () => {
+    renderSummary({ monitorType: MonitorType.IncomingRequest });
+
+    expect(testButton()).not.toBeInTheDocument();
+  });
+
+  test("a server monitor gets no button", () => {
+    renderSummary({ monitorType: MonitorType.Server });
+
+    expect(testButton()).not.toBeInTheDocument();
+  });
+
+  test("a monitor with no steps gets no button", () => {
+    /*
+     * The row would be created and accepted, and the probe would return
+     * without reporting anything - so the only thing the user would ever see
+     * is the poll giving up two and a half minutes later.
+     */
+    renderSummary({ withoutMonitorSteps: true });
+
+    expect(testButton()).not.toBeInTheDocument();
+  });
+
+  test("a monitor with an empty steps array gets no button", () => {
+    renderSummary({ monitorSteps: stepsWith(0) });
+
+    expect(testButton()).not.toBeInTheDocument();
+  });
+
+  test("a monitor with nothing attached gets no button", () => {
+    /*
+     * The modal's "Select Probe" field is required and would have no options,
+     * so Run Test could never be submitted. The card already explains this
+     * case in its body.
+     */
+    renderSummary({ probes: [] });
+
+    expect(testButton()).not.toBeInTheDocument();
+    expect(probePicker()).not.toBeInTheDocument();
+  });
+
+  test("a read-only user gets no button", () => {
+    currentPermissions = [Permission.Viewer];
+
+    renderSummary();
+
+    expect(testButton()).not.toBeInTheDocument();
+  });
+
+  test("withholding the button leaves the rest of the card alone", () => {
+    renderSummary({ probes: [] });
+
+    expect(
+      screen.getByRole("heading", { name: "Monitor Summary" }),
+    ).toBeInTheDocument();
+  });
+
+  test("a manual monitor renders no card at all", () => {
+    renderSummary({ monitorType: MonitorType.Manual });
+
+    expect(screen.queryByTestId("card")).not.toBeInTheDocument();
+    expect(testButton()).not.toBeInTheDocument();
+  });
+});
+
+describe("what the card hands the test form", () => {
+  test("it still renders the button when the page has no monitor id", () => {
+    /*
+     * monitorId is optional on the card so that a caller which cannot supply
+     * one is not forced to; the overview page always does, which is what lets
+     * the server resolve this monitor's secrets for the run.
+     */
+    renderSummary({ withoutMonitorId: true });
+
+    expect(testButton()).toBeInTheDocument();
+  });
+});