@oneuptime/common 12.0.20 → 12.0.21

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/Infrastructure/Postgres/AddUserSlackAndMicrosoftTeamsMigration.test.ts

@@ -0,0 +1,236 @@
+import { AddUserSlackAndMicrosoftTeams1789000000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1789000000000-AddUserSlackAndMicrosoftTeams";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { MigrationInterface, QueryRunner } from "typeorm";
+import fs from "fs";
+import path from "path";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The guard that lets this migration run twice.
+ *
+ * It shipped as AddUserSlackAndMicrosoftTeams1788800000000 and was renumbered
+ * to 1789000000000 to clear a timestamp collision. TypeORM records a migration
+ * by class NAME, so the rename made it pending again on every database that
+ * had already run it, and `CREATE TABLE "UserSlack"` failed on its own table —
+ * which stops the runner, leaving this and every later migration pending on
+ * every boot until it is fixed.
+ *
+ * So there are two databases to satisfy, and both are asserted below: one that
+ * has never seen this migration must get the whole schema, and one that
+ * already carries it must get no DDL at all.
+ *
+ * The statements are inspected rather than executed — these tests run without
+ * a database, and what can go wrong here is which statements are issued, not
+ * whether Postgres understands them.
+ */
+
+const MIGRATION_NAME: string = "AddUserSlackAndMicrosoftTeams1789000000000";
+
+const SUPERSEDED_MIGRATION_NAME: string =
+  "AddUserSlackAndMicrosoftTeams1788800000000";
+
+const MIGRATION_TIMESTAMP: string = "1789000000000";
+
+const MIGRATION_DIRECTORY: string = path.join(
+  __dirname,
+  "../../../../Server/Infrastructure/Postgres/SchemaMigrations",
+);
+
+/*
+ * Every statement `up` issues after the probe. The count is asserted rather
+ * than sampled: the risk the guard introduces is an early return that swallows
+ * work a fresh install needs, and only a total catches a statement going
+ * missing from the middle.
+ */
+const STATEMENTS_IN_UP: number = 30;
+
+type CapturedQueryRunner = {
+  runner: QueryRunner;
+  queries: Array<string>;
+};
+
+type IsProbeFunction = (sql: string) => boolean;
+
+/*
+ * The one read `up` makes: does "UserSlack" already exist? Matched on shape
+ * rather than on the exact string so reformatting the SQL does not fail these.
+ */
+const isProbe: IsProbeFunction = (sql: string): boolean => {
+  return (
+    sql.includes("information_schema.tables") && sql.includes("'UserSlack'")
+  );
+};
+
+type MockQueryRunnerFunction = (
+  userSlackTableExists: boolean,
+) => CapturedQueryRunner;
+
+const mockQueryRunner: MockQueryRunnerFunction = (
+  userSlackTableExists: boolean,
+): CapturedQueryRunner => {
+  const queries: Array<string> = [];
+
+  return {
+    queries: queries,
+    runner: {
+      query: async (sql: string): Promise<unknown> => {
+        queries.push(sql);
+
+        if (isProbe(sql)) {
+          return [{ exists: userSlackTableExists }];
+        }
+
+        return undefined;
+      },
+    } as unknown as QueryRunner,
+  };
+};
+
+const migration: AddUserSlackAndMicrosoftTeams1789000000000 =
+  new AddUserSlackAndMicrosoftTeams1789000000000();
+
+describe("AddUserSlackAndMicrosoftTeams migration", () => {
+  /*
+   * TypeORM matches migrations by this name. A mismatch between the class name
+   * and the `name` property makes the migration run again on every boot.
+   */
+  test("names itself consistently so it is recorded as run", () => {
+    expect(migration.name).toBe(MIGRATION_NAME);
+    expect(AddUserSlackAndMicrosoftTeams1789000000000.name).toBe(
+      MIGRATION_NAME,
+    );
+  });
+
+  describe("registration", () => {
+    test("it is registered exactly once", () => {
+      const occurrences: number = SchemaMigrations.filter(
+        (registered: new () => MigrationInterface): boolean => {
+          return registered.name === MIGRATION_NAME;
+        },
+      ).length;
+
+      expect(occurrences).toBe(1);
+    });
+
+    /*
+     * The old number belongs to DropMarketingConversionAddEnterpriseLicenseEmail
+     * now. Registering both names would run the same DDL twice under two
+     * records, which is the failure this migration already had once.
+     */
+    test("no longer registers the timestamp it was renamed away from", () => {
+      const names: Array<string> = SchemaMigrations.map(
+        (registered: new () => MigrationInterface): string => {
+          return registered.name;
+        },
+      );
+
+      expect(names).not.toContain(SUPERSEDED_MIGRATION_NAME);
+    });
+
+    test("exactly one file on disk carries its timestamp, and it is this one", () => {
+      const matching: Array<string> = fs
+        .readdirSync(MIGRATION_DIRECTORY)
+        .filter((file: string): boolean => {
+          return file.startsWith(`${MIGRATION_TIMESTAMP}-`);
+        });
+
+      expect(matching).toEqual([
+        `${MIGRATION_TIMESTAMP}-AddUserSlackAndMicrosoftTeams.ts`,
+      ]);
+    });
+  });
+
+  describe("on a database that has never run it", () => {
+    test("checks for the table before touching anything", async () => {
+      const up: CapturedQueryRunner = mockQueryRunner(false);
+
+      await migration.up(up.runner);
+
+      expect(isProbe(up.queries[0]!)).toBe(true);
+    });
+
+    test("creates the whole schema, unchanged by the guard", async () => {
+      const up: CapturedQueryRunner = mockQueryRunner(false);
+
+      await migration.up(up.runner);
+
+      const statements: Array<string> = up.queries.filter(
+        (sql: string): boolean => {
+          return !isProbe(sql);
+        },
+      );
+
+      expect(statements.length).toBe(STATEMENTS_IN_UP);
+    });
+
+    test("creates both method tables and their notification wiring", async () => {
+      const up: CapturedQueryRunner = mockQueryRunner(false);
+
+      await migration.up(up.runner);
+
+      const sql: string = up.queries.join("\n");
+
+      expect(sql).toContain(`CREATE TABLE "UserSlack"`);
+      expect(sql).toContain(`CREATE TABLE "UserMicrosoftTeams"`);
+      expect(sql).toContain(
+        `ALTER TABLE "UserNotificationRule" ADD "userSlackId" uuid`,
+      );
+      expect(sql).toContain(
+        `ALTER TABLE "UserNotificationRule" ADD "userMicrosoftTeamsId" uuid`,
+      );
+      expect(sql).toContain(
+        `ALTER TABLE "UserNotificationSetting" ADD "alertBySlack" boolean NOT NULL DEFAULT false`,
+      );
+      expect(sql).toContain(
+        `ALTER TABLE "UserNotificationSetting" ADD "alertByMicrosoftTeams" boolean NOT NULL DEFAULT false`,
+      );
+    });
+  });
+
+  describe("on a database that already ran it under its old name", () => {
+    /*
+     * The whole point. Migrations run one transaction each, so a recorded run
+     * committed all 30 statements or none of them — the table being there means
+     * the schema is there, and re-issuing any of it can only fail.
+     */
+    test("issues nothing but the probe", async () => {
+      const up: CapturedQueryRunner = mockQueryRunner(true);
+
+      await migration.up(up.runner);
+
+      expect(up.queries.length).toBe(1);
+      expect(isProbe(up.queries[0]!)).toBe(true);
+    });
+
+    test("never re-runs the CREATE TABLE that was failing", async () => {
+      const up: CapturedQueryRunner = mockQueryRunner(true);
+
+      await migration.up(up.runner);
+
+      const sql: string = up.queries.join("\n");
+
+      expect(sql).not.toContain(`CREATE TABLE "UserSlack"`);
+      expect(sql).not.toContain(`CREATE TABLE "UserMicrosoftTeams"`);
+      expect(sql).not.toContain("ADD CONSTRAINT");
+    });
+  });
+
+  /*
+   * `down` is deliberately NOT guarded. It reverses the schema whichever name
+   * recorded it, and a rollback that finds the tables missing has bigger
+   * problems than a failed DROP.
+   */
+  describe("down", () => {
+    test("drops both method tables", async () => {
+      const down: CapturedQueryRunner = mockQueryRunner(true);
+
+      await migration.down(down.runner);
+
+      const sql: string = down.queries.join("\n");
+
+      expect(sql).toContain(`DROP TABLE "UserSlack"`);
+      expect(sql).toContain(`DROP TABLE "UserMicrosoftTeams"`);
+      expect(down.queries.length).toBe(STATEMENTS_IN_UP);
+    });
+  });
+});