@oneuptime/common 12.0.20 → 12.0.22

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

@@ -0,0 +1,258 @@
+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";
+
+/*
+ * The investigation drawer is the "what happened in this window?" panel:
+ * it must summarize the log signal for the window+scope, hand every
+ * companion signal the SAME pinned window, and route escape hatches
+ * (patterns, explorer) through onClose so the page underneath doesn't
+ * change behind an open drawer.
+ */
+
+const histogramMock: MockFunction = getJestMockFunction();
+const patternsMock: MockFunction = getJestMockFunction();
+const companionTabsMock: MockFunction = getJestMockFunction();
+const embeddedCardMock: MockFunction = getJestMockFunction();
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Logs/LogsInsightsApi",
+  () => {
+    return {
+      __esModule: true,
+      fetchLogsHistogramRaw: (...args: Array<any>) => {
+        return histogramMock(...args);
+      },
+      fetchTopErrorPatterns: (...args: Array<any>) => {
+        return patternsMock(...args);
+      },
+    };
+  },
+);
+
+/*
+ * The companion tabs and the embedded metric card are heavy, separately
+ * tested surfaces — here they only need to prove WHAT they were handed.
+ */
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Telemetry/TelemetryCompanionSignalTabs",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: Record<string, unknown>): React.ReactElement => {
+        companionTabsMock(props);
+        return React.createElement(
+          "div",
+          { "data-testid": "companion-tabs" },
+          props["primarySignalElement"] as React.ReactElement,
+        );
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/EmbeddedMetricCard",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: Record<string, unknown>): React.ReactElement => {
+        embeddedCardMock(props);
+        return React.createElement("div", {
+          "data-testid": "embedded-metric-card",
+        });
+      },
+    };
+  },
+);
+
+import InvestigationDrawer from "../../../../App/FeatureSet/Dashboard/src/Components/Telemetry/InvestigationDrawer";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import MetricViewData from "../../../Types/Metrics/MetricViewData";
+import TelemetryType from "../../../Types/Telemetry/TelemetryType";
+import Navigation from "../../../UI/Utils/Navigation";
+
+const WINDOW: InBetween<Date> = new InBetween<Date>(
+  new Date("2026-08-20T10:00:00.000Z"),
+  new Date("2026-08-20T10:15:00.000Z"),
+);
+
+function buildViewData(): MetricViewData {
+  return {
+    queryConfigs: [
+      {
+        metricAliasData: { metricVariable: "a" },
+        metricQueryData: {
+          filterData: {
+            metricName: "cpu.usage",
+            attributes: { "host.name": "web-01" },
+            aggegationType: MetricsAggregationType.Avg,
+          },
+        },
+      },
+    ],
+    formulaConfigs: [],
+    startAndEndDate: null,
+  } as unknown as MetricViewData;
+}
+
+let navigateSpy: ReturnType<typeof jest.spyOn>;
+
+beforeEach(() => {
+  histogramMock.mockReset();
+  patternsMock.mockReset();
+  companionTabsMock.mockReset();
+  embeddedCardMock.mockReset();
+  histogramMock.mockReturnValue(
+    Promise.resolve([
+      { time: "2026-08-20T10:00:00.000Z", severity: "Information", count: 90 },
+      { time: "2026-08-20T10:05:00.000Z", severity: "Error", count: 10 },
+    ]),
+  );
+  patternsMock.mockReturnValue(
+    Promise.resolve([
+      {
+        pattern: "connection refused to <IP>",
+        sampleBody: "connection refused to 10.0.0.5",
+        count: 42,
+        resourceIds: [],
+        severities: ["Error"],
+        sampleTraceIds: [],
+      },
+    ]),
+  );
+  navigateSpy = jest.spyOn(Navigation, "navigate").mockImplementation(() => {
+    return undefined;
+  });
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  cleanup();
+});
+
+describe("InvestigationDrawer", () => {
+  test("summarizes the window's log signal and lists top error patterns", async () => {
+    render(
+      <InvestigationDrawer
+        title="host.name=web-01"
+        window={WINDOW}
+        metricViewData={buildViewData()}
+        onClose={() => {
+          // not exercised here
+        }}
+      />,
+    );
+
+    // Scope chips reflect the metric view's filters.
+    expect(screen.getByText("host.name = web-01")).toBeInTheDocument();
+
+    await waitFor(() => {
+      expect(screen.getByText("100")).toBeInTheDocument();
+    });
+    expect(screen.getByText("10")).toBeInTheDocument();
+    expect(screen.getByText("10.0%")).toBeInTheDocument();
+    expect(
+      screen.getByText("connection refused to 10.0.0.5"),
+    ).toBeInTheDocument();
+
+    // The histogram request carried the attribute scope.
+    const histogramBody: Record<string, unknown> = histogramMock.mock
+      .calls[0]?.[0] as Record<string, unknown>;
+    expect(
+      (histogramBody["attributes"] as Record<string, unknown>)["host.name"],
+    ).toBe("web-01");
+  });
+
+  test("hands the companion tabs the SAME pinned window and metric queries", async () => {
+    render(
+      <InvestigationDrawer
+        window={WINDOW}
+        metricViewData={buildViewData()}
+        onClose={() => {
+          // not exercised here
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(companionTabsMock).toHaveBeenCalled();
+    });
+
+    const tabsProps: Record<string, unknown> = companionTabsMock.mock
+      .calls[0]?.[0] as Record<string, unknown>;
+    const telemetryQuery: Record<string, unknown> = tabsProps[
+      "telemetryQuery"
+    ] as Record<string, unknown>;
+
+    expect(telemetryQuery["telemetryType"]).toBe(TelemetryType.Metric);
+    const viewData: MetricViewData = telemetryQuery[
+      "metricViewData"
+    ] as MetricViewData;
+    expect(viewData.startAndEndDate?.startValue.getTime()).toBe(
+      WINDOW.startValue.getTime(),
+    );
+    // Pinned — never a rolling token.
+    expect(viewData.rangeToken).toBeUndefined();
+    expect(tabsProps["eventNoun"]).toBe("view");
+
+    const snapshotWindow: InBetween<Date> = tabsProps[
+      "snapshotWindow"
+    ] as InBetween<Date>;
+    expect(snapshotWindow.endValue.getTime()).toBe(WINDOW.endValue.getTime());
+
+    // The primary element is the interactive metric card, same queries.
+    expect(screen.getByTestId("embedded-metric-card")).toBeInTheDocument();
+    const cardProps: Record<string, unknown> = embeddedCardMock.mock
+      .calls[0]?.[0] as Record<string, unknown>;
+    const cardConfigs: Array<Record<string, any>> = cardProps[
+      "queryConfigs"
+    ] as Array<Record<string, any>>;
+    expect(
+      cardConfigs[0]?.["metricQueryData"]["filterData"]["metricName"],
+    ).toBe("cpu.usage");
+  });
+
+  test("escape hatches close the drawer before navigating", async () => {
+    const onClose: MockFunction = getJestMockFunction();
+
+    render(
+      <InvestigationDrawer
+        window={WINDOW}
+        metricViewData={buildViewData()}
+        onClose={(...args: Array<any>) => {
+          onClose(...args);
+        }}
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Open in Metric Explorer"));
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(navigateSpy).toHaveBeenCalledTimes(1);
+
+    await waitFor(() => {
+      expect(
+        screen.getByText("connection refused to 10.0.0.5"),
+      ).toBeInTheDocument();
+    });
+    fireEvent.click(screen.getByText("connection refused to 10.0.0.5"));
+    expect(onClose).toHaveBeenCalledTimes(2);
+    expect(navigateSpy).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -0,0 +1,171 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * Ghost overlays end-to-end through the real MetricCharts: previous-
+ * period results must render as dashed twins of DISPLAYED series only —
+ * never as legend chips, never consuming Top-N slots, and always
+ * time-shifted onto the current window's bucket grid (unshifted points
+ * would be silently dropped by the bucketer).
+ */
+
+jest.mock("recharts", () => {
+  const actual: Record<string, any> = jest.requireActual("recharts") as Record<
+    string,
+    any
+  >;
+  return {
+    ...actual,
+    ResponsiveContainer: ({ children }: { children: React.ReactElement }) => {
+      return React.cloneElement(children, {
+        width: 600,
+        height: 300,
+      } as Record<string, unknown>);
+    },
+  };
+});
+
+const fetchExemplarsMock: MockFunction = getJestMockFunction();
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/Metrics",
+  () => {
+    return {
+      __esModule: true,
+      default: {
+        fetchExemplars: (...args: Array<any>) => {
+          fetchExemplarsMock(...args);
+          return new Promise(() => {
+            // Intentionally never settles.
+          });
+        },
+        setQueryTopNOverride: () => {
+          return undefined;
+        },
+        getQueryConfigTopNKey: (
+          _queryConfig: unknown,
+          index: number,
+          scope?: string,
+        ) => {
+          return `${scope || ""}:${index}`;
+        },
+        clearQueryTopNOverridesForScope: () => {
+          return undefined;
+        },
+        serializeAttributeFiltersForKey: (attributes: unknown) => {
+          return JSON.stringify(attributes || {});
+        },
+      },
+      DEFAULT_TOP_N_SERIES: 10,
+      SHOW_ALL_SERIES_TOP_N: 10_000,
+      sanitizeAttributeFilters: (attributes: unknown) => {
+        return attributes;
+      },
+    };
+  },
+);
+
+import MetricCharts from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricCharts";
+import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricViewData from "../../../Types/Metrics/MetricViewData";
+
+const WINDOW_START: Date = new Date("2026-08-20T10:00:00.000Z");
+const WINDOW_END: Date = new Date("2026-08-20T11:00:00.000Z");
+const WINDOW_MS: number = WINDOW_END.getTime() - WINDOW_START.getTime();
+
+function buildViewData(): MetricViewData {
+  return {
+    queryConfigs: [
+      {
+        metricAliasData: { metricVariable: "a", legend: "CPU" },
+        metricQueryData: {
+          filterData: {
+            metricName: "cpu.usage",
+            attributes: {},
+            aggegationType: MetricsAggregationType.Avg,
+          },
+        },
+      } as unknown as MetricQueryConfigData,
+    ],
+    formulaConfigs: [],
+    startAndEndDate: new InBetween<Date>(WINDOW_START, WINDOW_END),
+  } as MetricViewData;
+}
+
+function buildResult(offsetMs: number): AggregatedResult {
+  return {
+    data: [
+      {
+        timestamp: new Date(
+          new Date("2026-08-20T10:10:00.000Z").getTime() - offsetMs,
+        ),
+        value: 40,
+      },
+      {
+        timestamp: new Date(
+          new Date("2026-08-20T10:30:00.000Z").getTime() - offsetMs,
+        ),
+        value: 70,
+      },
+    ],
+    truncated: false,
+  } as unknown as AggregatedResult;
+}
+
+beforeEach(() => {
+  fetchExemplarsMock.mockReset();
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("MetricCharts compare overlays", () => {
+  test("renders a dashed ghost twin without adding legend chips", () => {
+    const { container } = render(
+      <MetricCharts
+        metricViewData={buildViewData()}
+        metricResults={[buildResult(0)]}
+        metricResultsPrevious={[buildResult(WINDOW_MS)]}
+        compareOffsetMs={WINDOW_MS}
+        metricTypes={[]}
+      />,
+    );
+
+    // The ghost line is on the chart, dashed…
+    expect(
+      container.querySelector('path[stroke-dasharray="6 4"]'),
+    ).toBeInTheDocument();
+
+    // …but the chip legend shows only the live series.
+    expect(screen.getAllByText("CPU").length).toBeGreaterThan(0);
+    expect(screen.queryByText("CPU (previous)")).toBeNull();
+    // And the series count still reads 1.
+    expect(screen.getByText("1 series")).toBeInTheDocument();
+  });
+
+  test("no previous results means no ghosts", () => {
+    const { container } = render(
+      <MetricCharts
+        metricViewData={buildViewData()}
+        metricResults={[buildResult(0)]}
+        metricTypes={[]}
+      />,
+    );
+
+    expect(container.querySelector('path[stroke-dasharray="6 4"]')).toBeNull();
+  });
+});

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

@@ -0,0 +1,233 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, waitFor } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * Compare-to-previous-period: MetricView must fetch the SAME queries a
+ * second time over the window shifted back by exactly one window width,
+ * hand both result sets to MetricCharts, and degrade to live-only when
+ * the shifted fetch fails.
+ */
+
+const fetchResultsMock: MockFunction = getJestMockFunction();
+const metricChartsMock: MockFunction = getJestMockFunction();
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/Metrics",
+  () => {
+    return {
+      __esModule: true,
+      default: {
+        fetchResults: (...args: Array<any>) => {
+          return fetchResultsMock(...args);
+        },
+        getMetricTypes: () => {
+          return Promise.resolve([]);
+        },
+        loadAllMetricsTypes: () => {
+          return Promise.resolve({
+            metricTypes: [],
+            telemetryServices: [],
+          });
+        },
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricCharts",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: Record<string, unknown>): React.ReactElement => {
+        metricChartsMock(props);
+        return React.createElement("div", {
+          "data-testid": "metric-charts",
+        });
+      },
+    };
+  },
+);
+
+import MetricView from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricView";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import MetricViewData from "../../../Types/Metrics/MetricViewData";
+
+const WINDOW_START: Date = new Date("2026-08-20T10:00:00.000Z");
+const WINDOW_END: Date = new Date("2026-08-20T11:00:00.000Z");
+const WINDOW_MS: number = WINDOW_END.getTime() - WINDOW_START.getTime();
+
+function buildData(): MetricViewData {
+  return {
+    queryConfigs: [
+      {
+        metricAliasData: { metricVariable: "a" },
+        metricQueryData: {
+          filterData: {
+            metricName: "cpu.usage",
+            attributes: {},
+            aggegationType: MetricsAggregationType.Avg,
+          },
+        },
+      },
+    ],
+    formulaConfigs: [],
+    startAndEndDate: new InBetween<Date>(WINDOW_START, WINDOW_END),
+  } as unknown as MetricViewData;
+}
+
+interface CapturedFetch {
+  metricViewData: MetricViewData;
+}
+
+beforeEach(() => {
+  fetchResultsMock.mockReset();
+  metricChartsMock.mockReset();
+  fetchResultsMock.mockReturnValue(
+    Promise.resolve([{ data: [], truncated: false }]),
+  );
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("MetricView compare with previous period", () => {
+  test("fetches the shifted window alongside the live one and hands both down", async () => {
+    render(
+      <MetricView
+        data={buildData()}
+        hideQueryElements={true}
+        hideStartAndEndDate={true}
+        compareWithPreviousPeriod={true}
+        onChange={() => {
+          // not exercised
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(fetchResultsMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+    });
+
+    const windows: Array<[number, number]> = fetchResultsMock.mock.calls.map(
+      (call: Array<unknown>): [number, number] => {
+        const args: CapturedFetch = call[0] as CapturedFetch;
+        return [
+          args.metricViewData.startAndEndDate!.startValue.getTime(),
+          args.metricViewData.startAndEndDate!.endValue.getTime(),
+        ];
+      },
+    );
+
+    /*
+     * One live window and one shifted back by EXACTLY the window width
+     * (bucket-congruent modulo the shift). Alignment may floor the live
+     * start onto the bucket grid, so assert the relationship between the
+     * two fetches rather than raw instants.
+     */
+    const [liveWindow, previousWindow] = windows as [
+      [number, number],
+      [number, number],
+    ];
+    const liveWidth: number = liveWindow[1] - liveWindow[0];
+    expect(previousWindow[0]).toBe(liveWindow[0] - liveWidth);
+    expect(previousWindow[1]).toBe(liveWindow[1] - liveWidth);
+    expect(liveWidth).toBeGreaterThanOrEqual(WINDOW_MS);
+
+    await waitFor(() => {
+      const lastProps: Record<string, unknown> = metricChartsMock.mock.calls[
+        metricChartsMock.mock.calls.length - 1
+      ]?.[0] as Record<string, unknown>;
+      expect(lastProps["metricResultsPrevious"]).toBeTruthy();
+      expect(lastProps["compareOffsetMs"]).toBe(liveWidth);
+    });
+  });
+
+  test("compare off means exactly one fetch and no ghost props", async () => {
+    render(
+      <MetricView
+        data={buildData()}
+        hideQueryElements={true}
+        hideStartAndEndDate={true}
+        onChange={() => {
+          // not exercised
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(fetchResultsMock).toHaveBeenCalled();
+    });
+    // Let any (wrong) shifted fetch get scheduled before asserting.
+    await new Promise((resolve: (value: unknown) => void) => {
+      setTimeout(resolve, 30);
+    });
+    /*
+     * MetricView may legitimately refetch the LIVE window more than once
+     * on mount — what compare-off forbids is any fetch of a SHIFTED
+     * (earlier) window.
+     */
+    const anyShiftedFetch: boolean = fetchResultsMock.mock.calls.some(
+      (call: Array<unknown>): boolean => {
+        const args: CapturedFetch = call[0] as CapturedFetch;
+        return (
+          args.metricViewData.startAndEndDate!.endValue.getTime() <=
+          WINDOW_START.getTime()
+        );
+      },
+    );
+    expect(anyShiftedFetch).toBe(false);
+    const lastProps: Record<string, unknown> = metricChartsMock.mock.calls[
+      metricChartsMock.mock.calls.length - 1
+    ]?.[0] as Record<string, unknown>;
+    expect(lastProps["metricResultsPrevious"]).toBeUndefined();
+  });
+
+  test("a failed shifted fetch degrades to live-only, never an error", async () => {
+    fetchResultsMock.mockImplementation(
+      (args: { metricViewData: MetricViewData }) => {
+        const start: number =
+          args.metricViewData.startAndEndDate!.startValue.getTime();
+        // The shifted (earlier) fetch fails; the live one succeeds.
+        if (start < WINDOW_START.getTime()) {
+          return Promise.reject(new Error("clickhouse hiccup"));
+        }
+        return Promise.resolve([{ data: [], truncated: false }]);
+      },
+    );
+
+    render(
+      <MetricView
+        data={buildData()}
+        hideQueryElements={true}
+        hideStartAndEndDate={true}
+        compareWithPreviousPeriod={true}
+        onChange={() => {
+          // not exercised
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(metricChartsMock).toHaveBeenCalled();
+    });
+
+    const lastProps: Record<string, unknown> = metricChartsMock.mock.calls[
+      metricChartsMock.mock.calls.length - 1
+    ]?.[0] as Record<string, unknown>;
+    expect(lastProps["metricResults"]).toBeTruthy();
+    expect(lastProps["metricResultsPrevious"]).toBeUndefined();
+  });
+});

package/Tests/Server/API/UserAuthenticationAPI.test.ts

@@ -96,6 +96,14 @@ const AUTHENTICATION_STATUS: UserAuthenticationStatus = {
    */
   twoFactorAuthStatus: TwoFactorAuthStatus.EnabledPendingSetup,
   verifiedTwoFactorAuthMethodCount: 0,
+
+  /*
+   * Reported alongside the method count, never folded into it -- backup codes
+   * are the way back in to an account whose factor is unreachable, not a
+   * factor. Zero here keeps this fixture the pure "mandated, nothing set up"
+   * case it exists to be.
+   */
+  unusedTwoFactorBackupCodeCount: 0,
   hasPendingPasswordResetLink: false,
 };
 
@@ -201,9 +209,13 @@ describe("GET /user/:userId/authentication-status", () => {
 
   test("sends exactly what the service reported", async () => {
     /*
-     * The page renders these four booleans directly. A field dropped or
-     * renamed on the way out reads as `undefined`, which the UI shows as "no
-     * password" for an account that has one.
+     * The page renders these fields directly. One dropped or renamed on the
+     * way out reads as `undefined`, which the UI shows as "no password" for an
+     * account that has one.
+     *
+     * Asserted as an EXACT object rather than field by field, so a new field
+     * added to the DTO has to be added here too -- which is how this test has
+     * done its job twice now, most recently for the backup code count.
      */
     await callRoute({
       method: "GET",
@@ -217,6 +229,7 @@ describe("GET /user/:userId/authentication-status", () => {
       isTwoFactorAuthEnabled: true,
       twoFactorAuthStatus: TwoFactorAuthStatus.EnabledPendingSetup,
       verifiedTwoFactorAuthMethodCount: 0,
+      unusedTwoFactorBackupCodeCount: 0,
       hasPendingPasswordResetLink: false,
     });
   });