@oneuptime/common 13.0.6 → 13.0.7

package/Tests/Server/Infrastructure/Postgres/MonitorDescriptionMigration.test.ts

@@ -0,0 +1,422 @@
+import { RemoveMonitorDescriptionLengthLimit1793800000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1793800000000-RemoveMonitorDescriptionLengthLimit";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import ObjectID from "../../../../Types/ObjectID";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+import { DataSource, MigrationInterface, QueryRunner } from "typeorm";
+
+interface DescriptionColumn {
+  table: string;
+  column: string;
+}
+
+interface StoredDescription {
+  _id: number;
+  description: string | null;
+}
+
+const DESCRIPTION_COLUMNS: ReadonlyArray<DescriptionColumn> = [
+  { table: "Monitor", column: "description" },
+  { table: "MonitorTemplate", column: "monitorDescription" },
+];
+
+async function queriesFor(direction: "up" | "down"): Promise<Array<string>> {
+  const statements: Array<string> = [];
+  const runner: QueryRunner = {
+    query: async (statement: string): Promise<void> => {
+      statements.push(statement);
+    },
+  } as unknown as QueryRunner;
+
+  await new RemoveMonitorDescriptionLengthLimit1793800000000()[direction](
+    runner,
+  );
+  return statements;
+}
+
+describe("monitor description migration", () => {
+  test.each(["up", "down"] as const)(
+    "%s changes types in place without deleting or truncating descriptions",
+    async (direction: "up" | "down") => {
+      const statements: Array<string> = await queriesFor(direction);
+      const type: string =
+        direction === "up" ? "text" : "character varying(500)";
+
+      /*
+       * TypeORM generates DROP/ADD for this type change unless corrected.
+       * The exact ALTER contract also excludes a truncating rollback cast.
+       */
+      expect(statements).toHaveLength(DESCRIPTION_COLUMNS.length);
+      for (const { table, column } of DESCRIPTION_COLUMNS) {
+        expect(statements).toContain(
+          `ALTER TABLE "${table}" ALTER COLUMN "${column}" TYPE ${type}`,
+        );
+      }
+      expect(statements.join("\n")).not.toMatch(/DROP COLUMN|TRUNCATE|USING/i);
+    },
+  );
+
+  test("is registered exactly once so existing databases receive the change", () => {
+    expect(
+      SchemaMigrations.filter(
+        (migration: new () => MigrationInterface): boolean => {
+          return migration === RemoveMonitorDescriptionLengthLimit1793800000000;
+        },
+      ),
+    ).toHaveLength(1);
+  });
+});
+
+/*
+ * Opt in with RUN_POSTGRES_MONITOR_DESCRIPTION_MIGRATION_TESTS=true and the
+ * normal database credentials. Every test uses a transaction inside a unique
+ * schema, and the connection's search_path excludes public to protect app data.
+ */
+const describePostgres: typeof describe.skip =
+  process.env["RUN_POSTGRES_MONITOR_DESCRIPTION_MIGRATION_TESTS"] === "true"
+    ? describe
+    : describe.skip;
+
+function descriptionDatabase(schema: string): DataSource {
+  return new DataSource({
+    type: "postgres",
+    host:
+      process.env["MONITOR_DESCRIPTION_MIGRATION_TEST_DATABASE_HOST"] ||
+      "localhost",
+    port: Number(
+      process.env["MONITOR_DESCRIPTION_MIGRATION_TEST_DATABASE_PORT"] || "5400",
+    ),
+    username: process.env["DATABASE_USERNAME"] || "postgres",
+    password: process.env["DATABASE_PASSWORD"] || "password",
+    database: process.env["DATABASE_NAME"] || "oneuptimedb",
+    entities: [],
+    migrations: [RemoveMonitorDescriptionLengthLimit1793800000000],
+    schema,
+    synchronize: false,
+    extra: { options: `-c search_path=${schema}` },
+  });
+}
+
+describePostgres("monitor descriptions against Postgres", () => {
+  const schema: string = `monitor_description_${ObjectID.generate().toString().replace(/-/g, "")}`;
+  const migration: RemoveMonitorDescriptionLengthLimit1793800000000 =
+    new RemoveMonitorDescriptionLengthLimit1793800000000();
+  const existingDescriptions: ReadonlyArray<string | null> = [
+    null,
+    "",
+    "Monitor for pod CPU saturation",
+    "監視 café 🚀".repeat(20),
+    "x".repeat(500),
+  ];
+  let database: DataSource;
+  let runner: QueryRunner;
+
+  async function rows(
+    column: DescriptionColumn,
+  ): Promise<Array<StoredDescription>> {
+    return runner.query(
+      `SELECT "_id", "${column.column}" AS description FROM "${column.table}" ORDER BY "_id"`,
+    );
+  }
+
+  beforeAll(async () => {
+    database = descriptionDatabase(schema);
+    await database.initialize();
+    await database.query(`CREATE SCHEMA "${schema}"`);
+    runner = database.createQueryRunner();
+    await runner.connect();
+    const currentSchema: Array<{ current_schema: string }> = await runner.query(
+      "SELECT current_schema()",
+    );
+    expect(currentSchema[0]?.current_schema).toBe(schema);
+  });
+
+  beforeEach(async () => {
+    await runner.startTransaction();
+    for (const { table, column } of DESCRIPTION_COLUMNS) {
+      await runner.query(
+        `CREATE TABLE "${table}" ("_id" integer PRIMARY KEY, "${column}" character varying(500))`,
+      );
+      for (const [index, description] of existingDescriptions.entries()) {
+        await runner.query(
+          `INSERT INTO "${table}" ("_id", "${column}") VALUES ($1, $2)`,
+          [index, description],
+        );
+      }
+    }
+  });
+
+  afterEach(async () => {
+    if (runner?.isTransactionActive) {
+      await runner.rollbackTransaction();
+    }
+  });
+
+  afterAll(async () => {
+    if (runner) {
+      await runner.release();
+    }
+    if (database?.isInitialized) {
+      await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await database.destroy();
+    }
+  });
+
+  test("preserves existing null, empty, Unicode and 500-character values through migration and rollback", async () => {
+    const expected: Array<StoredDescription> = existingDescriptions.map(
+      (description: string | null, index: number): StoredDescription => {
+        return { _id: index, description };
+      },
+    );
+
+    await migration.up(runner);
+    for (const column of DESCRIPTION_COLUMNS) {
+      expect(await rows(column)).toEqual(expected);
+      const types: Array<{
+        data_type: string;
+        character_maximum_length: number | null;
+      }> = await runner.query(
+        "SELECT data_type, character_maximum_length FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND column_name = $3",
+        [schema, column.table, column.column],
+      );
+      expect(types).toEqual([
+        { data_type: "text", character_maximum_length: null },
+      ]);
+    }
+
+    await migration.down(runner);
+    for (const column of DESCRIPTION_COLUMNS) {
+      expect(await rows(column)).toEqual(expected);
+    }
+  });
+
+  test.each(DESCRIPTION_COLUMNS)(
+    "stores and updates long descriptions in $table",
+    async (column: DescriptionColumn) => {
+      await migration.up(runner);
+      const descriptions: ReadonlyArray<string> = [
+        "a".repeat(501),
+        "b".repeat(100_000),
+        "## 監視 🚀\nCPU > 90% — café\n".repeat(1_000),
+      ];
+
+      for (const [index, description] of descriptions.entries()) {
+        const id: number = 100 + index;
+        const inserted: Array<StoredDescription> = await runner.query(
+          `INSERT INTO "${column.table}" ("_id", "${column.column}") VALUES ($1, $2) RETURNING "_id", "${column.column}" AS description`,
+          [id, description],
+        );
+        expect(inserted).toEqual([{ _id: id, description }]);
+
+        const updatedDescription: string = `${description}\nUpdated description`;
+        await runner.query(
+          `UPDATE "${column.table}" SET "${column.column}" = $1 WHERE "_id" = $2`,
+          [updatedDescription, id],
+        );
+        expect(await rows(column)).toContainEqual({
+          _id: id,
+          description: updatedDescription,
+        });
+      }
+    },
+  );
+
+  test.each(DESCRIPTION_COLUMNS)(
+    "refuses rollback with an oversized $table description instead of discarding it",
+    async (column: DescriptionColumn) => {
+      await migration.up(runner);
+      const description: string = "x".repeat(501);
+      await runner.query(
+        `INSERT INTO "${column.table}" ("_id", "${column.column}") VALUES ($1, $2)`,
+        [100, description],
+      );
+
+      /*
+       * Match the transaction TypeORM uses for an actual rollback. The nested
+       * savepoint lets us verify the retained data after the expected failure.
+       */
+      await runner.startTransaction();
+      try {
+        await expect(migration.down(runner)).rejects.toThrow(
+          /value too long for type character varying\(500\)/,
+        );
+      } finally {
+        await runner.rollbackTransaction();
+      }
+      expect(await rows(column)).toContainEqual({ _id: 100, description });
+    },
+  );
+});
+
+describePostgres("monitor description startup migrations", () => {
+  let database: DataSource;
+  let schema: string;
+  const migrationName: string =
+    "RemoveMonitorDescriptionLengthLimit1793800000000";
+  const originalDescription: string = "x".repeat(500);
+
+  async function expectColumnTypes(
+    dataType: string,
+    maximumLength: number | null,
+  ): Promise<void> {
+    for (const column of DESCRIPTION_COLUMNS) {
+      const result: Array<{
+        data_type: string;
+        character_maximum_length: number | null;
+      }> = await database.query(
+        "SELECT data_type, character_maximum_length FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND column_name = $3",
+        [schema, column.table, column.column],
+      );
+      expect(result).toEqual([
+        { data_type: dataType, character_maximum_length: maximumLength },
+      ]);
+    }
+  }
+
+  async function expectStoredDescriptions(description: string): Promise<void> {
+    for (const column of DESCRIPTION_COLUMNS) {
+      expect(
+        await database.query(
+          `SELECT "${column.column}" AS description FROM "${column.table}" WHERE "_id" = 1`,
+        ),
+      ).toEqual([{ description }]);
+    }
+  }
+
+  beforeEach(async () => {
+    schema = `monitor_description_startup_${ObjectID.generate().toString().replace(/-/g, "")}`;
+    database = descriptionDatabase(schema);
+    await database.initialize();
+    await database.query(`CREATE SCHEMA "${schema}"`);
+    expect(await database.query("SELECT current_schema()")).toEqual([
+      { current_schema: schema },
+    ]);
+    for (const column of DESCRIPTION_COLUMNS) {
+      await database.query(
+        `CREATE TABLE "${column.table}" ("_id" integer PRIMARY KEY, "${column.column}" character varying(500))`,
+      );
+      await database.query(
+        `INSERT INTO "${column.table}" ("_id", "${column.column}") VALUES ($1, $2)`,
+        [1, originalDescription],
+      );
+    }
+  });
+
+  afterEach(async () => {
+    if (database?.isInitialized) {
+      await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await database.destroy();
+    }
+  });
+
+  test("runs once through TypeORM and preserves long values on the next startup", async () => {
+    expect(await database.runMigrations({ transaction: "all" })).toHaveLength(
+      1,
+    );
+    await expectColumnTypes("text", null);
+    await expectStoredDescriptions(originalDescription);
+
+    const description: string = "## Runbook 監視 🚀\nCPU > 90%\n".repeat(1_000);
+    for (const column of DESCRIPTION_COLUMNS) {
+      await database.query(
+        `UPDATE "${column.table}" SET "${column.column}" = $1 WHERE "_id" = 1`,
+        [description],
+      );
+    }
+
+    expect(await database.runMigrations({ transaction: "all" })).toEqual([]);
+    expect(await database.query('SELECT "name" FROM "migrations"')).toEqual([
+      { name: migrationName },
+    ]);
+    await expectStoredDescriptions(description);
+  });
+
+  test("can be rolled back and applied again without changing existing descriptions", async () => {
+    await database.runMigrations({ transaction: "all" });
+    await database.undoLastMigration({ transaction: "all" });
+
+    await expectColumnTypes("character varying", 500);
+    await expectStoredDescriptions(originalDescription);
+    expect(await database.query('SELECT "name" FROM "migrations"')).toEqual([]);
+
+    expect(await database.runMigrations({ transaction: "all" })).toHaveLength(
+      1,
+    );
+    await expectColumnTypes("text", null);
+    await expectStoredDescriptions(originalDescription);
+  });
+
+  test.each(DESCRIPTION_COLUMNS)(
+    "failed rollback keeps both columns and migration history intact for an oversized $table description",
+    async (column: DescriptionColumn) => {
+      await database.runMigrations({ transaction: "all" });
+      const description: string = "x".repeat(501);
+      await database.query(
+        `UPDATE "${column.table}" SET "${column.column}" = $1 WHERE "_id" = 1`,
+        [description],
+      );
+
+      await expect(
+        database.undoLastMigration({ transaction: "all" }),
+      ).rejects.toThrow(/value too long for type character varying\(500\)/);
+
+      await expectColumnTypes("text", null);
+      expect(await database.query('SELECT "name" FROM "migrations"')).toEqual([
+        { name: migrationName },
+      ]);
+      for (const storedColumn of DESCRIPTION_COLUMNS) {
+        expect(
+          await database.query(
+            `SELECT "${storedColumn.column}" AS description FROM "${storedColumn.table}" WHERE "_id" = 1`,
+          ),
+        ).toEqual([
+          {
+            description:
+              storedColumn.table === column.table
+                ? description
+                : originalDescription,
+          },
+        ]);
+      }
+
+      // Correcting the oversized value makes the same rollback safe to retry.
+      await database.query(
+        `UPDATE "${column.table}" SET "${column.column}" = $1 WHERE "_id" = 1`,
+        [originalDescription],
+      );
+      await database.undoLastMigration({ transaction: "all" });
+      await expectColumnTypes("character varying", 500);
+      await expectStoredDescriptions(originalDescription);
+    },
+  );
+
+  test("rolls back the first column change if migration of the second column fails", async () => {
+    await database.query(
+      'ALTER TABLE "Monitor" RENAME COLUMN "description" TO "legacyDescription"',
+    );
+
+    await expect(
+      database.runMigrations({ transaction: "all" }),
+    ).rejects.toThrow(/column "description".*does not exist/);
+
+    expect(await database.query('SELECT "name" FROM "migrations"')).toEqual([]);
+    await database.query(
+      'ALTER TABLE "Monitor" RENAME COLUMN "legacyDescription" TO "description"',
+    );
+    await expectColumnTypes("character varying", 500);
+    await expectStoredDescriptions(originalDescription);
+
+    expect(await database.runMigrations({ transaction: "all" })).toHaveLength(
+      1,
+    );
+    await expectColumnTypes("text", null);
+    await expectStoredDescriptions(originalDescription);
+  });
+});

package/Tests/Server/Infrastructure/TelemetryExporterDeploymentConfig.test.ts

@@ -3,7 +3,7 @@ import fs from "fs";
 import path from "path";
 import yaml from "js-yaml";
 
-const REPO_ROOT: string = path.resolve(__dirname, "../../../..");
+const REPO_ROOT: string = path.resolve(__dirname, "../../../../..");
 const COMPOSE_PATH: string = path.join(REPO_ROOT, "docker-compose.base.yml");
 const EXAMPLE_ENV_PATH: string = path.join(REPO_ROOT, "config.example.env");
 const HELM_VALUES_PATH: string = path.join(

package/Tests/Server/Infrastructure/ValkeyDeploymentConfig.test.ts

@@ -22,12 +22,18 @@ import yaml from "js-yaml";
  * config.env upgrade path by Tests/Ops/MergeEnvTemplateRenames.test.js.
  */
 
-const REPO_ROOT: string = path.resolve(__dirname, "../../../..");
+const REPO_ROOT: string = path.resolve(__dirname, "../../../../..");
 const BASE_COMPOSE_PATH: string = path.join(
   REPO_ROOT,
   "docker-compose.base.yml",
 );
 const EXAMPLE_ENV_PATH: string = path.join(REPO_ROOT, "config.example.env");
+const BILLING_OVERLAY_PATH: string = path.join(
+  REPO_ROOT,
+  "packages",
+  "E2E",
+  "docker-compose.billing.yml",
+);
 const HELM_VALUES_PATH: string = path.join(
   REPO_ROOT,
   "HelmChart",
@@ -36,11 +42,10 @@ const HELM_VALUES_PATH: string = path.join(
   "values.yaml",
 );
 
-// The three compose files an operator actually invokes; each extends the base.
+// The compose files an operator actually invokes; each extends the base.
 const OVERLAY_COMPOSE_FILES: Array<string> = [
   "docker-compose.yml",
-  "docker-compose.dev.yml",
-  "docker-compose.billing.yml",
+  "Scripts/Dev/docker-compose.dev.yml",
 ];
 
 // Every cache setting, by the suffix the two spellings share.
@@ -61,6 +66,7 @@ interface ComposeService {
   healthcheck?: { test?: Array<string> };
   networks?: Record<string, { aliases?: Array<string> } | null>;
   extends?: { file?: string; service?: string };
+  depends_on?: Record<string, { condition?: string }>;
 }
 
 interface ComposeFile {
@@ -224,6 +230,21 @@ describe("valkey cache and queue backend", () => {
     },
   );
 
+  /*
+   * The SaaS CI stack layers packages/E2E/docker-compose.billing.yml on top of
+   * docker-compose.yml, so it takes valkey from there; the container it adds
+   * has to wait on that service by its current name.
+   */
+  test("the billing overlay's home container waits on the valkey service", () => {
+    const overlay: ComposeFile = readCompose(BILLING_OVERLAY_PATH);
+
+    expect(overlay.services["redis"]).toBeUndefined();
+    expect(overlay.services["home"]?.depends_on?.["valkey"]?.condition).toBe(
+      "service_healthy",
+    );
+    expect(overlay.services["home"]?.depends_on?.["redis"]).toBeUndefined();
+  });
+
   /*
    * Compose and Helm claim in their comments to run the same engine version.
    * Nothing enforces that but this: the two drift apart the first time only one

package/Tests/Server/Middleware/IdentityRateLimit.test.ts

@@ -557,6 +557,18 @@ describe("IdentityRateLimit", () => {
       });
     });
 
+    it("ships the documented status page login budget", () => {
+      expect(
+        IdentityRateLimit.getBucketConfig(
+          IdentityRateLimitBucket.StatusPageLogin,
+        ),
+      ).toEqual({
+        windowSeconds: WINDOW_SECONDS,
+        perAccountLimit: PER_ACCOUNT_LIMIT,
+        perIpLimit: PER_IP_LIMIT,
+      });
+    });
+
     it("falls back to the login budget for an unknown bucket", () => {
       expect(
         IdentityRateLimit.getBucketConfig(
@@ -734,10 +746,70 @@ describe("IdentityRateLimit", () => {
       await consume({ bucket: IdentityRateLimitBucket.Login });
       await consume({ bucket: IdentityRateLimitBucket.TwoFactor });
       await consume({ bucket: IdentityRateLimitBucket.BackupCode });
+      await consume({ bucket: IdentityRateLimitBucket.StatusPageLogin });
 
       expect(client.keysMatching(":login:")).toHaveLength(2);
       expect(client.keysMatching(":two-factor:")).toHaveLength(2);
       expect(client.keysMatching(":backup-code:")).toHaveLength(2);
+      expect(client.keysMatching(":status-page-login:")).toHaveLength(2);
+    });
+
+    /*
+     * Status page private users and dashboard users are different accounts
+     * that can share an email address and an office. Guessing at one login
+     * must not refuse the other, in either direction.
+     */
+    it("does not let dashboard /login attempts refuse a status page login", async () => {
+      for (let i: number = 0; i < PER_IP_LIMIT + 1; i++) {
+        await consume({ bucket: IdentityRateLimitBucket.Login });
+      }
+
+      expect(
+        (await consume({ bucket: IdentityRateLimitBucket.StatusPageLogin }))
+          .outcome,
+      ).toBe(IdentityRateLimitOutcome.Allowed);
+    });
+
+    it("does not let status page login attempts refuse a dashboard /login", async () => {
+      for (let i: number = 0; i < PER_IP_LIMIT + 1; i++) {
+        await consume({ bucket: IdentityRateLimitBucket.StatusPageLogin });
+      }
+
+      expect(
+        (await consume({ bucket: IdentityRateLimitBucket.Login })).outcome,
+      ).toBe(IdentityRateLimitOutcome.Allowed);
+    });
+
+    it("bounds status page password guessing on its own counters", async () => {
+      for (let i: number = 0; i < PER_ACCOUNT_LIMIT; i++) {
+        expect(
+          (await consume({ bucket: IdentityRateLimitBucket.StatusPageLogin }))
+            .outcome,
+        ).toBe(IdentityRateLimitOutcome.Allowed);
+      }
+
+      const refused: IdentityRateLimitDecision = await consume({
+        bucket: IdentityRateLimitBucket.StatusPageLogin,
+      });
+
+      expect(refused.outcome).toBe(IdentityRateLimitOutcome.RateLimited);
+      expect(refused.scope).toBe(IdentityRateLimitScope.Account);
+
+      let ipRefused: IdentityRateLimitDecision | null = null;
+
+      for (let i: number = 0; i < PER_IP_LIMIT + 1; i++) {
+        const decision: IdentityRateLimitDecision = await consume({
+          accountKey: `rotating-${i}@example.com`,
+          clientIp: "198.51.100.4",
+          bucket: IdentityRateLimitBucket.StatusPageLogin,
+        });
+
+        if (decision.outcome === IdentityRateLimitOutcome.RateLimited) {
+          ipRefused = decision;
+        }
+      }
+
+      expect(ipRefused?.scope).toBe(IdentityRateLimitScope.Ip);
     });
   });
 

package/Tests/Server/Middleware/PublicDashboardRateLimit.test.ts

@@ -246,7 +246,7 @@ describe("PublicDashboardRateLimit", () => {
     clientIp?: string;
   }) => {
     return PublicDashboardRateLimit.consume({
-      dashboardKey: data.dashboardKey || "id:dashboard-a",
+      resourceKey: data.dashboardKey || "id:dashboard-a",
       clientIp: data.clientIp || "203.0.113.7",
       bucket: PublicDashboardRateLimitBucket.Read,
     });
@@ -811,7 +811,7 @@ describe("PublicDashboardRateLimit", () => {
     const consumePassword: () => Promise<PublicDashboardRateLimitDecision> =
       () => {
         return PublicDashboardRateLimit.consume({
-          dashboardKey: "id:dashboard-a",
+          resourceKey: "id:dashboard-a",
           clientIp: "203.0.113.7",
           bucket: PublicDashboardRateLimitBucket.MasterPassword,
         });
@@ -851,7 +851,7 @@ describe("PublicDashboardRateLimit", () => {
       for (let i: number = 0; i < MASTER_PASSWORD_PER_IP_LIMIT + 5; i++) {
         const decision: PublicDashboardRateLimitDecision =
           await PublicDashboardRateLimit.consume({
-            dashboardKey: `id:dashboard-${i}`,
+            resourceKey: `id:dashboard-${i}`,
             clientIp: "203.0.113.7",
             bucket: PublicDashboardRateLimitBucket.MasterPassword,
           });
@@ -903,7 +903,7 @@ describe("PublicDashboardRateLimit", () => {
         i++
       ) {
         await PublicDashboardRateLimit.consume({
-          dashboardKey: "id:dashboard-a",
+          resourceKey: "id:dashboard-a",
           clientIp: "203.0.113.7",
           bucket: PublicDashboardRateLimitBucket.MasterPassword,
         });
@@ -1441,7 +1441,7 @@ describe("PublicDashboardRateLimit configuration", () => {
       expect(
         (
           await limiter.consume({
-            dashboardKey: "id:a",
+            resourceKey: "id:a",
             clientIp: "203.0.113.7",
             bucket: PublicDashboardRateLimitBucket.Read,
           })
@@ -1452,7 +1452,7 @@ describe("PublicDashboardRateLimit configuration", () => {
     expect(
       (
         await limiter.consume({
-          dashboardKey: "id:a",
+          resourceKey: "id:a",
           clientIp: "203.0.113.7",
           bucket: PublicDashboardRateLimitBucket.Read,
         })
@@ -1469,7 +1469,7 @@ describe("PublicDashboardRateLimit configuration", () => {
 
     for (let i: number = 0; i < 6; i++) {
       const decision: PublicDashboardRateLimitDecision = await limiter.consume({
-        dashboardKey: `id:rotating-${i}`,
+        resourceKey: `id:rotating-${i}`,
         clientIp: "203.0.113.7",
         bucket: PublicDashboardRateLimitBucket.Read,
       });
@@ -1492,7 +1492,7 @@ describe("PublicDashboardRateLimit configuration", () => {
 
     for (let i: number = 0; i < 2; i++) {
       await limiter.consume({
-        dashboardKey: "id:a",
+        resourceKey: "id:a",
         clientIp: "203.0.113.7",
         bucket: PublicDashboardRateLimitBucket.MasterPassword,
       });
@@ -1501,7 +1501,7 @@ describe("PublicDashboardRateLimit configuration", () => {
     expect(
       (
         await limiter.consume({
-          dashboardKey: "id:a",
+          resourceKey: "id:a",
           clientIp: "203.0.113.7",
           bucket: PublicDashboardRateLimitBucket.MasterPassword,
         })
@@ -1517,7 +1517,7 @@ describe("PublicDashboardRateLimit configuration", () => {
 
     for (let i: number = 0; i < READ_PER_DASHBOARD_LIMIT; i++) {
       await limiter.consume({
-        dashboardKey: "id:a",
+        resourceKey: "id:a",
         clientIp: "203.0.113.7",
         bucket: PublicDashboardRateLimitBucket.Read,
       });
@@ -1526,7 +1526,7 @@ describe("PublicDashboardRateLimit configuration", () => {
     expect(
       (
         await limiter.consume({
-          dashboardKey: "id:a",
+          resourceKey: "id:a",
           clientIp: "203.0.113.7",
           bucket: PublicDashboardRateLimitBucket.Read,
         })
@@ -1543,7 +1543,7 @@ describe("PublicDashboardRateLimit configuration", () => {
     expect(
       (
         await limiter.consume({
-          dashboardKey: "id:a",
+          resourceKey: "id:a",
           clientIp: "203.0.113.7",
           bucket: PublicDashboardRateLimitBucket.Read,
         })