@oneuptime/common 12.0.33 → 12.0.34

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

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import { getMetadataArgsStorage } from "typeorm";
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import AlertCustomField from "../../../../Models/DatabaseModels/AlertCustomField";
+import IncidentCustomField from "../../../../Models/DatabaseModels/IncidentCustomField";
+import InventoryItemCustomField from "../../../../Models/DatabaseModels/InventoryItemCustomField";
+import MonitorCustomField from "../../../../Models/DatabaseModels/MonitorCustomField";
+import OnCallDutyPolicyCustomField from "../../../../Models/DatabaseModels/OnCallDutyPolicyCustomField";
+import ScheduledMaintenanceCustomField from "../../../../Models/DatabaseModels/ScheduledMaintenanceCustomField";
+import StatusPageCustomField from "../../../../Models/DatabaseModels/StatusPageCustomField";
+import TeamCustomField from "../../../../Models/DatabaseModels/TeamCustomField";
+import TeamMemberCustomField from "../../../../Models/DatabaseModels/TeamMemberCustomField";
+import { AddCustomFieldValueMapping1791600000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1791600000000-AddCustomFieldValueMapping";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+
+/*
+ * The value-mapping columns, and the two ways a migration silently fails to
+ * ship them.
+ *
+ * The first is the one AGENTS.md calls out: a migration file that exists but
+ * is never added to SchemaMigrations/Index.ts does not run, so the column is
+ * simply missing in production while every local database that was migrated by
+ * hand looks fine. The second is a column added to a model but not to the
+ * migration (or vice versa) — that is a green deploy followed by a red Schema
+ * Drift job.
+ *
+ * Both are checked against the models' own decorator metadata and the
+ * filesystem rather than a list written out twice.
+ */
+
+const MIGRATIONS_DIRECTORY: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+);
+
+const MIGRATION_PATH: string = path.join(
+  MIGRATIONS_DIRECTORY,
+  "1791600000000-AddCustomFieldValueMapping.ts",
+);
+
+const SOURCE: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+const MODELS_DIRECTORY: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "Models",
+  "DatabaseModels",
+);
+
+const MAPPING_COLUMNS: ReadonlyArray<string> = [
+  "mapFromResourceType",
+  "mapFromCustomFieldName",
+];
+
+/** The `<timestamp>-<Name>.ts` prefix TypeORM orders migrations by. */
+const MIGRATION_TIMESTAMP_PREFIX: RegExp = /^(\d+)-/;
+
+/*
+ * What TypeORM's metadata storage keys entities by: the class itself. Only
+ * ever compared by identity against `column.target`, so `unknown` states the
+ * requirement exactly — and avoids `Function`/`object`, both of which this
+ * repo's eslint config bans.
+ */
+type ModelClass = unknown;
+
+const DEFINITION_MODELS: Record<string, ModelClass> = {
+  AlertCustomField: AlertCustomField,
+  IncidentCustomField: IncidentCustomField,
+  InventoryItemCustomField: InventoryItemCustomField,
+  MonitorCustomField: MonitorCustomField,
+  OnCallDutyPolicyCustomField: OnCallDutyPolicyCustomField,
+  ScheduledMaintenanceCustomField: ScheduledMaintenanceCustomField,
+  StatusPageCustomField: StatusPageCustomField,
+  TeamCustomField: TeamCustomField,
+  TeamMemberCustomField: TeamMemberCustomField,
+};
+
+/*
+ * The definition tables as they exist on disk, so a tenth one added later
+ * fails this suite rather than quietly shipping without the columns.
+ */
+const DEFINITION_TABLES: Array<string> = fs
+  .readdirSync(MODELS_DIRECTORY)
+  .filter((fileName: string) => {
+    return fileName.endsWith("CustomField.ts");
+  })
+  .map((fileName: string) => {
+    return fileName.replace(/\.ts$/, "");
+  })
+  .sort();
+
+type DeclaredColumnsFunction = (modelType: ModelClass) => Array<string>;
+
+const getDeclaredColumns: DeclaredColumnsFunction = (
+  modelType: ModelClass,
+): Array<string> => {
+  return getMetadataArgsStorage()
+    .columns.filter((column: ColumnMetadataArgs): boolean => {
+      return column.target === modelType;
+    })
+    .map((column: ColumnMetadataArgs): string => {
+      return column.propertyName;
+    });
+};
+
+describe("the value-mapping migration", () => {
+  test("the file the rest of this suite reads exists, and every definition table is covered", () => {
+    expect(fs.existsSync(MIGRATION_PATH)).toBe(true);
+    expect(SOURCE.length).toBeGreaterThan(0);
+    expect(DEFINITION_TABLES.length).toBeGreaterThanOrEqual(9);
+    expect(Object.keys(DEFINITION_MODELS).sort()).toEqual(DEFINITION_TABLES);
+  });
+
+  /*
+   * Registration is the step with no feedback: an unregistered migration
+   * throws no error, logs nothing and simply never runs.
+   */
+  test("is registered in SchemaMigrations/Index.ts so it actually runs", () => {
+    expect(SchemaMigrations).toContain(AddCustomFieldValueMapping1791600000000);
+  });
+
+  test("its class name matches the `name` TypeORM records in the migrations table", () => {
+    expect(new AddCustomFieldValueMapping1791600000000().name).toBe(
+      "AddCustomFieldValueMapping1791600000000",
+    );
+  });
+
+  test.each(DEFINITION_TABLES)(
+    "adds both mapping columns to %s",
+    (tableName: string) => {
+      for (const column of MAPPING_COLUMNS) {
+        expect(SOURCE).toContain(
+          `ALTER TABLE "${tableName}" ADD "${column}" character varying(100)`,
+        );
+      }
+    },
+  );
+
+  test.each(DEFINITION_TABLES)(
+    "drops both mapping columns from %s on the way down",
+    (tableName: string) => {
+      for (const column of MAPPING_COLUMNS) {
+        expect(SOURCE).toContain(
+          `ALTER TABLE "${tableName}" DROP COLUMN "${column}"`,
+        );
+      }
+    },
+  );
+
+  test.each(DEFINITION_TABLES)(
+    "%s declares both mapping columns on the model, so the schema and the entities agree",
+    (tableName: string) => {
+      const declared: Array<string> = getDeclaredColumns(
+        DEFINITION_MODELS[tableName],
+      );
+
+      for (const column of MAPPING_COLUMNS) {
+        expect(declared).toContain(column);
+      }
+    },
+  );
+
+  /*
+   * TypeORM orders migrations by the timestamp in the class name, not by the
+   * order of the array. A timestamp below one already registered would run
+   * this migration before migrations that shipped earlier — harmless here, but
+   * the convention in this directory is a monotonic timestamp and breaking it
+   * makes the ordering unreadable.
+   */
+  test("its timestamp is the newest in the directory", () => {
+    const timestamps: Array<number> = fs
+      .readdirSync(MIGRATIONS_DIRECTORY)
+      .map((fileName: string) => {
+        return MIGRATION_TIMESTAMP_PREFIX.exec(fileName);
+      })
+      .filter((match: RegExpExecArray | null): match is RegExpExecArray => {
+        return Boolean(match);
+      })
+      .map((match: RegExpExecArray) => {
+        return parseInt(match[1]!, 10);
+      });
+
+    const ownTimestamp: number = parseInt(
+      MIGRATION_TIMESTAMP_PREFIX.exec(path.basename(MIGRATION_PATH))![1]!,
+      10,
+    );
+
+    expect(Math.max(...timestamps)).toBe(ownTimestamp);
+  });
+});

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

@@ -137,12 +137,53 @@ describe("the custom field table", () => {
     /*
      * Read off the model rather than listed here, so a column added to the
      * model without a migration fails rather than throwing at runtime.
+     *
+     * A column may legitimately arrive in a LATER migration instead of this
+     * CREATE TABLE — this migration has already shipped, and editing it would
+     * do nothing for the databases that have run it while putting them out of
+     * step with fresh ones. So the invariant is "every model column is created
+     * here or added later", which still fails a column that no migration
+     * mentions at all. The end-state schema itself is owned by the Schema
+     * Drift job, which migrates an empty database and diffs it against the
+     * models.
      */
     const createStatement: string = SOURCE.slice(
       SOURCE.indexOf('CREATE TABLE "InventoryItemCustomField"'),
     ).split("`")[0]!;
 
+    const migrationsDirectory: string = path.dirname(MIGRATION_PATH);
+
+    const addedByLaterMigration: Set<string> = new Set<string>();
+
+    for (const fileName of fs.readdirSync(migrationsDirectory)) {
+      if (
+        !fileName.endsWith(".ts") ||
+        fileName === path.basename(MIGRATION_PATH)
+      ) {
+        continue;
+      }
+
+      const migrationSource: string = fs.readFileSync(
+        path.join(migrationsDirectory, fileName),
+        "utf8",
+      );
+
+      const addPattern: RegExp =
+        /ALTER TABLE "InventoryItemCustomField" ADD "([^"]+)"/g;
+
+      let match: RegExpExecArray | null = addPattern.exec(migrationSource);
+
+      while (match) {
+        addedByLaterMigration.add(match[1]!);
+        match = addPattern.exec(migrationSource);
+      }
+    }
+
     for (const column of getDeclaredColumns(InventoryItemCustomField)) {
+      if (addedByLaterMigration.has(column)) {
+        continue;
+      }
+
       expect(createStatement).toContain(`"${column}"`);
     }
   });

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

@@ -0,0 +1,169 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { SessionReplayRecordEverySessionByDefault1791400000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1791400000000-SessionReplayRecordEverySessionByDefault";
+import RumApplication from "../../../../Models/DatabaseModels/RumApplication";
+import SessionReplayCaptureTrigger from "../../../../Types/Rum/SessionReplayCaptureTrigger";
+import { TableColumnMetadata } from "../../../../Types/Database/TableColumn";
+
+/*
+ * The migration that makes session replay record every session rather than
+ * only the ones that broke.
+ *
+ * The reported bug was not that playback was broken for unfailed sessions —
+ * it was that they were never uploaded at all. `OnErrorOrFrustration` with
+ * `sessionReplaySamplePercentage: 0` means the recorder buffers in memory and
+ * posts nothing until an error, a 5xx or a frustration signal fires, so the
+ * only rows that ever reached the session list carried one of those signals.
+ * Everything else read as "Metadata only" or as no row at all, which is
+ * indistinguishable from a feature that does not work.
+ *
+ * Three things are pinned here, and each of them is a silent regression if it
+ * moves on its own:
+ *
+ *  1. THE ENTITY AND THE MIGRATION AGREE. A default lives in two places —
+ *     the @Column decorator TypeORM generates DDL from, and the ALTER this
+ *     migration runs on databases that already exist. If only one moves, a
+ *     fresh install and an upgraded install disagree about what recording
+ *     means, and the schema-drift job does not catch a DEFAULT that matches
+ *     the entity it was generated from.
+ *
+ *  2. THE BACKFILL IS SCOPED TO ROWS STILL ON BOTH OLD DEFAULTS. An
+ *     unscoped UPDATE would overwrite a deliberate configuration; scoping on
+ *     only one of the two columns would catch an application whose operator
+ *     had set the other on purpose. Requiring both is the closest a
+ *     migration can get to "was never configured", and widening it later
+ *     would quietly increase how much end-user data an install records.
+ *
+ *  3. down() REVERSES THE DEFAULTS AND NOT THE BACKFILL. Rows moved by the
+ *     backfill are indistinguishable from ones an operator chose afterwards,
+ *     so moving them back would silently stop recording sessions somebody is
+ *     relying on being able to watch.
+ */
+
+const MIGRATION_PATH: string = path.join(
+  __dirname,
+  "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1791400000000-SessionReplayRecordEverySessionByDefault.ts",
+);
+
+const SOURCE: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+function bodyOf(method: "up" | "down"): string {
+  const start: number = SOURCE.indexOf(`public async ${method}(`);
+
+  expect(start).toBeGreaterThan(-1);
+
+  const end: number =
+    method === "up" ? SOURCE.indexOf("public async down(") : SOURCE.length;
+
+  return SOURCE.slice(start, end);
+}
+
+function statementsIn(body: string): Array<string> {
+  return [...body.matchAll(/`([^`]+)`/g)].map(
+    (match: RegExpMatchArray): string => {
+      return match[1] as string;
+    },
+  );
+}
+
+const UP_STATEMENTS: Array<string> = statementsIn(bodyOf("up"));
+const DOWN_STATEMENTS: Array<string> = statementsIn(bodyOf("down"));
+
+describe("SessionReplayRecordEverySessionByDefault migration", () => {
+  test("it is registered in the schema migration list", () => {
+    expect(SchemaMigrations).toContain(
+      SessionReplayRecordEverySessionByDefault1791400000000,
+    );
+  });
+
+  test("its class name matches its file name, so typeorm can find it", () => {
+    expect(
+      new SessionReplayRecordEverySessionByDefault1791400000000().name,
+    ).toBe("SessionReplayRecordEverySessionByDefault1791400000000");
+  });
+
+  test("it moves both column defaults to always-on recording", () => {
+    expect(UP_STATEMENTS).toContain(
+      `ALTER TABLE "RumApplication" ALTER COLUMN "sessionReplayCaptureTrigger" SET DEFAULT 'Always'`,
+    );
+    expect(UP_STATEMENTS).toContain(
+      `ALTER TABLE "RumApplication" ALTER COLUMN "sessionReplaySamplePercentage" SET DEFAULT 100`,
+    );
+  });
+
+  test("it backfills only rows still sitting on BOTH previous defaults", () => {
+    const updates: Array<string> = UP_STATEMENTS.filter(
+      (statement: string): boolean => {
+        return statement.startsWith("UPDATE ");
+      },
+    );
+
+    expect(updates).toHaveLength(1);
+
+    const update: string = updates[0] as string;
+
+    expect(update).toContain(`"sessionReplayCaptureTrigger" = 'Always'`);
+    expect(update).toContain(`"sessionReplaySamplePercentage" = 100`);
+
+    /*
+     * The WHERE is the entire safety property. Both conditions, joined by
+     * AND: an application whose operator chose Always, or dialled the
+     * sample percentage anywhere off zero, is left exactly as configured.
+     */
+    const where: string = update.slice(update.indexOf(" WHERE "));
+
+    expect(where).toContain(
+      `"sessionReplayCaptureTrigger" = 'OnErrorOrFrustration'`,
+    );
+    expect(where).toContain(`"sessionReplaySamplePercentage" = 0`);
+    expect(where).toContain(" AND ");
+    expect(where).not.toContain(" OR ");
+  });
+
+  test("down() restores the defaults and leaves the backfilled rows alone", () => {
+    expect(DOWN_STATEMENTS).toContain(
+      `ALTER TABLE "RumApplication" ALTER COLUMN "sessionReplayCaptureTrigger" SET DEFAULT 'OnErrorOrFrustration'`,
+    );
+    expect(DOWN_STATEMENTS).toContain(
+      `ALTER TABLE "RumApplication" ALTER COLUMN "sessionReplaySamplePercentage" SET DEFAULT 0`,
+    );
+
+    expect(
+      DOWN_STATEMENTS.some((statement: string): boolean => {
+        return statement.startsWith("UPDATE ");
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("RumApplication session replay capture defaults", () => {
+  test("a new application records every session from its first event", () => {
+    const application: RumApplication = new RumApplication();
+
+    const trigger: TableColumnMetadata = application.getTableColumnMetadata(
+      "sessionReplayCaptureTrigger",
+    );
+    const sample: TableColumnMetadata = application.getTableColumnMetadata(
+      "sessionReplaySamplePercentage",
+    );
+
+    expect(trigger.defaultValue).toBe(SessionReplayCaptureTrigger.Always);
+    expect(sample.defaultValue).toBe(100);
+  });
+
+  /*
+   * The dashboard form renders this enum straight into a dropdown, in
+   * declaration order, so the first member is what a person reads as the
+   * recommended answer. Keeping Always first is the difference between the
+   * default being discoverable and being buried under the option that
+   * records nothing for a healthy visit.
+   */
+  test("Always is the first capture trigger a person is offered", () => {
+    expect(Object.values(SessionReplayCaptureTrigger)).toEqual([
+      SessionReplayCaptureTrigger.Always,
+      SessionReplayCaptureTrigger.OnErrorOrFrustration,
+    ]);
+  });
+});

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

@@ -0,0 +1,210 @@
+import QueueWorker from "../../../Server/Infrastructure/QueueWorker";
+import TimeoutException from "../../../Types/Exception/TimeoutException";
+
+jest.mock("../../../Server/Utils/Telemetry/CaptureSpan", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return (
+        _target: unknown,
+        _name: string,
+        descriptor: PropertyDescriptor,
+      ): PropertyDescriptor => {
+        return descriptor;
+      };
+    },
+  };
+});
+
+jest.mock("../../../Server/Utils/Telemetry", () => {
+  return { __esModule: true, default: {} };
+});
+jest.mock("../../../Server/Utils/Telemetry/AppMetrics", () => {
+  return { __esModule: true, default: {} };
+});
+jest.mock("../../../Server/Infrastructure/Redis", () => {
+  return { __esModule: true, default: {} };
+});
+jest.mock("../../../Server/Utils/GracefulShutdown", () => {
+  return { __esModule: true, default: {} };
+});
+jest.mock("../../../Server/Utils/Logger", () => {
+  return { __esModule: true, default: {} };
+});
+
+interface DeferredJob {
+  promise: Promise<void>;
+  resolve: () => void;
+  reject: (reason: unknown) => void;
+}
+
+function deferredJob(): DeferredJob {
+  let resolve!: () => void;
+  let reject!: (reason: unknown) => void;
+  const promise: Promise<void> = new Promise<void>(
+    (res: () => void, rej: (reason: unknown) => void) => {
+      resolve = res;
+      reject = rej;
+    },
+  );
+  return { promise, resolve, reject };
+}
+
+describe("QueueWorker.runJobWithTimeout timer lifecycle", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  it.each([0, 1, 300_000, 3_600_000])(
+    "releases a %i ms deadline immediately when the job succeeds",
+    async (deadline: number) => {
+      const callback: jest.Mock = jest.fn().mockResolvedValue(undefined);
+      await expect(
+        QueueWorker.runJobWithTimeout(deadline, callback),
+      ).resolves.toBeUndefined();
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+    },
+  );
+
+  it.each([new Error("failed"), "non-error rejection", null])(
+    "preserves rejection identity and clears the deadline (%p)",
+    async (error: unknown) => {
+      await expect(
+        QueueWorker.runJobWithTimeout(300_000, () => {
+          return Promise.reject(error);
+        }),
+      ).rejects.toBe(error);
+      expect(jest.getTimerCount()).toBe(0);
+    },
+  );
+
+  it("clears the timer when the callback throws before returning a promise", async () => {
+    const error: Error = new Error("synchronous failure");
+    await expect(
+      QueueWorker.runJobWithTimeout(300_000, () => {
+        throw error;
+      }),
+    ).rejects.toBe(error);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it("holds a deadline only while a job is pending", async () => {
+    const job: DeferredJob = deferredJob();
+    const result: Promise<void> = QueueWorker.runJobWithTimeout(100, () => {
+      return job.promise;
+    });
+    expect(jest.getTimerCount()).toBe(1);
+    jest.advanceTimersByTime(99);
+    job.resolve();
+    await result;
+    expect(jest.getTimerCount()).toBe(0);
+    jest.advanceTimersByTime(1);
+    await expect(result).resolves.toBeUndefined();
+  });
+
+  it("rejects at the deadline with the existing timeout error", async () => {
+    const job: DeferredJob = deferredJob();
+    const result: Promise<void> = QueueWorker.runJobWithTimeout(100, () => {
+      return job.promise;
+    });
+    const rejection: Promise<void> = expect(result).rejects.toEqual(
+      new TimeoutException("Job Timeout"),
+    );
+    jest.advanceTimersByTime(100);
+    await rejection;
+    expect(jest.getTimerCount()).toBe(0);
+    // The timeout is a deadline, not cancellation of the underlying work.
+    job.resolve();
+    await job.promise;
+  });
+
+  it("observes a job rejection after its deadline without an unhandled rejection", async () => {
+    const job: DeferredJob = deferredJob();
+    const result: Promise<void> = QueueWorker.runJobWithTimeout(10, () => {
+      return job.promise;
+    });
+    const rejection: Promise<void> =
+      expect(result).rejects.toBeInstanceOf(TimeoutException);
+    jest.advanceTimersByTime(10);
+    await rejection;
+    job.reject(new Error("late failure"));
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it("keeps another concurrent job's deadline active", async () => {
+    const first: DeferredJob = deferredJob();
+    const second: DeferredJob = deferredJob();
+    const firstResult: Promise<void> = QueueWorker.runJobWithTimeout(
+      100,
+      () => {
+        return first.promise;
+      },
+    );
+    const secondResult: Promise<void> = QueueWorker.runJobWithTimeout(
+      200,
+      () => {
+        return second.promise;
+      },
+    );
+    const secondRejection: Promise<void> =
+      expect(secondResult).rejects.toBeInstanceOf(TimeoutException);
+
+    first.resolve();
+    await firstResult;
+    expect(jest.getTimerCount()).toBe(1);
+    jest.advanceTimersByTime(200);
+    await secondRejection;
+    expect(jest.getTimerCount()).toBe(0);
+    second.resolve();
+  });
+
+  it("does not clear timers created by the job itself", async () => {
+    const jobTimer: jest.Mock = jest.fn();
+    await QueueWorker.runJobWithTimeout(100, async () => {
+      setTimeout(jobTimer, 200);
+    });
+    expect(jest.getTimerCount()).toBe(1);
+    jest.advanceTimersByTime(200);
+    expect(jobTimer).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps the original deadline-first ordering for equal-time completion", async () => {
+    const result: Promise<void> = QueueWorker.runJobWithTimeout(100, () => {
+      return new Promise<void>((resolve: () => void) => {
+        setTimeout(resolve, 100);
+      });
+    });
+    const rejection: Promise<void> =
+      expect(result).rejects.toBeInstanceOf(TimeoutException);
+    jest.advanceTimersByTime(100);
+    await rejection;
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it("does not accumulate timeout handles across 10,000 completed jobs", async () => {
+    for (let batch: number = 0; batch < 100; batch++) {
+      const jobs: Array<Promise<void>> = Array.from(
+        { length: 100 },
+        (_value: unknown, index: number): Promise<void> => {
+          return QueueWorker.runJobWithTimeout(300_000, async () => {
+            if (index % 2 === 0) {
+              throw new Error("expected job failure");
+            }
+          }).catch(() => {
+            // Failed jobs must release their timers too.
+          });
+        },
+      );
+      await Promise.all(jobs);
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  });
+});