@oneuptime/common 14.0.3 → 14.0.6

package/Tests/UI/Utils/Breadcrumb/fixtures/RealBreadcrumbTrails.ts

@@ -476,6 +476,76 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
     pagePattern: "/dashboard/:projectId/dashboards/settings/owner-rules",
     titles: ["Project", "Dashboards", "Settings", "Owner Rules"],
   },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases",
+    titles: ["Project", "Databases"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/archived",
+    titles: ["Project", "Databases", "Archived"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/documentation",
+    titles: ["Project", "Databases", "Documentation"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id",
+    titles: ["Project", "Databases", "View Database"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/delete",
+    titles: ["Project", "Databases", "View Database", "Delete Database"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/documentation",
+    titles: ["Project", "Databases", "View Database", "Documentation"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/endpoints",
+    titles: ["Project", "Databases", "View Database", "Endpoints"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/feed",
+    titles: ["Project", "Databases", "View Database", "Feed"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/logs",
+    titles: ["Project", "Databases", "View Database", "Logs"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/metrics",
+    titles: ["Project", "Databases", "View Database", "Metrics"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/owners",
+    titles: ["Project", "Databases", "View Database", "Owners"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/recommendations",
+    titles: ["Project", "Databases", "View Database", "Recommendations"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/settings",
+    titles: ["Project", "Databases", "View Database", "Settings"],
+  },
+  {
+    getter: "getDatabaseBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/databases/:id/traces",
+    titles: ["Project", "Databases", "View Database", "Traces"],
+  },
   {
     getter: "getDockerBreadcrumbs",
     pagePattern: "/dashboard/:projectId/docker",

package/Tests/UI/Utils/Breadcrumb/fixtures/RealRoutePatterns.ts

@@ -506,6 +506,27 @@ const realRoutePatterns: Array<string> = [
   "/dashboard/:projectId/cloud/settings/label-rules",
   "/dashboard/:projectId/cloud/archived",
   "/dashboard/:projectId/cloud/settings/owner-rules",
+  "/dashboard/:projectId/databases/*",
+  "/dashboard/:projectId/databases",
+  "/dashboard/:projectId/databases/:id",
+  "/dashboard/:projectId/databases/:id/metrics",
+  "/dashboard/:projectId/databases/:id/logs",
+  "/dashboard/:projectId/databases/:id/traces",
+  "/dashboard/:projectId/databases/:id/incidents",
+  "/dashboard/:projectId/databases/:id/alerts",
+  "/dashboard/:projectId/databases/:id/scheduled-maintenance",
+  "/dashboard/:projectId/databases/:id/feed",
+  "/dashboard/:projectId/databases/:id/owners",
+  "/dashboard/:projectId/databases/:id/endpoints",
+  "/dashboard/:projectId/databases/:id/settings",
+  "/dashboard/:projectId/databases/:id/documentation",
+  "/dashboard/:projectId/databases/:id/delete",
+  "/dashboard/:projectId/databases/documentation",
+  "/dashboard/:projectId/databases/settings/label-rules",
+  "/dashboard/:projectId/databases/settings/label-rules/:id",
+  "/dashboard/:projectId/databases/settings/owner-rules",
+  "/dashboard/:projectId/databases/settings/owner-rules/:id",
+  "/dashboard/:projectId/databases/archived",
   "/dashboard/:projectId/rum/*",
   "/dashboard/:projectId/rum",
   "/dashboard/:projectId/rum/:id",

package/Tests/UI/Utils/ModelAPISsoRedirect.test.ts

@@ -0,0 +1,127 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import ModelAPI from "../../../UI/Utils/ModelAPI/ModelAPI";
+import API from "../../../UI/Utils/API/API";
+import Navigation from "../../../UI/Utils/Navigation";
+import ProjectUtil from "../../../UI/Utils/Project";
+import IncidentState from "../../../Models/DatabaseModels/IncidentState";
+import Project from "../../../Models/DatabaseModels/Project";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import SSOAuthorizationException from "../../../Types/Exception/SsoAuthorizationException";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The server answers a project-scoped request with 406 "SSO Authorization
+ * Required" when the project requires SSO and this session has not signed in
+ * through it. Every ModelAPI request sends the user to the project's SSO page
+ * on that answer, before rethrowing, whatever BILLING_ENABLED is set to. With
+ * billing disabled, this is what moves a user in an SSO-only project off
+ * pages whose data comes through ModelAPI (the dashboard header's alert and
+ * incident state lookups, the home page's lists and counts).
+ */
+
+const PROJECT_ID: string = "019acd20-1111-4111-8111-111111111111";
+const SSO_PATH: string = `/dashboard/${PROJECT_ID}/sso`;
+
+// Spies are held through the one property these tests read off them.
+interface CallRecorder {
+  mock: { calls: Array<Array<unknown>> };
+}
+
+let navigate: CallRecorder;
+
+function navigatedTo(): Array<string> {
+  return navigate.mock.calls.map((call: Array<unknown>): string => {
+    return String(call[0]);
+  });
+}
+
+function respondWith(statusCode: number, message: string): void {
+  jest
+    .spyOn(API, "fetch")
+    .mockResolvedValue(
+      new HTTPErrorResponse(statusCode, { message: message }, {}) as never,
+    );
+}
+
+async function thrownBy(request: Promise<unknown>): Promise<unknown> {
+  try {
+    await request;
+  } catch (error) {
+    return error;
+  }
+
+  throw new Error("Expected the request to throw");
+}
+
+beforeEach(() => {
+  const project: Project = new Project();
+  project.id = new ObjectID(PROJECT_ID);
+
+  jest
+    .spyOn(ProjectUtil, "getCurrentProjectId")
+    .mockReturnValue(new ObjectID(PROJECT_ID));
+  jest.spyOn(ProjectUtil, "getCurrentProject").mockReturnValue(project);
+  navigate = jest
+    .spyOn(Navigation, "navigate")
+    .mockImplementation(() => {}) as unknown as CallRecorder;
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("ModelAPI on an SSO authorization answer", () => {
+  test("getList sends the user to the project's SSO page, then rethrows", async () => {
+    respondWith(406, new SSOAuthorizationException().message);
+
+    const error: unknown = await thrownBy(
+      ModelAPI.getList<IncidentState>({
+        modelType: IncidentState,
+        query: {},
+        limit: 1,
+        skip: 0,
+        select: { _id: true },
+        sort: {},
+      }),
+    );
+
+    expect(navigatedTo()).toEqual([SSO_PATH]);
+    expect(error).toBeInstanceOf(HTTPErrorResponse);
+    expect(
+      SSOAuthorizationException.isException(API.getFriendlyMessage(error)),
+    ).toBe(true);
+  });
+
+  test("count does the same", async () => {
+    respondWith(406, new SSOAuthorizationException().message);
+
+    await thrownBy(
+      ModelAPI.count<IncidentState>({
+        modelType: IncidentState,
+        query: {},
+      }),
+    );
+
+    expect(navigatedTo()).toEqual([SSO_PATH]);
+  });
+
+  test("other failures do not redirect", async () => {
+    respondWith(500, "Server error");
+
+    await thrownBy(
+      ModelAPI.count<IncidentState>({
+        modelType: IncidentState,
+        query: {},
+      }),
+    );
+
+    expect(navigatedTo()).toEqual([]);
+  });
+});

package/Tests/UI/Utils/Navigation.test.ts

@@ -1,6 +1,7 @@
 import Route from "../../../Types/API/Route";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import Navigation from "../../../UI/Utils/Navigation";
+import { NavigateFunction } from "react-router-dom";
 import {
   afterEach,
   beforeEach,
@@ -350,3 +351,104 @@ describe("Navigation current route", () => {
     expect(Navigation.getCurrentRoute().toString()).toBe("/from-the-router");
   });
 });
+
+/*
+ * React Router matches paths case-insensitively (no route opts into
+ * caseSensitive), so `/dashboard/<id>/SSO` renders the SSO page. Page checks
+ * made through isOnThisPage / isStartWith (the dashboard hides its nav bar on
+ * the SSO page, create pages hide their side menu) must agree with the page
+ * the router rendered, or the SSO page shows up with the nav bar still on it.
+ * navigate() is the exception: its "already here" check stays exact, because
+ * parameter values that differ only by case are different pages, and
+ * dropping that navigation would strand the user.
+ */
+describe("Navigation page checks ignore case the way React Router does", () => {
+  const setPath: (pathname: string) => void = (pathname: string): void => {
+    Navigation.setLocation({
+      pathname: pathname,
+      search: "",
+      hash: "",
+      state: null,
+      key: "navigation-case",
+    });
+  };
+
+  afterEach(() => {
+    (Navigation as unknown as { location: unknown }).location = undefined;
+    (Navigation as unknown as { navigateHook: unknown }).navigateHook =
+      undefined;
+  });
+
+  test.each([
+    ["/dashboard/abc/SSO", "/dashboard/:projectId/sso"],
+    ["/dashboard/abc/Sso/", "/dashboard/:projectId/sso"],
+    ["/dashboard/abc/sso", "/dashboard/:projectId/SSO"],
+    [
+      "/Dashboard/abc/incidents/CREATE",
+      "/dashboard/:projectId/incidents/create",
+    ],
+  ])(
+    "isOnThisPage matches %s to %s",
+    (currentPath: string, routePath: string) => {
+      setPath(currentPath);
+
+      expect(Navigation.isOnThisPage(new Route(routePath))).toBe(true);
+    },
+  );
+
+  test.each([
+    ["/dashboard/abc/SSOX", "/dashboard/:projectId/sso"],
+    ["/dashboard/abc/SSO/extra", "/dashboard/:projectId/sso"],
+    ["/dashboard/abc/SSO", "/dashboard/:projectId/:id/sso"],
+  ])(
+    "isOnThisPage still tells %s apart from %s",
+    (currentPath: string, routePath: string) => {
+      setPath(currentPath);
+
+      expect(Navigation.isOnThisPage(new Route(routePath))).toBe(false);
+    },
+  );
+
+  test("a route that carries a query string still never matches the bare pathname", () => {
+    setPath("/dashboard/abc/network-sites/MAP");
+
+    expect(
+      Navigation.isOnThisPage(
+        new Route("/dashboard/abc/network-sites/map?site="),
+      ),
+    ).toBe(false);
+  });
+
+  test("isOnThisPage compares filled-in parameter values without case too", () => {
+    // Deliberate: the values checked this way are ids. See isSameSegment.
+    setPath("/dashboard/abc/containers/Web");
+
+    expect(
+      Navigation.isOnThisPage(new Route("/dashboard/abc/containers/web")),
+    ).toBe(true);
+  });
+
+  test("isStartWith ignores case", () => {
+    setPath("/dashboard/abc/Incidents/xyz");
+
+    expect(
+      Navigation.isStartWith(new Route("/dashboard/:projectId/incidents")),
+    ).toBe(true);
+    expect(
+      Navigation.isStartWith(new Route("/dashboard/:projectId/incidentsx")),
+    ).toBe(false);
+  });
+
+  test("navigate still treats a parameter value in another case as another page", () => {
+    const navigateHook: ReturnType<typeof jest.fn> = jest.fn();
+    Navigation.setNavigateHook(navigateHook as unknown as NavigateFunction);
+    setPath("/dashboard/abc/containers/Web");
+
+    Navigation.navigate(new Route("/dashboard/abc/containers/web"));
+    Navigation.navigate(new Route("/dashboard/abc/containers/Web"));
+
+    expect(navigateHook.mock.calls).toEqual([
+      ["/dashboard/abc/containers/web"],
+    ]);
+  });
+});

package/Tests/UI/Utils/Telemetry/TelemetryEntityNames.test.ts

@@ -51,6 +51,7 @@ import TelemetryEntityNameResolver, {
 import { UNKNOWN_SERVICE_NAME } from "../../../../UI/Utils/TelemetryService";
 import Alert from "../../../../Models/DatabaseModels/Alert";
 import BaseModel from "../../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import DatabaseServer from "../../../../Models/DatabaseModels/DatabaseServer";
 import Host from "../../../../Models/DatabaseModels/Host";
 import Incident from "../../../../Models/DatabaseModels/Incident";
 import IoTFleet from "../../../../Models/DatabaseModels/IoTFleet";
@@ -314,6 +315,27 @@ describe("TELEMETRY_ENTITY_TYPES registry", () => {
     });
   });
 
+  test("DatabaseServer telemetry resolves against the DatabaseServer table by name", () => {
+    /*
+     * Rows a collector database receiver sends without a service.name carry
+     * the DatabaseServer id as their primary entity. The name is the only
+     * human-readable field: databaseIdentifier is an internal
+     * "<engine>|<endpoint>" key, not something to show in a chip.
+     */
+    expect(TELEMETRY_ENTITY_TYPES[ServiceType.DatabaseServer]).toEqual({
+      label: "Database",
+      modelType: DatabaseServer,
+      nameFields: ["name"],
+    });
+    expect(TELEMETRY_ENTITY_RESOLUTION_ORDER).toContain(
+      ServiceType.DatabaseServer,
+    );
+    // Never ahead of Service - the common case must stay one request.
+    expect(
+      TELEMETRY_ENTITY_RESOLUTION_ORDER.indexOf(ServiceType.DatabaseServer),
+    ).toBeGreaterThan(0);
+  });
+
   test("IoTDevice telemetry resolves against the IoT fleet table", () => {
     expect(TELEMETRY_ENTITY_TYPES[ServiceType.IoTDevice].modelType).toBe(
       IoTFleet,
@@ -392,6 +414,7 @@ describe("getTelemetryEntityTypeLabel", () => {
     [ServiceType.IoTDevice, "IoT Fleet"],
     [ServiceType.ServerlessFunction, "Serverless Function"],
     [ServiceType.CloudResource, "Cloud Resource"],
+    [ServiceType.DatabaseServer, "Database"],
     [ServiceType.NetworkDevice, "Network Device"],
     [ServiceType.Monitor, "Monitor"],
     [ServiceType.Incident, "Incident"],