@oneuptime/common 14.0.2 → 14.0.5

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

@@ -78,6 +78,11 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
     pagePattern: "/dashboard/:projectId/alerts/:id/description",
     titles: ["Project", "Alerts", "Description"],
   },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/:id/incidents",
+    titles: ["Project", "Alerts", "View Alert", "Linked Incidents"],
+  },
   {
     getter: "getAlertsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/alerts/:id/internal-notes",
@@ -471,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",
@@ -807,6 +882,11 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
     pagePattern: "/dashboard/:projectId/incidents/:id",
     titles: ["Project", "Incidents", "View Incident"],
   },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/:id/alerts",
+    titles: ["Project", "Incidents", "View Incident", "Linked Alerts"],
+  },
   {
     getter: "getIncidentsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/incidents/:id/custom-fields",

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

@@ -70,6 +70,7 @@ const realRoutePatterns: Array<string> = [
   "/dashboard/:projectId/alerts/:id/custom-fields",
   "/dashboard/:projectId/alerts/:id/internal-notes",
   "/dashboard/:projectId/alerts/:id/runbooks",
+  "/dashboard/:projectId/alerts/:id/incidents",
   "/dashboard/:projectId/alerts/settings/state",
   "/dashboard/:projectId/alerts/settings/severity",
   "/dashboard/:projectId/alerts/settings/note-templates",
@@ -154,6 +155,7 @@ const realRoutePatterns: Array<string> = [
   "/dashboard/:projectId/incidents/:id/sla",
   "/dashboard/:projectId/incidents/:id/audit-logs",
   "/dashboard/:projectId/incidents/:id/runbooks",
+  "/dashboard/:projectId/incidents/:id/alerts",
   "/dashboard/:projectId/incidents/settings/state",
   "/dashboard/:projectId/incidents/settings/severity",
   "/dashboard/:projectId/incidents/settings/templates",
@@ -504,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/PermissionGate.test.ts

@@ -273,6 +273,28 @@ describe("PermissionGate", () => {
       expect(result.disabledReason).toContain("this Monitor Template");
     });
 
+    test("uses the caller's verb in the reason, but still checks the operation", () => {
+      permissionsForTest = [Permission.Viewer];
+
+      const denied: PermissionGateResult = PermissionGate.check(
+        new Monitor(),
+        ModelAction.Delete,
+        { verb: "Unlink" },
+      );
+
+      expect(denied.isAllowed).toBe(false);
+      expect(denied.disabledReason).toContain("permission to unlink this");
+      expect(denied.disabledReason).not.toContain("delete this");
+
+      permissionsForTest = [Permission.ProjectAdmin];
+
+      expect(
+        PermissionGate.check(new Monitor(), ModelAction.Delete, {
+          verb: "Unlink",
+        }).isAllowed,
+      ).toBe(true);
+    });
+
     /*
      * Both model hierarchies are unrelated classes that happen to expose the
      * same permission API, and the gate is structurally typed so one
@@ -465,6 +487,60 @@ describe("PermissionGate", () => {
         PermissionGate.getMissingPermissionMessage(monitor, ModelAction.Update),
       ).toContain("permission to update this Monitor");
     });
+
+    /*
+     * A table of links calls its delete "Unlink". The sentence follows the
+     * label, but the permissions it lists are still the delete ones.
+     */
+    test("uses the caller's verb when one is supplied", () => {
+      const monitor: Monitor = new Monitor();
+
+      const withVerb: string = PermissionGate.getMissingPermissionMessage(
+        monitor,
+        ModelAction.Delete,
+        { verb: "Unlink" },
+      );
+      const withoutVerb: string = PermissionGate.getMissingPermissionMessage(
+        monitor,
+        ModelAction.Delete,
+      );
+
+      expect(withVerb).toContain("permission to unlink this Monitor.");
+      expect(withVerb).not.toContain("delete this Monitor");
+      expect(withVerb).toBe(
+        withoutVerb.replace("to delete this", "to unlink this"),
+      );
+    });
+
+    test("ignores a blank verb", () => {
+      const monitor: Monitor = new Monitor();
+
+      expect(
+        PermissionGate.getMissingPermissionMessage(
+          monitor,
+          ModelAction.Delete,
+          { verb: "  " },
+        ),
+      ).toBe(
+        PermissionGate.getMissingPermissionMessage(monitor, ModelAction.Delete),
+      );
+    });
+
+    test("uses the verb in the bare sentence too", () => {
+      const model: PermissionCheckableModel = {
+        ...modelWithNoDeletePermissions,
+        getDeletePermissions: (): Array<Permission> => {
+          return ["NotARealPermission" as Permission];
+        },
+      };
+
+      expect(
+        PermissionGate.getMissingPermissionMessage(model, ModelAction.Delete, {
+          verb: "Unlink",
+          singularName: "Link",
+        }),
+      ).toBe("You do not have permission to unlink this Link.");
+    });
   });
 
   describe("gateCardButton", () => {

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"],