@oneuptime/common 11.7.1 → 11.7.3

package/Tests/Models/AnalyticsModels/KubernetesCostAllocation.test.ts

@@ -37,12 +37,15 @@ describe("Analytics KubernetesCostAllocation model", () => {
       "cpuCoreHours",
       "cpuCoreRequestAverage",
       "cpuCoreUsageAverage",
+      "cpuCoreLimitAverage",
       "cpuCost",
       "gpuHours",
       "gpuCost",
       "ramByteHours",
       "ramBytesRequestAverage",
       "ramBytesUsageAverage",
+      "ramBytesLimitAverage",
+      "ramBytesUsageMax",
       "ramCost",
       "pvByteHours",
       "pvCost",
@@ -95,6 +98,19 @@ describe("Analytics KubernetesCostAllocation model", () => {
     );
   });
 
+  test("carries the shipment identity the ingest dedup relies on", () => {
+    const shipmentId: AnalyticsTableColumn | null =
+      model.getTableColumn("shipmentId");
+    expect(shipmentId?.type).toBe(TableColumnType.Text);
+    // Rows written before the shipment contract read back as "no identity".
+    expect(shipmentId?.defaultValue).toBe("");
+
+    const shipmentChunk: AnalyticsTableColumn | null =
+      model.getTableColumn("shipmentChunk");
+    expect(shipmentChunk?.type).toBe(TableColumnType.Number);
+    expect(shipmentChunk?.defaultValue).toBe(0);
+  });
+
   test("stores labels as a map with an extracted key column", () => {
     const labels: AnalyticsTableColumn | null = model.getTableColumn("labels");
     expect(labels?.type).toBe(TableColumnType.MapStringString);

package/Tests/Models/DatabaseModels/ProbeColumnAccessControl.test.ts

@@ -0,0 +1,103 @@
+import Probe from "../../../Models/DatabaseModels/Probe";
+import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import Permission from "../../../Types/Permission";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Several Probe columns were gated on status-page permissions
+ * (Create/Read/EditProjectStatusPage) instead of the probe ones. The table
+ * itself is gated on Create/Read/Edit/DeleteProjectProbe, so a team granted
+ * only granular probe permissions could open the probe edit form and change
+ * "Enable monitoring automatically on new monitors" - and ModelForm would drop
+ * the field from both the form and the request, with no error. The toggle
+ * looked unset afterwards, and the probe never got attached to new monitors.
+ *
+ * Any Probe column gated on a status-page permission is a copy-paste bug, so
+ * this asserts the absence outright rather than listing today's offenders.
+ */
+
+const STATUS_PAGE_PERMISSIONS: Array<Permission> = [
+  Permission.CreateProjectStatusPage,
+  Permission.ReadProjectStatusPage,
+  Permission.EditProjectStatusPage,
+  Permission.DeleteProjectStatusPage,
+];
+
+describe("Probe column access control", () => {
+  const accessControl: Record<string, ColumnAccessControl> =
+    new Probe().getColumnAccessControlForAllColumns();
+
+  it("never gates a probe column on a status page permission", () => {
+    const offenders: Array<string> = [];
+
+    for (const columnName of Object.keys(accessControl)) {
+      const column: ColumnAccessControl | undefined = accessControl[columnName];
+
+      const allPermissions: Array<Permission> = [
+        ...(column?.create || []),
+        ...(column?.read || []),
+        ...(column?.update || []),
+      ];
+
+      for (const permission of allPermissions) {
+        if (STATUS_PAGE_PERMISSIONS.includes(permission)) {
+          offenders.push(`${columnName}: ${permission}`);
+        }
+      }
+    }
+
+    expect(offenders).toEqual([]);
+  });
+
+  it("lets a user with granular probe permissions edit the auto-enable toggle", () => {
+    const column: ColumnAccessControl | undefined =
+      accessControl["shouldAutoEnableProbeOnNewMonitors"];
+
+    expect(column).toBeDefined();
+    expect(column!.update).toContain(Permission.EditProjectProbe);
+    expect(column!.read).toContain(Permission.ReadProjectProbe);
+    expect(column!.create).toContain(Permission.CreateProjectProbe);
+  });
+
+  it("keeps every field on the probe edit form readable and writable by a project owner", () => {
+    /*
+     * Every field the "Probe Details" card edits. If any of these stops
+     * intersecting a project owner's permissions, editing a probe silently
+     * stops working for the person who created it - which is exactly how the
+     * original bug presented.
+     */
+    const editableColumns: Array<string> = [
+      "name",
+      "description",
+      "iconFile",
+      "shouldAutoEnableProbeOnNewMonitors",
+      "labels",
+    ];
+
+    // What a signed-in project owner actually carries.
+    const ownerPermissions: Array<Permission> = [
+      Permission.Public,
+      Permission.User,
+      Permission.CurrentUser,
+      Permission.ProjectOwner,
+    ];
+
+    for (const columnName of editableColumns) {
+      const column: ColumnAccessControl | undefined = accessControl[columnName];
+
+      expect(column).toBeDefined();
+
+      expect(
+        (column!.update || []).some((permission: Permission) => {
+          return ownerPermissions.includes(permission);
+        }),
+      ).toBe(true);
+
+      expect(
+        (column!.read || []).some((permission: Permission) => {
+          return ownerPermissions.includes(permission);
+        }),
+      ).toBe(true);
+    }
+  });
+});

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

@@ -0,0 +1,135 @@
+import BaseAPI from "../../../Server/API/BaseAPI";
+import DatabaseService from "../../../Server/Services/DatabaseService";
+import {
+  ExpressResponse,
+  OneUptimeRequest,
+} from "../../../Server/Utils/Express";
+import Response from "../../../Server/Utils/Response";
+import { mockRouter } from "./Helpers";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+import ObjectID from "../../../Types/ObjectID";
+import ModelPermission from "../../../Server/Types/Database/Permissions/Index";
+import Probe from "../../../Models/DatabaseModels/Probe";
+import { getJestSpyOn } from "../../Spy";
+
+jest.mock("../../../Server/Utils/Express", () => {
+  return {
+    getRouter: () => {
+      return mockRouter;
+    },
+  };
+});
+
+jest.mock("../../../Server/Utils/Response", () => {
+  return {
+    sendEmptySuccessResponse: jest.fn(),
+    sendEntityResponse: jest.fn(),
+    sendEntityArrayResponse: jest.fn(),
+    sendJsonObjectResponse: jest.fn(),
+  };
+});
+
+/*
+ * PUT /<model>/:id answered 200 with an empty body no matter what happened.
+ *
+ * DatabaseService narrows the update query AFTER the caller builds it - tenant
+ * scope, access-control labels, owned scope - so an update can match zero rows
+ * and write nothing. updateOneById threw that count away and BaseAPI reported
+ * success regardless, so the client showed a saved edit that was never
+ * persisted and "disappeared" on the next page load, with no error anywhere.
+ */
+
+const TEST_ID: string = "550e8400-e29b-41d4-a716-446655440009";
+
+describe("BaseAPI.updateItem when the update matches nothing", () => {
+  let service: DatabaseService<Probe>;
+  let api: BaseAPI<Probe, DatabaseService<Probe>>;
+  let request: OneUptimeRequest;
+  let response: ExpressResponse;
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+
+    service = new DatabaseService<Probe>(Probe);
+    api = new BaseAPI<Probe, DatabaseService<Probe>>(Probe, service);
+
+    request = {
+      params: { id: TEST_ID },
+      body: { data: { name: "renamed-probe" } },
+      headers: {},
+    } as unknown as OneUptimeRequest;
+
+    response = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis(),
+      send: jest.fn().mockReturnThis(),
+    } as unknown as ExpressResponse;
+  });
+
+  it("reports success when a row was actually updated", async () => {
+    getJestSpyOn(service, "updateOneById").mockResolvedValue(1);
+
+    await api.updateItem(request, response);
+
+    expect(Response.sendEmptySuccessResponse).toHaveBeenCalledWith(
+      request,
+      response,
+    );
+  });
+
+  it("refuses to report success when nothing was written", async () => {
+    getJestSpyOn(service, "updateOneById").mockResolvedValue(0);
+
+    await expect(api.updateItem(request, response)).rejects.toThrow(
+      NotAuthorizedException,
+    );
+
+    expect(Response.sendEmptySuccessResponse).not.toHaveBeenCalled();
+  });
+
+  it("names the resource in the error so the message is actionable", async () => {
+    getJestSpyOn(service, "updateOneById").mockResolvedValue(0);
+
+    await expect(api.updateItem(request, response)).rejects.toThrow(/probe/i);
+  });
+});
+
+describe("DatabaseService.updateOneById", () => {
+  it("hands back the number of rows the update matched", async () => {
+    const service: DatabaseService<Probe> = new DatabaseService<Probe>(Probe);
+
+    getJestSpyOn(
+      ModelPermission,
+      "checkUpdatePermissionByModel",
+    ).mockResolvedValue(undefined);
+    getJestSpyOn(service, "updateOneBy").mockResolvedValue(3);
+
+    const numberOfDocsAffected: number = await service.updateOneById({
+      id: new ObjectID(TEST_ID),
+      data: {} as any,
+      props: { isRoot: true },
+    });
+
+    expect(numberOfDocsAffected).toBe(3);
+  });
+
+  it("hands back zero when the permission-scoped query matched no rows", async () => {
+    const service: DatabaseService<Probe> = new DatabaseService<Probe>(Probe);
+
+    getJestSpyOn(
+      ModelPermission,
+      "checkUpdatePermissionByModel",
+    ).mockResolvedValue(undefined);
+    getJestSpyOn(service, "updateOneBy").mockResolvedValue(0);
+
+    const numberOfDocsAffected: number = await service.updateOneById({
+      id: new ObjectID(TEST_ID),
+      data: {} as any,
+      props: { isRoot: true },
+    });
+
+    expect(numberOfDocsAffected).toBe(0);
+  });
+});

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

@@ -0,0 +1,317 @@
+import { describe, expect, test, afterEach } from "@jest/globals";
+import CommonAPI from "../../../Server/API/CommonAPI";
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import Dictionary from "../../../Types/Dictionary";
+import ObjectID from "../../../Types/ObjectID";
+import Permission, {
+  UserPermission,
+  UserTenantAccessPermission,
+} from "../../../Types/Permission";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+import Exception from "../../../Types/Exception/Exception";
+
+/*
+ * Tests for CommonAPI.assertAuthenticatedProjectMember — the shared auth
+ * guard for custom endpoints that disclose project data (Teams / Slack
+ * channel browsing, etc.). getUserMiddleware lets unauthenticated requests
+ * through as "public" and takes the tenant id from a caller-supplied
+ * header, so this guard must reject anything that is not an authenticated
+ * member of the tenant project.
+ */
+
+function buildTenantPermission(
+  projectId: ObjectID,
+): UserTenantAccessPermission {
+  const memberPermission: UserPermission = {
+    _type: "UserPermission",
+    permission: Permission.ProjectMember,
+    labelIds: [],
+  };
+
+  const tenantPermission: UserTenantAccessPermission = {
+    _type: "UserTenantAccessPermission",
+    projectId: projectId,
+    permissions: [memberPermission],
+  };
+
+  return tenantPermission;
+}
+
+function buildProps(overrides?: {
+  tenantId?: ObjectID | undefined;
+  userId?: ObjectID | undefined;
+  userTenantAccessPermission?:
+    | Dictionary<UserTenantAccessPermission>
+    | undefined;
+}): DatabaseCommonInteractionProps {
+  const props: DatabaseCommonInteractionProps = {
+    tenantId: overrides?.tenantId,
+    userId: overrides?.userId,
+    userTenantAccessPermission: overrides?.userTenantAccessPermission,
+  };
+  return props;
+}
+
+/*
+ * The guard is synchronous, so failures are captured with try/catch (via
+ * this helper) or expect(() => ...).toThrow — never .rejects.
+ */
+function captureThrown(fn: () => void): unknown {
+  try {
+    fn();
+  } catch (err: unknown) {
+    return err;
+  }
+  return undefined;
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("CommonAPI.assertAuthenticatedProjectMember", () => {
+  describe("missing tenant id", () => {
+    test("throws BadDataException with 'Project ID is required' when tenantId is undefined", () => {
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: undefined,
+      });
+
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow(BadDataException);
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow("Project ID is required");
+    });
+
+    test("missing tenantId wins over everything else — even a fully authenticated user gets BadDataException", () => {
+      const projectId: ObjectID = ObjectID.generate();
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: undefined,
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {
+          [projectId.toString()]: buildTenantPermission(projectId),
+        },
+      });
+
+      const thrown: unknown = captureThrown(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      });
+
+      expect(thrown).toBeInstanceOf(BadDataException);
+      expect(thrown).not.toBeInstanceOf(NotAuthorizedException);
+      expect((thrown as BadDataException).message).toBe(
+        "Project ID is required",
+      );
+    });
+
+    test("completely empty props object throws BadDataException", () => {
+      const props: DatabaseCommonInteractionProps = {};
+
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("unauthenticated / unauthorized callers", () => {
+    test("tenantId present but no userId throws NotAuthorizedException", () => {
+      const projectId: ObjectID = ObjectID.generate();
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: projectId,
+        userId: undefined,
+        userTenantAccessPermission: {
+          [projectId.toString()]: buildTenantPermission(projectId),
+        },
+      });
+
+      const thrown: unknown = captureThrown(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      });
+
+      expect(thrown).toBeInstanceOf(NotAuthorizedException);
+      expect((thrown as NotAuthorizedException).message).toBe(
+        "You are not authorized to access this project's data.",
+      );
+    });
+
+    test("userId present but no userTenantAccessPermission map throws NotAuthorizedException", () => {
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: ObjectID.generate(),
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: undefined,
+      });
+
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow(NotAuthorizedException);
+    });
+
+    test("permission map keyed by a DIFFERENT project id throws NotAuthorizedException", () => {
+      const requestedProjectId: ObjectID = ObjectID.generate();
+      const otherProjectId: ObjectID = ObjectID.generate();
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: requestedProjectId,
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {
+          [otherProjectId.toString()]: buildTenantPermission(otherProjectId),
+        },
+      });
+
+      const thrown: unknown = captureThrown(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      });
+
+      expect(thrown).toBeInstanceOf(NotAuthorizedException);
+      expect((thrown as NotAuthorizedException).message).toBe(
+        "You are not authorized to access this project's data.",
+      );
+    });
+
+    test("empty-object permission map throws NotAuthorizedException", () => {
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: ObjectID.generate(),
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {},
+      });
+
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow(NotAuthorizedException);
+    });
+
+    test("the not-authorized error is a NotAuthorizedException, not a BadDataException", () => {
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: ObjectID.generate(),
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {},
+      });
+
+      const thrown: unknown = captureThrown(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      });
+
+      expect(thrown).toBeInstanceOf(NotAuthorizedException);
+      expect(thrown).not.toBeInstanceOf(BadDataException);
+      expect(thrown).toBeInstanceOf(Exception);
+      expect(thrown).toBeInstanceOf(Error);
+    });
+
+    test("no userId AND no permission map throws NotAuthorizedException (public caller)", () => {
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: ObjectID.generate(),
+        userId: undefined,
+        userTenantAccessPermission: undefined,
+      });
+
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow(NotAuthorizedException);
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow("You are not authorized to access this project's data.");
+    });
+  });
+
+  describe("authorized callers", () => {
+    test("happy path returns the exact same ObjectID instance that was passed as tenantId", () => {
+      const projectId: ObjectID = ObjectID.generate();
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: projectId,
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {
+          [projectId.toString()]: buildTenantPermission(projectId),
+        },
+      });
+
+      const returned: ObjectID =
+        CommonAPI.assertAuthenticatedProjectMember(props);
+
+      expect(returned).toBe(projectId);
+      expect(returned.toString()).toBe(projectId.toString());
+    });
+
+    test("happy path does not throw", () => {
+      const projectId: ObjectID = ObjectID.generate();
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: projectId,
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {
+          [projectId.toString()]: buildTenantPermission(projectId),
+        },
+      });
+
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).not.toThrow();
+    });
+
+    test("happy path with multiple projects in the permission map returns the requested tenant", () => {
+      const projectA: ObjectID = ObjectID.generate();
+      const projectB: ObjectID = ObjectID.generate();
+      const projectC: ObjectID = ObjectID.generate();
+      const permissionMap: Dictionary<UserTenantAccessPermission> = {
+        [projectA.toString()]: buildTenantPermission(projectA),
+        [projectB.toString()]: buildTenantPermission(projectB),
+        [projectC.toString()]: buildTenantPermission(projectC),
+      };
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: projectB,
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: permissionMap,
+      });
+
+      const returned: ObjectID =
+        CommonAPI.assertAuthenticatedProjectMember(props);
+
+      expect(returned).toBe(projectB);
+    });
+
+    test("a DIFFERENT ObjectID instance with the same string value is still authorized (lookup is by string)", () => {
+      const projectIdString: string = ObjectID.generate().toString();
+      const tenantInstance: ObjectID = new ObjectID(projectIdString);
+      const permissionKeyInstance: ObjectID = new ObjectID(projectIdString);
+      const props: DatabaseCommonInteractionProps = buildProps({
+        tenantId: tenantInstance,
+        userId: ObjectID.generate(),
+        userTenantAccessPermission: {
+          [permissionKeyInstance.toString()]: buildTenantPermission(
+            permissionKeyInstance,
+          ),
+        },
+      });
+
+      const returned: ObjectID =
+        CommonAPI.assertAuthenticatedProjectMember(props);
+
+      /*
+       * The instance returned is the tenantId from props, not the one the
+       * permission map was built from.
+       */
+      expect(returned).toBe(tenantInstance);
+      expect(returned).not.toBe(permissionKeyInstance);
+      expect(returned.toString()).toBe(projectIdString);
+    });
+
+    test("extra unrelated props (isRoot, isMasterAdmin) do not bypass the membership check", () => {
+      const projectId: ObjectID = ObjectID.generate();
+      const props: DatabaseCommonInteractionProps = {
+        tenantId: projectId,
+        userId: undefined,
+        userTenantAccessPermission: undefined,
+        isRoot: true,
+        isMasterAdmin: true,
+      };
+
+      /*
+       * Pin current behavior: the guard checks userId + the tenant access
+       * permission map ONLY — root / master-admin flags do not grant
+       * access to these endpoints.
+       */
+      expect(() => {
+        CommonAPI.assertAuthenticatedProjectMember(props);
+      }).toThrow(NotAuthorizedException);
+    });
+  });
+});