npm - @oneuptime/common - Versions diffs - 12.0.12 → 12.0.14 - Mend

@oneuptime/common 12.0.12 → 12.0.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (596) hide show

package/Tests/App/StatusPage/StatusPageIndexPageRobotsMeta.test.ts ADDED Viewed

@@ -0,0 +1,130 @@
+/**
+ * The <meta name="robots"> half of the status page indexing opt-out, rendered
+ * from the real template.
+ *
+ * This is the channel that matters most: it is in the server-rendered HTML
+ * before the JS bundle loads, so it is what a crawler that does not run
+ * JavaScript sees. The X-Robots-Tag header that backs it up is asserted in
+ * App/Tests/StatusPage/SearchEngineIndexingResponses.test.ts.
+ *
+ * The template is read off disk rather than reproduced here, because the
+ * failure this guards against is someone editing index.ejs - a copy of the
+ * markup would keep passing while the shipped page lost its tag. It lives
+ * under Common/Tests because that is where the ejs types are installed;
+ * Common/Tests/App is the established home for tests that reach into App.
+ */
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+import ejs from "ejs";
+import fs from "fs";
+import path from "path";
+const INDEX_TEMPLATE: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "App",
+  "FeatureSet",
+  "StatusPage",
+  "views",
+  "index.ejs",
+);
+const NOINDEX_META: RegExp =
+  /<meta\s+name="robots"\s+content="noindex,\s*nofollow">/;
+function renderIndexPage(variables: JSONObject): string {
+  return ejs.render(fs.readFileSync(INDEX_TEMPLATE, "utf8"), variables);
+}
+describe("the status page index template", () => {
+  it("tells crawlers not to index when the owner turned indexing off", () => {
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      description: "How Acme is doing.",
+      isSearchEngineIndexingEnabled: false,
+    });
+    expect(html).toMatch(NOINDEX_META);
+  });
+  it("keeps the noindex tag inside <head>, where crawlers read it", () => {
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      isSearchEngineIndexingEnabled: false,
+    });
+    const head: string = html.split("</head>")[0] || "";
+    expect(head).toMatch(NOINDEX_META);
+  });
+  it("says nothing about robots when indexing is on", () => {
+    /*
+     * Not "emits index, follow". A crawler already assumes that, and emitting
+     * it would override a noindex an operator set on a proxy in front of
+     * OneUptime - the last robots instruction a crawler reads is the one that
+     * counts.
+     */
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      description: "How Acme is doing.",
+      isSearchEngineIndexingEnabled: true,
+    });
+    expect(html).not.toContain('name="robots"');
+  });
+  it("says nothing about robots when the variable was never passed", () => {
+    /*
+     * The fallback render - a host that resolves to no status page - passes
+     * no flag at all, and must not throw on the missing variable either.
+     * That page is the generic placeholder and stays indexable, which is what
+     * shipped before this feature.
+     */
+    const html: string = renderIndexPage({ title: "Status Page" });
+    expect(html).not.toContain('name="robots"');
+    expect(html).toContain("<title>Status Page</title>");
+  });
+  it.each([
+    ["a truthy non-boolean", "no"],
+    ["null", null],
+    ["zero", 0],
+  ])(
+    "only an explicit false suppresses indexing, not %s",
+    (_label: string, value: unknown) => {
+      /*
+       * The template compares against false rather than testing falsiness, so
+       * a value arriving in an unexpected shape leaves the page indexable
+       * instead of silently de-indexing it.
+       */
+      const html: string = renderIndexPage({
+        title: "Acme Status",
+        isSearchEngineIndexingEnabled: value,
+      } as JSONObject);
+      expect(html).not.toContain('name="robots"');
+    },
+  );
+  it("still renders the rest of the head when indexing is off", () => {
+    /*
+     * The opt-out must not cost the page its title, description or favicon -
+     * a page kept out of search results is still a page people read.
+     */
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      description: "How Acme is doing.",
+      faviconUrl: "/status-page-api/favicon/acme",
+      isSearchEngineIndexingEnabled: false,
+    });
+    expect(html).toContain("<title>Acme Status</title>");
+    expect(html).toContain('content="How Acme is doing."');
+    expect(html).toContain('href="/status-page-api/favicon/acme"');
+  });
+});

package/Tests/Models/DatabaseModels/DatabaseBaseModelToJSONObjectCache.test.ts ADDED Viewed

@@ -0,0 +1,180 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
+import Label from "../../../Models/DatabaseModels/Label";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import Color from "../../../Types/Color";
+import { JSONArray, JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, it } from "@jest/globals";
+/*
+ * toJSONObject reads table-column metadata off a cached, frozen, per-class
+ * vanilla instance instead of constructing one per row. These tests pin the
+ * contract that makes the cache safe: output is identical to a fresh
+ * construction, no state bleeds between rows or tenants, the cache is keyed
+ * on the declared modelType (not the instance's runtime class), and fromJSON
+ * still hands out a fresh mutable instance every call.
+ */
+describe("DatabaseBaseModel.toJSONObject with cached vanilla model", () => {
+  it("serializes a populated model with nested Entity and EntityArray columns", () => {
+    const severity: IncidentSeverity = new IncidentSeverity();
+    severity._id = "severity-id";
+    severity.name = "Critical";
+    const monitorOne: Monitor = new Monitor();
+    monitorOne._id = "monitor-one-id";
+    monitorOne.name = "Monitor One";
+    const monitorTwo: Monitor = new Monitor();
+    monitorTwo._id = "monitor-two-id";
+    monitorTwo.name = "Monitor Two";
+    const incident: Incident = new Incident();
+    incident._id = "incident-id";
+    incident.title = "Database is down";
+    incident.projectId = new ObjectID("project-one");
+    incident.incidentSeverity = severity;
+    incident.monitors = [monitorOne, monitorTwo];
+    const json: JSONObject = BaseModel.toJSONObject(incident, Incident);
+    expect(json["_id"]).toBe("incident-id");
+    expect(json["title"]).toBe("Database is down");
+    expect(json["projectId"]).toBe(incident.projectId);
+    // Nested Entity column is recursively serialized to a plain object.
+    const severityJson: JSONObject = json["incidentSeverity"] as JSONObject;
+    expect(severityJson).not.toBeInstanceOf(BaseModel);
+    expect(severityJson["_id"]).toBe("severity-id");
+    expect(severityJson["name"]).toBe("Critical");
+    // Nested EntityArray column is serialized item by item, order preserved.
+    const monitorsJson: JSONArray = json["monitors"] as JSONArray;
+    expect(Array.isArray(monitorsJson)).toBe(true);
+    expect(
+      monitorsJson.map((monitor: JSONObject | unknown) => {
+        expect(monitor).not.toBeInstanceOf(BaseModel);
+        return (monitor as JSONObject)["name"];
+      }),
+    ).toEqual(["Monitor One", "Monitor Two"]);
+    // Unset columns are skipped entirely.
+    expect("description" in json).toBe(false);
+  });
+  it("keeps each row's JSON isolated across repeated calls for the same class", () => {
+    const tenantOneProjectId: ObjectID = ObjectID.generate();
+    const tenantTwoProjectId: ObjectID = ObjectID.generate();
+    const tenantOneLabel: Label = new Label();
+    tenantOneLabel._id = "label-tenant-one";
+    tenantOneLabel.name = "Tenant One Label";
+    tenantOneLabel.projectId = tenantOneProjectId;
+    const tenantTwoLabel: Label = new Label();
+    tenantTwoLabel._id = "label-tenant-two";
+    tenantTwoLabel.name = "Tenant Two Label";
+    tenantTwoLabel.projectId = tenantTwoProjectId;
+    const jsonOne: JSONObject = BaseModel.toJSONObject(tenantOneLabel, Label);
+    const jsonTwo: JSONObject = BaseModel.toJSONObject(tenantTwoLabel, Label);
+    // Second serialization must not disturb the first result.
+    expect(jsonOne["_id"]).toBe("label-tenant-one");
+    expect(jsonOne["name"]).toBe("Tenant One Label");
+    expect(jsonOne["projectId"]).toBe(tenantOneProjectId);
+    expect(jsonTwo["_id"]).toBe("label-tenant-two");
+    expect(jsonTwo["name"]).toBe("Tenant Two Label");
+    expect(jsonTwo["projectId"]).toBe(tenantTwoProjectId);
+  });
+  it("does not leak a key set on an earlier row into a later row without it", () => {
+    const labelWithColor: Label = new Label();
+    labelWithColor.name = "Colored";
+    labelWithColor.color = new Color("#112233");
+    const labelWithoutColor: Label = new Label();
+    labelWithoutColor.name = "Plain";
+    const jsonWithColor: JSONObject = BaseModel.toJSONObject(
+      labelWithColor,
+      Label,
+    );
+    const jsonWithoutColor: JSONObject = BaseModel.toJSONObject(
+      labelWithoutColor,
+      Label,
+    );
+    expect(jsonWithColor["color"]).toBe(labelWithColor.color);
+    expect("color" in jsonWithoutColor).toBe(false);
+  });
+  it("serializes by the declared modelType, not the instance's runtime class", () => {
+    const label: Label = new Label();
+    label._id = "declared-type-label";
+    label.name = "Declared Type";
+    label.color = new Color("#445566");
+    label.projectId = ObjectID.generate();
+    /*
+     * Warm the subclass cache first so a cache wrongly keyed on
+     * model.constructor would surface Label columns below.
+     */
+    BaseModel.toJSONObject(label, Label);
+    const baseJson: JSONObject = BaseModel.toJSONObject(label, BaseModel);
+    const baseColumns: Array<string> = new BaseModel().getTableColumns()
+      .columns;
+    for (const key of Object.keys(baseJson)) {
+      expect(baseColumns).toContain(key);
+    }
+    expect(baseJson["_id"]).toBe("declared-type-label");
+    expect("color" in baseJson).toBe(false);
+    expect("projectId" in baseJson).toBe(false);
+  });
+  it("toJSONObject on a fresh base model returns an empty object", () => {
+    const json: JSONObject = BaseModel.toJSONObject(new BaseModel(), BaseModel);
+    expect(json).toEqual({});
+  });
+  it("fromJSON returns a fresh mutable instance on every call", () => {
+    const json: JSONObject = {
+      name: "oneuptime",
+      description: "a label",
+    };
+    const first: Label = BaseModel.fromJSON(json, Label) as Label;
+    const second: Label = BaseModel.fromJSON(json, Label) as Label;
+    expect(first).toBeInstanceOf(Label);
+    expect(second).toBeInstanceOf(Label);
+    expect(first).not.toBe(second);
+    first.name = "mutated";
+    expect(second.name).toBe("oneuptime");
+    expect(second.description).toBe("a label");
+  });
+  it("toJSONObjectArray serializes every item correctly on the cache-hit path", () => {
+    const labels: Array<Label> = [1, 2, 3, 4].map((index: number) => {
+      const label: Label = new Label();
+      label._id = `label-${index}`;
+      label.name = `Label ${index}`;
+      return label;
+    });
+    const jsonArray: JSONArray = BaseModel.toJSONObjectArray(labels, Label);
+    expect(jsonArray).toHaveLength(4);
+    jsonArray.forEach((item: JSONObject | unknown, index: number) => {
+      expect((item as JSONObject)["_id"]).toBe(`label-${index + 1}`);
+      expect((item as JSONObject)["name"]).toBe(`Label ${index + 1}`);
+    });
+  });
+});

package/Tests/Models/StatusPageEnableSearchEngineIndexing.test.ts ADDED Viewed

@@ -0,0 +1,157 @@
+/**
+ * StatusPage.enableSearchEngineIndexing column contract.
+ *
+ * The promise is "status pages stay indexable unless the owner turns indexing
+ * off". Three separate mechanisms carry that promise, and they are easy to
+ * confuse:
+ * - NEW rows get true from the Postgres column default, declared by
+ *   @Column({ default: true }) and stored in TypeORM's metadata
+ * - EXISTING rows got true from the migration's NOT NULL DEFAULT true
+ * - @TableColumn({ defaultValue: true }) is documentation only - it feeds the
+ *   generated API schema and form metadata, and defaults nothing at runtime
+ *
+ * All three are pinned below, because a one-word edit to any of them silently
+ * flips the default for everyone - and this is a default nobody notices going
+ * wrong until their status page has dropped out of Google.
+ */
+import StatusPage from "../../Models/DatabaseModels/StatusPage";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import Permission from "../../Types/Permission";
+import { SEARCH_ENGINE_INDEXING_FLAG_NAME } from "../../Types/StatusPage/SearchEngineIndexing";
+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 = "enableSearchEngineIndexing";
+const MIGRATIONS_DIR: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+);
+const MIGRATION_PATH: string = path.join(
+  MIGRATIONS_DIR,
+  "1787500000000-AddEnableSearchEngineIndexingToStatusPage.ts",
+);
+function metadata(): TableColumnMetadata {
+  return new StatusPage().getTableColumnMetadata(COLUMN);
+}
+function typeOrmColumn(): ColumnMetadataArgs | undefined {
+  return getMetadataArgsStorage().columns.find((column: ColumnMetadataArgs) => {
+    return column.target === StatusPage && column.propertyName === COLUMN;
+  });
+}
+describe("StatusPage.enableSearchEngineIndexing", () => {
+  test("exists as a boolean column", () => {
+    expect(metadata()).toBeDefined();
+    expect(metadata().type).toBe(TableColumnType.Boolean);
+  });
+  test("is named exactly what the API and the template look for", () => {
+    expect(COLUMN).toBe(SEARCH_ENGINE_INDEXING_FLAG_NAME);
+  });
+  test("a newly created status page is indexable", () => {
+    /*
+     * This is the assertion that actually protects new status pages: the
+     * Postgres column default. Nothing else populates the column when a
+     * create omits it, and every create in the product omits it.
+     */
+    expect(typeOrmColumn()).toBeDefined();
+    expect(typeOrmColumn()?.options.default).toBe(true);
+  });
+  test("the column is NOT NULL, so no row can be ambiguous", () => {
+    expect(typeOrmColumn()?.options.nullable).toBe(false);
+  });
+  test("every pre-existing status page was backfilled as indexable", () => {
+    /*
+     * The migration is the only thing that decided the value for status pages
+     * that existed before this feature shipped. DEFAULT true in the same
+     * statement fills every existing row, so no page silently loses its search
+     * traffic on upgrade.
+     */
+    const migration: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+    expect(migration).toContain('ALTER TABLE "StatusPage"');
+    expect(migration).toContain(
+      `ADD "${COLUMN}" boolean NOT NULL DEFAULT true`,
+    );
+  });
+  test("the migration is registered, so it actually runs on boot", () => {
+    /*
+     * A migration file that is not in Index.ts is dead code: the column never
+     * appears in Postgres, and every read of it fails at runtime rather than
+     * at compile time.
+     */
+    const index: string = fs.readFileSync(
+      path.join(MIGRATIONS_DIR, "Index.ts"),
+      "utf8",
+    );
+    expect(index).toContain(
+      "AddEnableSearchEngineIndexingToStatusPage1787500000000",
+    );
+    /* Imported AND listed in the exported array - the import alone does nothing. */
+    expect(
+      index.match(/AddEnableSearchEngineIndexingToStatusPage1787500000000/g)
+        ?.length,
+    ).toBeGreaterThanOrEqual(2);
+  });
+  test("is documented as defaulting to enabled", () => {
+    /*
+     * Feeds the generated API schema and the dashboard form metadata.
+     * Documentation only - see the tests above for the defaults that actually
+     * apply.
+     */
+    expect(metadata().defaultValue).toBe(true);
+  });
+  test("is a default-value column, so create may omit it", () => {
+    expect(new StatusPage().isDefaultValueColumn(COLUMN)).toBe(true);
+  });
+  test("is not required, so existing create calls keep working", () => {
+    expect(metadata().required).toBeFalsy();
+  });
+  test("is readable by status page viewers", () => {
+    const accessControl: Array<Permission> | undefined =
+      new StatusPage().getColumnAccessControlFor(COLUMN)?.read;
+    expect(accessControl).toContain(Permission.ProjectMember);
+    expect(accessControl).toContain(Permission.StatusPageAdmin);
+    expect(accessControl).toContain(Permission.ReadProjectStatusPage);
+  });
+  test("is editable by status page editors", () => {
+    const accessControl: Array<Permission> | undefined =
+      new StatusPage().getColumnAccessControlFor(COLUMN)?.update;
+    expect(accessControl).toContain(Permission.EditProjectStatusPage);
+    expect(accessControl).toContain(Permission.StatusPageAdmin);
+  });
+  test("is not editable by a read-only viewer", () => {
+    const accessControl: Array<Permission> | undefined =
+      new StatusPage().getColumnAccessControlFor(COLUMN)?.update;
+    expect(accessControl).not.toContain(Permission.Viewer);
+    expect(accessControl).not.toContain(Permission.StatusPageViewer);
+  });
+});

package/Tests/Models/UserPushCriticalAlertColumn.test.ts ADDED Viewed

@@ -0,0 +1,172 @@
+/**
+ * UserPush.isCriticalAlertEnabled column contract.
+ *
+ * This is the one stored preference in the product whose purpose is to DEFEAT
+ * a choice the user made with a physical switch on their phone. Everything
+ * below pins a property that, quietly changed, either wakes people who did not
+ * ask to be woken or - far worse for an on-call product - stops waking people
+ * who did.
+ *
+ * The three "default" mechanisms are separate and easy to confuse:
+ * - NEW rows get false from the Postgres column default (@Column default)
+ * - EXISTING rows got false from the migration's NOT NULL DEFAULT false
+ * - @TableColumn defaultValue is documentation for the generated API schema
+ *   and forms; it defaults nothing at runtime
+ */
+import UserPush from "../../Models/DatabaseModels/UserPush";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import Permission from "../../Types/Permission";
+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 = "isCriticalAlertEnabled";
+const MIGRATIONS_DIR: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+);
+const MIGRATION_CLASS: string = "MigrationName1787156982416";
+const MIGRATION_PATH: string = path.join(
+  MIGRATIONS_DIR,
+  "1787156982416-MigrationName.ts",
+);
+function metadata(): TableColumnMetadata {
+  return new UserPush().getTableColumnMetadata(COLUMN);
+}
+function typeOrmColumn(): ColumnMetadataArgs | undefined {
+  return getMetadataArgsStorage().columns.find((column: ColumnMetadataArgs) => {
+    return column.target === UserPush && column.propertyName === COLUMN;
+  });
+}
+describe("UserPush.isCriticalAlertEnabled", () => {
+  test("exists as a boolean column", () => {
+    expect(metadata()).toBeDefined();
+    expect(metadata().type).toBe(TableColumnType.Boolean);
+  });
+  test("a newly registered device does NOT override silent mode", () => {
+    /*
+     * The single most important assertion in this file. Overriding a silenced
+     * phone is opted into, never inherited: a responder who installs the app
+     * has not asked to be woken by it, and a default of true would make every
+     * existing user's phone start ringing through Do Not Disturb on upgrade.
+     */
+    expect(typeOrmColumn()).toBeDefined();
+    expect(typeOrmColumn()?.options.default).toBe(false);
+  });
+  test("every device that existed before this feature was backfilled as off", () => {
+    const migration: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+    expect(migration).toContain('ALTER TABLE "UserPush"');
+    expect(migration).toContain(
+      `ADD "${COLUMN}" boolean NOT NULL DEFAULT false`,
+    );
+  });
+  test("the migration is registered, so the column actually exists at runtime", () => {
+    /*
+     * A migration file missing from Index.ts never runs. The column would then
+     * be absent from Postgres while every select in the paging path asks for
+     * it, which fails the query that sends the page.
+     */
+    const index: string = fs.readFileSync(
+      path.join(MIGRATIONS_DIR, "Index.ts"),
+      "utf8",
+    );
+    // Imported AND listed in the exported array - the import alone does nothing.
+    expect(index.match(new RegExp(MIGRATION_CLASS, "g"))?.length).toBe(2);
+  });
+  test("the migration's down() removes the column", () => {
+    const migration: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+    expect(migration).toContain(
+      `ALTER TABLE "UserPush" DROP COLUMN "${COLUMN}"`,
+    );
+  });
+  test("is a default-value column, so existing create calls keep working", () => {
+    expect(new UserPush().isDefaultValueColumn(COLUMN)).toBe(true);
+    expect(metadata().required).toBeFalsy();
+  });
+  test("is documented as defaulting to off", () => {
+    expect(metadata().defaultValue).toBe(false);
+  });
+});
+describe("UserPush.isCriticalAlertEnabled access control", () => {
+  /*
+   * UserPush is an owner-only table: its table-level `read` names
+   * Permission.CurrentUser and nothing else, which is what scopes every read
+   * to the caller's own rows. A new column has to keep that shape or it
+   * becomes the exception that widens the table.
+   */
+  test("is readable only by the responder it belongs to", () => {
+    const read: Array<Permission> | undefined =
+      new UserPush().getColumnAccessControlFor(COLUMN)?.read;
+    expect(read).toEqual([Permission.CurrentUser]);
+  });
+  test("is settable at registration by the responder", () => {
+    const create: Array<Permission> | undefined =
+      new UserPush().getColumnAccessControlFor(COLUMN)?.create;
+    expect(create).toEqual([Permission.CurrentUser]);
+  });
+  test("cannot be written through the generic CRUD update surface", () => {
+    /*
+     * Every column on this model has an empty update list; writes go through
+     * the dedicated routes that check row ownership first and then act as
+     * root. Granting update here would let the flag be flipped by any path
+     * that can PUT the model, which is a wider surface than "the phone that
+     * owns this row".
+     */
+    const update: Array<Permission> | undefined =
+      new UserPush().getColumnAccessControlFor(COLUMN)?.update;
+    expect(update).toEqual([]);
+  });
+  test("does not widen the table's owner-only read scope", () => {
+    /*
+     * isAccessGrantedOnlyByCurrentUser is true exactly while the TABLE read
+     * list holds nothing but CurrentUser, and that is what stamps
+     * `userId = me` onto every read of this table. Adding a column must not
+     * disturb it.
+     */
+    expect(new UserPush().getReadPermissions()).toEqual([
+      Permission.CurrentUser,
+    ]);
+  });
+  test("is not marked readable through relation queries", () => {
+    /*
+     * canReadOnRelationQuery makes a column readable from a nested select on a
+     * model whose own read is admin-wide, skipping this table's column check
+     * entirely. isVerified - the column this one sits beside and is read
+     * alongside - does not set it, and neither does this: the paging path
+     * reads both as root, so nothing needs the flag.
+     */
+    expect(metadata().canReadOnRelationQuery).toBeFalsy();
+  });
+});

package/Tests/Server/API/AIChatCancelAndFeedback.test.ts CHANGED Viewed

@@ -26,6 +26,7 @@ import AIRunStatus from "../../../Types/AI/AIRunStatus";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
+import Permission from "../../../Types/Permission";
 import {
   afterEach,
   beforeEach,
@@ -61,10 +62,31 @@ const MESSAGE_ID: ObjectID = new ObjectID(
   "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee",
 );
+/*
+ * A real member of PROJECT_ID. The tenant access permission entry is not
+ * decoration: every AI chat route asserts membership of the project named in
+ * the `tenantid` header (CommonAPI.assertAuthenticatedProjectMember), so props
+ * carrying only a user id and a tenant id are exactly what an outsider sends
+ * and are refused before the handler does anything. AIChatRouteAuthorization
+ * covers that refusal; these tests are about what a legitimate member gets.
+ */
 const props: DatabaseCommonInteractionProps = {
   userId: USER_ID,
   tenantId: PROJECT_ID,
-} as DatabaseCommonInteractionProps;
+  userTenantAccessPermission: {
+    [PROJECT_ID.toString()]: {
+      _type: "UserTenantAccessPermission",
+      projectId: PROJECT_ID,
+      permissions: [
+        {
+          _type: "UserPermission",
+          permission: Permission.ProjectMember,
+          labelIds: [],
+        },
+      ],
+    },
+  },
+} as unknown as DatabaseCommonInteractionProps;
 function requestFor(body: JSONObject): ExpressRequest {
   return {