@oneuptime/common 11.7.3 → 12.0.0

package/Tests/Models/RecommendationDismissalModel.test.ts

@@ -0,0 +1,269 @@
+/**
+ * RecommendationDismissal model wiring.
+ *
+ * Everything that makes this model work is decorator metadata, and decorator
+ * metadata has no runtime that would ever exercise it in a unit test. It is
+ * read by the generic CRUD API, by BaseModelTable and by the team-permissions
+ * screen — all of which fail *quietly* when a decorator is wrong:
+ *
+ * - a wrong @TenantColumn does not throw, it drops the automatic projectId
+ *   filter, so one project's dismissals start hiding another project's cards
+ * - a changed @CrudApiEndpoint does not throw, it 404s the dismiss button in
+ *   the browser while every server test still passes
+ * - a @TableColumn added to resourceId with a modelType would turn a
+ *   deliberately polymorphic pointer into a relation, and TypeORM would then
+ *   try to join against a table that does not exist for seven of the eight
+ *   resource kinds
+ * - a Permission enum member with no entry in the permission-description
+ *   table throws BadDataException from PermissionHelper.getDescription, which
+ *   is only ever called when someone opens Project Settings > Teams
+ *
+ * None of these are caught by tsc, and none are caught by any test that
+ * exercises the service. So they are pinned here.
+ */
+
+import Project from "../../Models/DatabaseModels/Project";
+import RecommendationDismissal from "../../Models/DatabaseModels/RecommendationDismissal";
+import Columns from "../../Types/Database/Columns";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import Permission, {
+  PermissionHelper,
+  PermissionProps,
+} from "../../Types/Permission";
+import RecommendationType from "../../Types/Recommendation/RecommendationType";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import { RelationMetadataArgs } from "typeorm/metadata-args/RelationMetadataArgs";
+
+const RECOMMENDATION_DISMISSAL_PERMISSIONS: Array<Permission> = [
+  Permission.CreateRecommendationDismissal,
+  Permission.ReadRecommendationDismissal,
+  Permission.EditRecommendationDismissal,
+  Permission.DeleteRecommendationDismissal,
+];
+
+function model(): RecommendationDismissal {
+  return new RecommendationDismissal();
+}
+
+function relationArgs(propertyName: string): RelationMetadataArgs | undefined {
+  return getMetadataArgsStorage().relations.find(
+    (relation: RelationMetadataArgs) => {
+      return (
+        relation.target === RecommendationDismissal &&
+        relation.propertyName === propertyName
+      );
+    },
+  );
+}
+
+function permissionProps(permission: Permission): PermissionProps | undefined {
+  return PermissionHelper.getAllPermissionProps().find(
+    (props: PermissionProps) => {
+      return props.permission === permission;
+    },
+  );
+}
+
+describe("RecommendationDismissal table wiring", () => {
+  test("is tenant-scoped by projectId", () => {
+    /*
+     * DatabaseService reads this string to inject the tenant filter on every
+     * read, update and delete. If it is null or names a column that does not
+     * exist, queries stop being scoped and a dismissal made in one project
+     * starts hiding recommendations in another.
+     */
+    expect(model().getTenantColumn()).toBe("projectId");
+  });
+
+  test("is served at /recommendation-dismissal", () => {
+    /*
+     * The dashboard calls this path through ModelAPI. It is a string on both
+     * sides with no shared constant, so a rename here breaks Dismiss in the
+     * browser and nothing else.
+     */
+    expect(model().getCrudApiPath()?.toString()).toBe(
+      "/recommendation-dismissal",
+    );
+  });
+
+  test("maps to the RecommendationDismissal table", () => {
+    expect(model().tableName).toBe("RecommendationDismissal");
+  });
+
+  test("declares every column the dismissal flow writes and reads", () => {
+    const columns: Columns = model().getTableColumns();
+
+    for (const columnName of [
+      "recommendationType",
+      "recommendationId",
+      "resourceType",
+      "resourceId",
+      "dismissalReason",
+      "projectId",
+    ]) {
+      expect(columns.hasColumn(columnName)).toBe(true);
+    }
+  });
+
+  test("requires the two columns that identify what was dismissed", () => {
+    /*
+     * required: true is what makes DatabaseService reject a create that omits
+     * them. It is the layer underneath RecommendationDismissalService's own
+     * validation; both exist because a row missing either field hides nothing
+     * yet still consumes the unique slot for its (project, type, resource).
+     */
+    const columns: RecommendationDismissal = model();
+
+    expect(columns.getTableColumnMetadata("recommendationType").required).toBe(
+      true,
+    );
+    expect(columns.getTableColumnMetadata("recommendationId").required).toBe(
+      true,
+    );
+  });
+
+  test("keeps resourceType and resourceId optional for unscoped recommendations", () => {
+    /*
+     * A future project-wide recommendation kind has no resource to point at.
+     * Marking either column required would make that kind undismissable.
+     */
+    const columns: RecommendationDismissal = model();
+
+    expect(columns.getTableColumnMetadata("resourceType").required).toBeFalsy();
+    expect(columns.getTableColumnMetadata("resourceId").required).toBeFalsy();
+  });
+
+  test("documents recommendationType with a value that is actually in the enum", () => {
+    /*
+     * The example feeds the generated API documentation, and it is the only
+     * place an integrator learns what this free-text column accepts. Since the
+     * service rejects anything outside the enum — case-sensitively — an
+     * example that has drifted from the enum documents a request that always
+     * 400s.
+     */
+    const example: unknown =
+      model().getTableColumnMetadata("recommendationType").example;
+
+    expect(Object.values(RecommendationType)).toContain(example);
+  });
+});
+
+describe("RecommendationDismissal.resourceId is a polymorphic pointer", () => {
+  test("carries no relation metadata, unlike the project relation", () => {
+    /*
+     * resourceId points at a KubernetesCluster, a Host, a DockerHost or five
+     * other tables depending on resourceType, so there is no single table a
+     * foreign key could name. The contrast with `project` below is the point:
+     * a relation column declares modelType and manyToOneRelationColumn, and
+     * anything reading this metadata (the API docs generator, the populate
+     * logic, BaseModelTable) branches on their presence. Give resourceId a
+     * modelType and those readers will start trying to join it.
+     */
+    const resourceId: TableColumnMetadata =
+      model().getTableColumnMetadata("resourceId");
+
+    expect(resourceId.type).toBe(TableColumnType.ObjectID);
+    expect(resourceId.modelType).toBeUndefined();
+    expect(resourceId.manyToOneRelationColumn).toBeUndefined();
+
+    const project: TableColumnMetadata =
+      model().getTableColumnMetadata("project");
+
+    expect(project.type).toBe(TableColumnType.Entity);
+    expect(project.modelType).toBe(Project);
+    expect(project.manyToOneRelationColumn).toBe("projectId");
+  });
+
+  test("has no sibling entity property and no TypeORM relation", () => {
+    /*
+     * The relation-column convention in this schema is a pair: an ObjectID
+     * column plus an entity property carrying the @ManyToOne (projectId +
+     * project). resourceId deliberately has no partner, and there must be no
+     * @ManyToOne registered against it either — TypeORM would resolve the FK
+     * at connection time and fail to start, or worse, join every dismissal to
+     * one arbitrary table.
+     */
+    expect(model().getTableColumns().hasColumn("resource")).toBe(false);
+    expect(relationArgs("resourceId")).toBeUndefined();
+    expect(relationArgs("resource")).toBeUndefined();
+
+    // The project relation is registered, so the assertions above mean something.
+    expect(relationArgs("project")).toBeDefined();
+  });
+});
+
+describe("RecommendationDismissal permissions", () => {
+  test("every granular permission has a description entry", () => {
+    /*
+     * PermissionHelper.getDescription throws BadDataException for a permission
+     * that is missing from getAllPermissionProps. Project Settings > Teams
+     * calls it for every permission it renders, so one missing entry does not
+     * hide a checkbox — it breaks the whole permissions screen, and only for
+     * whoever opens it after the model ships.
+     */
+    for (const permission of RECOMMENDATION_DISMISSAL_PERMISSIONS) {
+      const props: PermissionProps | undefined = permissionProps(permission);
+
+      expect(props).toBeDefined();
+      expect(props?.title.length).toBeGreaterThan(0);
+      expect(props?.description.length).toBeGreaterThan(0);
+
+      expect(() => {
+        return PermissionHelper.getDescription(permission);
+      }).not.toThrow();
+      expect(() => {
+        return PermissionHelper.getTitle(permission);
+      }).not.toThrow();
+    }
+  });
+
+  test("granular permissions are assignable to a team", () => {
+    /*
+     * A permission that is not assignable to a tenant never appears in the
+     * team permission picker, which makes it unreachable for anyone who is not
+     * already a project owner or admin.
+     */
+    for (const permission of RECOMMENDATION_DISMISSAL_PERMISSIONS) {
+      expect(permissionProps(permission)?.isAssignableToTenant).toBe(true);
+    }
+  });
+
+  test("each granular permission is wired into the matching table access control", () => {
+    /*
+     * Declaring the permissions without attaching them to the table would
+     * leave four checkboxes in the UI that grant nothing at all.
+     */
+    const dismissal: RecommendationDismissal = model();
+
+    expect(dismissal.createRecordPermissions).toContain(
+      Permission.CreateRecommendationDismissal,
+    );
+    expect(dismissal.readRecordPermissions).toContain(
+      Permission.ReadRecommendationDismissal,
+    );
+    expect(dismissal.updateRecordPermissions).toContain(
+      Permission.EditRecommendationDismissal,
+    );
+    expect(dismissal.deleteRecordPermissions).toContain(
+      Permission.DeleteRecommendationDismissal,
+    );
+  });
+
+  test("allows delete, because un-dismissing is a delete and not a flag", () => {
+    /*
+     * There is no isDismissed column to flip back. Restoring a recommendation
+     * removes the row, so without delete permission for ordinary project
+     * members a dismissal made by mistake is permanent for everyone.
+     */
+    const dismissal: RecommendationDismissal = model();
+
+    expect(dismissal.deleteRecordPermissions).toContain(
+      Permission.ProjectMember,
+    );
+    expect(dismissal.createRecordPermissions).toContain(
+      Permission.ProjectMember,
+    );
+  });
+});

package/Tests/Models/RunnerVersionLabel.test.ts

@@ -0,0 +1,223 @@
+/*
+ * ---------------------------------------------------------------------------
+ * Runner.agentVersion — the label says "Runner Version", the wire says
+ * "agentVersion", and those two facts must move independently forever.
+ *
+ * The dashboard used to render this field as "Agent Version", which is wrong:
+ * the entity is a Runner, and "agent" is the name of a completely different
+ * family of things in this product (the Host / Docker / Kubernetes / RUM
+ * monitoring agents, which DO have an agent version). Only the display strings
+ * were changed.
+ *
+ * The property name — and therefore the Postgres column, the /api/runner JSON
+ * field, and the POST /heartbeat body key — deliberately stays `agentVersion`:
+ *
+ *   - Runners are customer-pulled containers (`oneuptime/runner:release`) on
+ *     their own upgrade cadence. Weeks of skew against the server is normal.
+ *   - Renaming the key fails SILENTLY. RunnerIngress only writes the column
+ *     when the body carries a non-empty string, so a Runner posting the old key
+ *     to a renamed server still gets HTTP 200, still shows as Connected, and
+ *     just freezes its reported version forever. No exception, no log, no CI
+ *     signal.
+ *   - RunnerService.heartbeat writes through `update["agentVersion"]` on an
+ *     object cast to `never`, so TypeScript would not catch a missed call site.
+ *
+ * So this file pins BOTH halves. The title/description assertions fail if
+ * someone reverts the wording; the property/column assertions fail if someone
+ * "finishes the job" by renaming the field, which is the change that would take
+ * production down quietly. The final describe pins that the eleven unrelated
+ * monitoring-agent models were NOT swept up in the rename.
+ * ---------------------------------------------------------------------------
+ */
+
+import CephCluster from "../../Models/DatabaseModels/CephCluster";
+import CloudResource from "../../Models/DatabaseModels/CloudResource";
+import DockerHost from "../../Models/DatabaseModels/DockerHost";
+import DockerSwarmCluster from "../../Models/DatabaseModels/DockerSwarmCluster";
+import Host from "../../Models/DatabaseModels/Host";
+import IoTFleet from "../../Models/DatabaseModels/IoTFleet";
+import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
+import ProxmoxCluster from "../../Models/DatabaseModels/ProxmoxCluster";
+import Runner from "../../Models/DatabaseModels/Runner";
+import RumApplication from "../../Models/DatabaseModels/RumApplication";
+import ServerlessFunction from "../../Models/DatabaseModels/ServerlessFunction";
+import DatabaseBaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import fs from "fs";
+import path from "path";
+
+const COLUMN: string = "agentVersion";
+
+const RUNNER_MODEL_PATH: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "Models",
+  "DatabaseModels",
+  "Runner.ts",
+);
+
+/*
+ * getTableColumns iterates Object.keys(target), which only sees properties
+ * initialized with `= undefined`. It must be given an INSTANCE — passing the
+ * class returns an empty dictionary and every assertion below would pass
+ * vacuously.
+ */
+function metadata(): TableColumnMetadata {
+  return new Runner().getTableColumnMetadata(COLUMN);
+}
+
+function typeOrmColumn(
+  model: new () => DatabaseBaseModel,
+): ColumnMetadataArgs | undefined {
+  return getMetadataArgsStorage().columns.find((column: ColumnMetadataArgs) => {
+    return column.target === model && column.propertyName === COLUMN;
+  });
+}
+
+describe("Runner.agentVersion display label", () => {
+  test("is titled 'Runner Version'", () => {
+    expect(metadata()).toBeDefined();
+    expect(metadata().title).toBe("Runner Version");
+  });
+
+  test("no longer says 'Agent Version' anywhere in its metadata", () => {
+    expect(metadata().title).not.toBe("Agent Version");
+    expect(String(metadata().description)).not.toContain("Agent Version");
+  });
+
+  /*
+   * The description, not the title, is what actually gets published:
+   * ModelSchema prefers description over title when building the Zod
+   * `.describe()` text, and that text is what lands in the generated OpenAPI
+   * spec, the Terraform provider docs and the MCP tool schemas. The API
+   * Reference page renders the description and never renders the title at all.
+   * A title-only fix would have left "agent binary" in every published artifact.
+   */
+  test("describes a Runner binary, not an agent binary", () => {
+    const description: string = String(metadata().description);
+
+    expect(description).toBe(
+      "Self-reported version of the Runner binary. Updated on each heartbeat.",
+    );
+    expect(description).not.toContain("agent binary");
+    expect(description.toLowerCase()).not.toContain("agent");
+  });
+
+  test("still says it is refreshed by the heartbeat", () => {
+    expect(String(metadata().description)).toContain("each heartbeat");
+  });
+});
+
+describe("Runner.agentVersion column contract (must NOT be renamed)", () => {
+  /*
+   * The load-bearing assertion of this whole file. If someone renames the
+   * property to runnerVersion, every deployed Runner keeps POSTing
+   * `agentVersion`, the server quietly ignores it, and the dashboard shows a
+   * connected Runner whose version never advances again.
+   */
+  test("the property is still called agentVersion", () => {
+    expect(new Runner().getTableColumns().columns).toContain(COLUMN);
+    expect(Object.keys(new Runner())).toContain(COLUMN);
+  });
+
+  test("no runnerVersion property was introduced alongside it", () => {
+    expect(new Runner().getTableColumns().columns).not.toContain(
+      "runnerVersion",
+    );
+  });
+
+  test("the Postgres column is still agentVersion and still nullable", () => {
+    const column: ColumnMetadataArgs | undefined = typeOrmColumn(Runner);
+
+    expect(column).toBeDefined();
+    expect(column!.propertyName).toBe(COLUMN);
+    // No `name` override, so TypeORM derives the DB column from the property.
+    expect(column!.options.name).toBeUndefined();
+    expect(column!.options.nullable).toBe(true);
+  });
+
+  test("is still typed as a Version column", () => {
+    expect(metadata().type).toBe(TableColumnType.Version);
+  });
+
+  /*
+   * required: false is what keeps a Runner creatable before it has ever
+   * heartbeated. Flipping it while renaming labels would reject every create.
+   */
+  test("stays optional on create", () => {
+    expect(metadata().required).toBe(false);
+  });
+
+  /*
+   * The rationale for keeping the wire name lives in a comment on the property.
+   * Without it the next reader sees a "Runner Version" label over an
+   * `agentVersion` field and reasonably assumes it was an oversight.
+   */
+  test("carries a comment explaining why the wire name stays agentVersion", () => {
+    const source: string = fs.readFileSync(RUNNER_MODEL_PATH, "utf8");
+    const squashed: string = source.replace(/\s+/g, " ");
+
+    expect(squashed).toContain("the property");
+    expect(squashed).toContain("stays");
+    expect(squashed).toContain("agentVersion");
+    expect(squashed).toContain("un-redeployed Runner");
+  });
+});
+
+/*
+ * The eleven models below are real monitoring agents / SDKs reporting the
+ * version of software OneUptime ships onto a customer host. "Agent Version" is
+ * correct for all of them. A find-and-replace across the repo would have
+ * renamed them too, so each one is pinned by name — a bulk rename fails here
+ * loudly instead of shipping "Runner Version" onto the Kubernetes cluster page.
+ */
+describe("unrelated monitoring-agent models keep saying 'Agent Version'", () => {
+  const AGENT_MODELS: Array<{
+    name: string;
+    model: new () => DatabaseBaseModel;
+  }> = [
+    { name: "Host", model: Host },
+    { name: "DockerHost", model: DockerHost },
+    { name: "PodmanHost", model: PodmanHost },
+    { name: "KubernetesCluster", model: KubernetesCluster },
+    { name: "DockerSwarmCluster", model: DockerSwarmCluster },
+    { name: "CephCluster", model: CephCluster },
+    { name: "ProxmoxCluster", model: ProxmoxCluster },
+    { name: "CloudResource", model: CloudResource },
+    { name: "IoTFleet", model: IoTFleet },
+    { name: "RumApplication", model: RumApplication },
+    { name: "ServerlessFunction", model: ServerlessFunction },
+  ];
+
+  test.each(AGENT_MODELS)(
+    "$name.agentVersion is still titled 'Agent Version'",
+    ({ model }: { model: new () => DatabaseBaseModel }) => {
+      const columnMetadata: TableColumnMetadata =
+        new model().getTableColumnMetadata(COLUMN);
+
+      expect(columnMetadata).toBeDefined();
+      expect(columnMetadata.title).toBe("Agent Version");
+    },
+  );
+
+  test("Runner is the only model of the set that says 'Runner Version'", () => {
+    const runnerVersionTitled: Array<string> = AGENT_MODELS.filter(
+      ({ model }: { model: new () => DatabaseBaseModel }) => {
+        return (
+          new model().getTableColumnMetadata(COLUMN).title === "Runner Version"
+        );
+      },
+    ).map(({ name }: { name: string }) => {
+      return name;
+    });
+
+    expect(runnerVersionTitled).toEqual([]);
+    expect(metadata().title).toBe("Runner Version");
+  });
+});