@oneuptime/common 12.0.4 → 12.0.6

package/Tests/App/AdminDashboard/AdminUsersIdFilter.test.tsx

@@ -0,0 +1,216 @@
+import "@testing-library/jest-dom";
+import { render, waitFor } from "@testing-library/react";
+import React from "react";
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+import { Location, MemoryRouter } from "react-router-dom";
+
+/*
+ * A master admin who has an ID in hand - out of a support ticket, a log line,
+ * an API response - needs to get from that ID to the user it belongs to. The
+ * Users table's search box only covers name and email, so before this filter
+ * existed the only route was paging through every user on the instance.
+ *
+ * The filter is declarative: the page hands ModelTable a `filters` array and
+ * the shared table machinery does the rest. That makes the declaration itself
+ * the whole feature, and losing a line of it is silent - the table renders
+ * perfectly well with one fewer filter. Hence this file pins the declaration.
+ */
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string): string => {
+          return key;
+        },
+      };
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Permission", () => {
+  return {
+    __esModule: true,
+    default: {
+      getAllPermissions: () => {
+        return [];
+      },
+      getProjectPermissions: () => {
+        return [];
+      },
+      getGlobalPermissions: () => {
+        return [];
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: () => {
+        return true;
+      },
+      getUserId: () => {
+        return null;
+      },
+    },
+  };
+});
+
+/*
+ * The real ModelTable would drag in the pager, the URL state and a live fetch.
+ * What this file is about is the props the page hands it, so a stand-in that
+ * records them is both enough and more precise.
+ */
+type CapturedTableProps = {
+  filters?: Array<Filter<User>> | undefined;
+  searchableFields?: Array<string> | undefined;
+  showViewIdButton?: boolean | undefined;
+};
+
+let capturedTableProps: CapturedTableProps | null = null;
+
+jest.mock("../../../UI/Components/ModelTable/ModelTable", () => {
+  return {
+    __esModule: true,
+    default: (props: CapturedTableProps) => {
+      capturedTableProps = props;
+      return null;
+    },
+  };
+});
+
+import Users from "../../../../App/FeatureSet/AdminDashboard/src/Pages/Users/Index";
+import Filter from "../../../UI/Components/ModelFilter/Filter";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import Navigation from "../../../UI/Utils/Navigation";
+import User from "../../../Models/DatabaseModels/User";
+import { getFilterKeys } from "../../../UI/Components/ModelTable/FilterDataToQuery";
+
+type FilterTitledFunction = (title: string) => Filter<User>;
+
+const filterTitled: FilterTitledFunction = (title: string): Filter<User> => {
+  const filter: Filter<User> | undefined = (
+    capturedTableProps?.filters || []
+  ).find((candidate: Filter<User>) => {
+    return candidate.title === title;
+  });
+
+  if (!filter) {
+    throw new Error(
+      `No "${title}" filter. Filters: ${(capturedTableProps?.filters || [])
+        .map((candidate: Filter<User>) => {
+          return candidate.title;
+        })
+        .join(", ")}`,
+    );
+  }
+
+  return filter;
+};
+
+describe("Admin > Users page", () => {
+  beforeEach(async () => {
+    capturedTableProps = null;
+
+    /*
+     * The page reads the current route to build the row's view link. In the
+     * app the router pushes this in; under test nothing does.
+     */
+    Navigation.setLocation({
+      pathname: "/admin/users",
+      search: "",
+      hash: "",
+      state: null,
+      key: "test",
+    } as Location);
+
+    render(
+      <MemoryRouter>
+        <Users />
+      </MemoryRouter>,
+    );
+
+    await waitFor(() => {
+      expect(capturedTableProps).not.toBeNull();
+    });
+  });
+
+  describe("the User ID filter", () => {
+    test("is offered as a filter", () => {
+      expect(() => {
+        return filterTitled("User ID");
+      }).not.toThrow();
+    });
+
+    /*
+     * `_id` and nothing else. A filter pointed at any other column would look
+     * identical in the UI and quietly return the wrong rows.
+     */
+    test("filters on the user's own id column", () => {
+      expect(filterTitled("User ID").field).toEqual({ _id: true });
+    });
+
+    /*
+     * The type is what picks the input the filter modal renders. ObjectID
+     * routes to the text input with its operator menu (contains / equals /
+     * starts with / ...); Entity or Dropdown would render a picker of options
+     * that nothing populates, leaving an admin with an ID and no way to type
+     * it.
+     */
+    test("renders as a typed-in ID, not a picker", () => {
+      expect(filterTitled("User ID").type).toBe(FieldType.ObjectID);
+    });
+
+    /*
+     * `sanitizeFilterData` drops any key the table did not declare a filter
+     * for, so an undeclared `_id` would be stripped between the modal and the
+     * request - the modal would accept the ID and the table would come back
+     * unfiltered.
+     */
+    test("declares _id as an allowed filter key", () => {
+      expect(getFilterKeys<User>(capturedTableProps!.filters || [])).toContain(
+        "_id",
+      );
+    });
+
+    test("comes first, where an admin pasting an ID will look", () => {
+      expect(capturedTableProps!.filters?.[0]?.title).toBe("User ID");
+    });
+  });
+
+  describe("what it must not have displaced", () => {
+    test("keeps the filters the page already had", () => {
+      expect(
+        (capturedTableProps!.filters || []).map((filter: Filter<User>) => {
+          return filter.title;
+        }),
+      ).toEqual([
+        "User ID",
+        "Full Name",
+        "Email",
+        "Email Verified",
+        "Last Active At",
+      ]);
+    });
+
+    /*
+     * Free-text search stays on name and email. Adding `_id` here would make
+     * every single-character search match nearly every row on the instance,
+     * because a hex id contains most characters somewhere.
+     */
+    test("leaves the search box searching names and emails", () => {
+      expect(capturedTableProps!.searchableFields).toEqual(["name", "email"]);
+    });
+
+    /*
+     * Filtering by ID is only half the loop - the other half is reading an ID
+     * off a row to filter or search with elsewhere.
+     */
+    test("still lets an admin read a row's id", () => {
+      expect(capturedTableProps!.showViewIdButton).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,422 @@
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import React, { act } from "react";
+
+/*
+ * The human actions on the insight detail page, driven against a fake server
+ * that implements the same rules AIInsightService does.
+ *
+ * Two bugs live here, and both are invisible to a source-text wiring test:
+ *
+ *  - The action bar was rendered only while the insight was open, so a
+ *    dismissal — one click, terminal, and additionally a suppression of the
+ *    same fingerprint for InsightStore's cooldown — could not be undone from
+ *    the UI at all.
+ *  - Confirm was disabled whenever a Confirmed verdict already existed. A
+ *    disabled Button in this design keeps its enabled styling and the browser
+ *    swallows the click, so "already confirmed" and "the button is broken"
+ *    looked identical.
+ *
+ * Everything below therefore asserts what a person can actually see and press
+ * after each action, not which props were passed.
+ */
+
+const INSIGHT_ID: string = "11111111-1111-4111-8111-111111111111";
+
+const postMock: jest.Mock<any, any> = jest.fn() as jest.Mock<any, any>;
+
+jest.mock("react-router-dom", () => {
+  return {
+    __esModule: true,
+    useParams: () => {
+      return { id: INSIGHT_ID };
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      post: (...args: Array<any>) => {
+        return postMock(...args);
+      },
+      getFriendlyMessage: () => {
+        return "Request failed";
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getItem: () => {
+        return Promise.resolve(buildInsight());
+      },
+      getCommonHeaders: () => {
+        return {};
+      },
+    },
+  };
+});
+
+import AIInsightViewPage from "../../../../App/FeatureSet/Dashboard/src/Pages/AIInsights/View/Index";
+import AIInsight from "../../../Models/DatabaseModels/AIInsight";
+import AIInsightHumanVerdict from "../../../Types/AI/AIInsightHumanVerdict";
+import AIInsightSeverity from "../../../Types/AI/AIInsightSeverity";
+import AIInsightStatus from "../../../Types/AI/AIInsightStatus";
+import AIInsightType from "../../../Types/AI/AIInsightType";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The fake server's row. Kept deliberately close to the real columns: the
+ * page reads status/humanVerdict back after every action, so a fake that did
+ * not persist writes would hide exactly the class of bug being tested.
+ */
+interface FakeRow {
+  status: AIInsightStatus;
+  humanVerdict: AIInsightHumanVerdict | null;
+  fixAiRunId: ObjectID | null;
+}
+
+let row: FakeRow;
+
+type BuildInsightFunction = () => AIInsight;
+
+const buildInsight: BuildInsightFunction = (): AIInsight => {
+  const insight: AIInsight = new AIInsight();
+  insight.id = new ObjectID(INSIGHT_ID);
+  insight.title = "New exception: 401 in api";
+  insight.insightType = AIInsightType.NewException;
+  insight.severity = AIInsightSeverity.Medium;
+  insight.detailMarkdown = "New exception detected";
+  insight.occurrenceCount = 4;
+  insight.status = row.status;
+  if (row.humanVerdict) {
+    insight.humanVerdict = row.humanVerdict;
+  }
+  if (row.fixAiRunId) {
+    insight.fixAiRunId = row.fixAiRunId;
+  }
+  return insight;
+};
+
+// AIInsightService.getReopenStatus, mirrored.
+type ReopenStatusFunction = () => AIInsightStatus;
+
+const reopenStatus: ReopenStatusFunction = (): AIInsightStatus => {
+  return row.fixAiRunId
+    ? AIInsightStatus.FixOpened
+    : AIInsightStatus.ActionRequired;
+};
+
+/*
+ * AIInsightAPI's three write routes, implemented against `row` exactly as the
+ * service does — including the two rules the page duplicates optimistically
+ * (Confirmed reopens an insight closed AS Dismissed; reopen clears the
+ * verdict), so a page that got either one wrong would disagree with the
+ * refetch and fail here.
+ */
+type HandlePostFunction = (args: {
+  url: { toString: () => string };
+  data: JSONObject;
+}) => Promise<HTTPResponse<JSONObject>>;
+
+const handlePost: HandlePostFunction = async (args: {
+  url: { toString: () => string };
+  data: JSONObject;
+}): Promise<HTTPResponse<JSONObject>> => {
+  const url: string = args.url.toString();
+
+  if (url.includes("/ai-insight/triage-run")) {
+    return new HTTPResponse<JSONObject>(200, { run: null, events: [] }, {});
+  }
+
+  if (url.includes("/ai-insight/verdict")) {
+    const verdict: AIInsightHumanVerdict = args.data[
+      "verdict"
+    ] as AIInsightHumanVerdict;
+
+    if (verdict === AIInsightHumanVerdict.Dismissed) {
+      row.status = AIInsightStatus.Dismissed;
+    } else if (row.status === AIInsightStatus.Dismissed) {
+      row.status = reopenStatus();
+    }
+    row.humanVerdict = verdict;
+
+    return new HTTPResponse<JSONObject>(
+      200,
+      { insightId: INSIGHT_ID, verdict: verdict, status: row.status },
+      {},
+    );
+  }
+
+  if (url.includes("/ai-insight/resolve")) {
+    row.status = AIInsightStatus.Resolved;
+    if (!row.humanVerdict) {
+      row.humanVerdict = AIInsightHumanVerdict.Confirmed;
+    }
+    return new HTTPResponse<JSONObject>(
+      200,
+      { insightId: INSIGHT_ID, status: row.status },
+      {},
+    );
+  }
+
+  if (url.includes("/ai-insight/reopen")) {
+    if (
+      row.status === AIInsightStatus.Dismissed ||
+      row.status === AIInsightStatus.Resolved
+    ) {
+      row.status = reopenStatus();
+      row.humanVerdict = null;
+    }
+    return new HTTPResponse<JSONObject>(
+      200,
+      { insightId: INSIGHT_ID, status: row.status },
+      {},
+    );
+  }
+
+  return new HTTPResponse<JSONObject>(200, {}, {});
+};
+
+type RenderPageFunction = () => Promise<void>;
+
+const renderPage: RenderPageFunction = async (): Promise<void> => {
+  render(<AIInsightViewPage {...({} as any)} />);
+  await waitFor(() => {
+    return expect(
+      screen.getByText("New exception: 401 in api"),
+    ).toBeInTheDocument();
+  });
+};
+
+type ClickFunction = (name: string) => Promise<void>;
+
+const click: ClickFunction = async (name: string): Promise<void> => {
+  await act(async () => {
+    fireEvent.click(screen.getByRole("button", { name: name }));
+  });
+};
+
+type PostedRoutesFunction = () => Array<string>;
+
+const postedRoutes: PostedRoutesFunction = (): Array<string> => {
+  return postMock.mock.calls.map((call: Array<any>) => {
+    return String(call[0].url);
+  });
+};
+
+describe("AI insight detail — human actions", () => {
+  beforeEach(() => {
+    row = {
+      status: AIInsightStatus.ActionRequired,
+      humanVerdict: null,
+      fixAiRunId: null,
+    };
+    postMock.mockReset();
+    postMock.mockImplementation((args: any) => {
+      return handlePost(args);
+    });
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("confirming an open insight records the verdict and shows it", async () => {
+    await renderPage();
+
+    expect(screen.getByText("Needs Attention")).toBeInTheDocument();
+    expect(screen.queryByText("Confirmed")).not.toBeInTheDocument();
+
+    await click("Confirm");
+
+    await waitFor(() => {
+      return expect(screen.getByText("Confirmed")).toBeInTheDocument();
+    });
+    // The verdict survives the reconciling refetch, not just the optimism.
+    expect(row.humanVerdict).toBe(AIInsightHumanVerdict.Confirmed);
+    // Confirming does not close an open insight.
+    expect(screen.getByText("Needs Attention")).toBeInTheDocument();
+  });
+
+  test("a dismissed insight keeps its actions — this is the undo path", async () => {
+    await renderPage();
+
+    await click("Dismiss");
+
+    await waitFor(() => {
+      // Both pills read Dismissed: the lifecycle status and the verdict.
+      return expect(screen.getAllByText("Dismissed")).toHaveLength(2);
+    });
+
+    /*
+     * The regression: the whole bar used to unmount here, leaving a closed
+     * insight with no control on the page at all.
+     */
+    expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled();
+    expect(screen.getByRole("button", { name: "Reopen" })).toBeEnabled();
+    // Resolve gives way to Reopen — "close as handled" is meaningless now.
+    expect(
+      screen.queryByRole("button", { name: "Resolve" }),
+    ).not.toBeInTheDocument();
+    // And the footer no longer reads as a dead end.
+    expect(screen.getByText(/you can reopen it here/)).toBeInTheDocument();
+  });
+
+  test("Reopen undoes a dismissal and clears the verdict", async () => {
+    await renderPage();
+
+    await click("Dismiss");
+    await waitFor(() => {
+      return expect(screen.getAllByText("Dismissed")).toHaveLength(2);
+    });
+
+    await click("Reopen");
+
+    await waitFor(() => {
+      return expect(screen.getByText("Needs Attention")).toBeInTheDocument();
+    });
+
+    expect(screen.queryAllByText("Dismissed")).toHaveLength(0);
+    expect(screen.queryByText("Confirmed")).not.toBeInTheDocument();
+    expect(row.status).toBe(AIInsightStatus.ActionRequired);
+    /*
+     * Cleared, not merely hidden: a verdict the human took back must stop
+     * counting toward per-detector precision, and a stale humanVerdictAt
+     * would otherwise keep anchoring InsightStore's dismissal cooldown.
+     */
+    expect(row.humanVerdict).toBeNull();
+    expect(
+      postedRoutes().some((url: string) => {
+        return url.endsWith("/ai-insight/reopen");
+      }),
+    ).toBe(true);
+    // Back to an open insight, so Resolve is available again.
+    expect(screen.getByRole("button", { name: "Resolve" })).toBeEnabled();
+  });
+
+  test("Reopen restores FixOpened when a fix task is attached", async () => {
+    row.fixAiRunId = new ObjectID("33333333-3333-4333-8333-333333333333");
+    await renderPage();
+
+    await click("Dismiss");
+    await waitFor(() => {
+      return expect(screen.getAllByText("Dismissed")).toHaveLength(2);
+    });
+
+    await click("Reopen");
+
+    await waitFor(() => {
+      return expect(screen.getByText("Fix Opened")).toBeInTheDocument();
+    });
+    expect(row.status).toBe(AIInsightStatus.FixOpened);
+  });
+
+  test("confirming a dismissed insight reopens it — Confirm is never a dead click", async () => {
+    row.status = AIInsightStatus.Dismissed;
+    row.humanVerdict = AIInsightHumanVerdict.Dismissed;
+    await renderPage();
+
+    /*
+     * Confirm still has work to do here even though a verdict exists, so it
+     * must be pressable — the old `disabled={isConfirmed}` rule is only
+     * about the verdict and would have to be re-derived to get this wrong.
+     */
+    expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled();
+
+    await click("Confirm");
+
+    await waitFor(() => {
+      return expect(screen.getByText("Confirmed")).toBeInTheDocument();
+    });
+
+    // "Closed as noise" cannot survive a Confirmed verdict.
+    expect(screen.getByText("Needs Attention")).toBeInTheDocument();
+    expect(row.status).toBe(AIInsightStatus.ActionRequired);
+    expect(screen.queryAllByText("Dismissed")).toHaveLength(0);
+  });
+
+  test("a button is disabled only when pressing it would change nothing", async () => {
+    row.humanVerdict = AIInsightHumanVerdict.Confirmed;
+    await renderPage();
+
+    // Already Confirmed and already open: confirming again is a genuine no-op.
+    expect(screen.getByRole("button", { name: "Confirm" })).toBeDisabled();
+    // ...and it now looks disabled, rather than swallowing the click silently.
+    expect(screen.getByRole("button", { name: "Confirm" })).toHaveClass(
+      "disabled:opacity-50",
+    );
+    // Dismiss still changes something (the verdict and the status).
+    expect(screen.getByRole("button", { name: "Dismiss" })).toBeEnabled();
+  });
+
+  test("a resolved insight can still be reopened", async () => {
+    await renderPage();
+
+    await click("Resolve");
+
+    await waitFor(() => {
+      return expect(screen.getByText("Resolved")).toBeInTheDocument();
+    });
+    // Resolve implies the finding was real.
+    expect(screen.getByText("Confirmed")).toBeInTheDocument();
+
+    await click("Reopen");
+
+    await waitFor(() => {
+      return expect(screen.getByText("Needs Attention")).toBeInTheDocument();
+    });
+    expect(row.humanVerdict).toBeNull();
+  });
+
+  test("a failed action rolls back and says so instead of failing silently", async () => {
+    await renderPage();
+
+    postMock.mockImplementation((args: any) => {
+      if (String(args.url).includes("/ai-insight/verdict")) {
+        return Promise.resolve(
+          new HTTPErrorResponse(500, { message: "nope" }, {}),
+        );
+      }
+      return handlePost(args);
+    });
+
+    await click("Dismiss");
+
+    /*
+     * By role, not by text: Alert splices strongTitle and title into one
+     * "<strong> - <message>" line, so an exact text match silently misses the
+     * banner and the test would pass on a page that showed nothing.
+     */
+    const banner: HTMLElement = await screen.findByRole("alert");
+    expect(banner).toHaveTextContent("Could not save your action");
+    expect(banner).toHaveTextContent("Request failed");
+
+    // Rolled back: the insight is still open and still has no verdict.
+    expect(screen.getByText("Needs Attention")).toBeInTheDocument();
+    expect(screen.queryAllByText("Dismissed")).toHaveLength(0);
+    expect(row.status).toBe(AIInsightStatus.ActionRequired);
+  });
+});