@oneuptime/common 12.0.10 → 12.0.11

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

@@ -0,0 +1,312 @@
+import CommonModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/CommonModel";
+import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * Unit tests for CommonModel — the base every analytics (ClickHouse) model
+ * extends. It owns the column-aware value coercion (setColumnValue) and the
+ * JSON (de)serialization that the analytics query/ingest layer relies on.
+ *
+ * Nothing imports CommonModel directly in the existing test suite, so its
+ * per-type string coercion and its static/instance JSON helpers were
+ * uncovered. The logic is pure: it reads column metadata off the instance,
+ * so no ClickHouse connection is required.
+ */
+
+// Build a column of a given type. Only key + type matter for these tests.
+const column: (key: string, type: TableColumnType) => AnalyticsTableColumn = (
+  key: string,
+  type: TableColumnType,
+): AnalyticsTableColumn => {
+  return new AnalyticsTableColumn({
+    key,
+    title: key,
+    description: `${key} column`,
+    required: false,
+    type,
+  });
+};
+
+const COLUMNS: Array<AnalyticsTableColumn> = [
+  column("name", TableColumnType.Text),
+  column("resourceId", TableColumnType.ObjectID),
+  column("startsAt", TableColumnType.Date),
+  column("observedAt", TableColumnType.DateTime64),
+  column("attributes", TableColumnType.JSON),
+  column("tags", TableColumnType.JSONArray),
+  column("count", TableColumnType.Number),
+  column("ratio", TableColumnType.Decimal),
+  column("bigCount", TableColumnType.LongNumber),
+];
+
+/*
+ * A concrete model with a no-arg constructor so the static new type() paths
+ * (fromJSON / fromJSONArray) work.
+ */
+class TestModel extends CommonModel {
+  public constructor() {
+    super({ tableColumns: COLUMNS });
+  }
+}
+
+const newModel: () => TestModel = (): TestModel => {
+  return new TestModel();
+};
+
+describe("CommonModel.getTableColumn", () => {
+  test("returns the column when it exists", () => {
+    const model: TestModel = newModel();
+    const col: AnalyticsTableColumn | null = model.getTableColumn("name");
+    expect(col).not.toBeNull();
+    expect(col!.key).toBe("name");
+    expect(col!.type).toBe(TableColumnType.Text);
+  });
+
+  test("returns null for an unknown column", () => {
+    expect(newModel().getTableColumn("doesNotExist")).toBeNull();
+  });
+
+  test("getTableColumns returns the full column set", () => {
+    expect(newModel().getTableColumns()).toHaveLength(COLUMNS.length);
+  });
+});
+
+describe("CommonModel.setColumnValue coercion by column type", () => {
+  test("stores a plain text value unchanged", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("name", "hello");
+    expect(model.getColumnValue("name")).toBe("hello");
+  });
+
+  test("wraps a string into an ObjectID for an ObjectID column", () => {
+    const model: TestModel = newModel();
+    const id: ObjectID = ObjectID.generate();
+    model.setColumnValue("resourceId", id.toString());
+    const stored: unknown = model.getColumnValue("resourceId");
+    expect(stored).toBeInstanceOf(ObjectID);
+    expect((stored as ObjectID).toString()).toBe(id.toString());
+  });
+
+  test("parses a string into a Date for Date and DateTime64 columns", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("startsAt", "2023-01-15T12:30:00.000Z");
+    model.setColumnValue("observedAt", "2023-06-01T00:00:00.000Z");
+    expect(model.getColumnValue("startsAt")).toBeInstanceOf(Date);
+    expect(model.getColumnValue("observedAt")).toBeInstanceOf(Date);
+  });
+
+  test("parses a JSON string for a JSON column", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("attributes", '{"env":"prod","n":5}');
+    expect(model.getColumnValue("attributes")).toEqual({
+      env: "prod",
+      n: 5,
+    });
+  });
+
+  test("falls back to an empty object when the JSON string is invalid", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("attributes", "not json {");
+    expect(model.getColumnValue("attributes")).toEqual({});
+  });
+
+  test("parses a JSON array string for a JSONArray column", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("tags", "[1, 2, 3]");
+    expect(model.getColumnValue("tags")).toEqual([1, 2, 3]);
+  });
+
+  test("falls back to an empty array when the JSONArray string is invalid", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("tags", "definitely not an array");
+    expect(model.getColumnValue("tags")).toEqual([]);
+  });
+
+  test("parses a string into an integer for a Number column", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("count", "42");
+    expect(model.getColumnValue("count")).toBe(42);
+  });
+
+  test("parses a string into a float for a Decimal column", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("ratio", "3.14");
+    expect(model.getColumnValue("ratio")).toBe(3.14);
+  });
+
+  test("parses a string into an integer for a LongNumber column", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("bigCount", "1000");
+    expect(model.getColumnValue("bigCount")).toBe(1000);
+  });
+
+  test("leaves an already-numeric value on a Number column unchanged", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("count", 7);
+    expect(model.getColumnValue("count")).toBe(7);
+  });
+
+  test("throws BadDataException when setting an unknown column", () => {
+    const model: TestModel = newModel();
+    expect(() => {
+      model.setColumnValue("nope", "x");
+    }).toThrow(BadDataException);
+  });
+});
+
+describe("CommonModel.getColumnValue", () => {
+  test("returns undefined for an unknown column", () => {
+    expect(newModel().getColumnValue("nope")).toBeUndefined();
+  });
+
+  test("returns undefined for a known-but-unset column", () => {
+    expect(newModel().getColumnValue("name")).toBeUndefined();
+  });
+});
+
+describe("CommonModel.fromJSON (instance) and toJSON", () => {
+  test("fromJSON populates every provided column with coercion", () => {
+    const model: CommonModel = newModel().fromJSON({
+      name: "widget",
+      count: "10",
+      ratio: "2.5",
+    });
+
+    expect(model.getColumnValue("name")).toBe("widget");
+    expect(model.getColumnValue("count")).toBe(10);
+    expect(model.getColumnValue("ratio")).toBe(2.5);
+  });
+
+  test("toJSON emits set columns and omits unset ones", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("name", "widget");
+    model.setColumnValue("count", 3);
+
+    const json: Record<string, unknown> = model.toJSON();
+
+    expect(json["name"]).toBe("widget");
+    expect(json["count"]).toBe(3);
+    // Unset columns serialize to undefined, which JSONFunctions.serialize drops.
+    expect(Object.prototype.hasOwnProperty.call(json, "ratio")).toBe(false);
+    expect(json["ratio"]).toBeUndefined();
+  });
+
+  test("toJSON recursively serializes a nested CommonModel value", () => {
+    const parent: TestModel = newModel();
+    const child: TestModel = newModel();
+    child.setColumnValue("name", "child");
+
+    /*
+     * A non-string value on a column is stored as-is, so a nested model
+     * survives to toJSON where it is recursively serialized.
+     */
+    parent.setColumnValue("attributes", child as unknown as never);
+
+    const json: Record<string, unknown> = parent.toJSON();
+    expect((json["attributes"] as Record<string, unknown>)["name"]).toBe(
+      "child",
+    );
+  });
+});
+
+describe("CommonModel static fromJSON / toJSON", () => {
+  test("builds a model instance from a plain JSON object", () => {
+    const model: CommonModel = CommonModel.fromJSON(
+      { name: "from-json" },
+      TestModel,
+    ) as CommonModel;
+
+    expect(model).toBeInstanceOf(TestModel);
+    expect(model.getColumnValue("name")).toBe("from-json");
+  });
+
+  test("returns an already-constructed model unchanged", () => {
+    const existing: TestModel = newModel();
+    existing.setColumnValue("name", "existing");
+
+    const result: CommonModel = CommonModel.fromJSON(
+      existing,
+      TestModel,
+    ) as CommonModel;
+
+    expect(result).toBe(existing);
+  });
+
+  test("builds an array of models, passing through existing instances", () => {
+    const existing: TestModel = newModel();
+    existing.setColumnValue("name", "kept");
+
+    const result: Array<CommonModel> = CommonModel.fromJSON(
+      [{ name: "a" }, existing, { name: "b" }] as never,
+      TestModel,
+    ) as Array<CommonModel>;
+
+    expect(result).toHaveLength(3);
+    expect(result[0]!.getColumnValue("name")).toBe("a");
+    expect(result[1]).toBe(existing);
+    expect(result[2]!.getColumnValue("name")).toBe("b");
+  });
+
+  test("static toJSON delegates to the instance toJSON", () => {
+    const model: TestModel = newModel();
+    model.setColumnValue("name", "delegated");
+
+    const json: Record<string, unknown> = CommonModel.toJSON(model, TestModel);
+    expect(json["name"]).toBe("delegated");
+  });
+});
+
+describe("CommonModel static fromJSONArray / toJSONArray", () => {
+  test("fromJSONArray builds instances and passes through existing ones", () => {
+    const existing: TestModel = newModel();
+    existing.setColumnValue("name", "kept");
+
+    const models: Array<CommonModel> = CommonModel.fromJSONArray(
+      [{ name: "first" }, existing],
+      TestModel,
+    );
+
+    expect(models).toHaveLength(2);
+    expect(models[0]!.getColumnValue("name")).toBe("first");
+    expect(models[1]).toBe(existing);
+  });
+
+  test("toJSONArray round-trips a list of models to JSON objects", () => {
+    const a: TestModel = newModel();
+    a.setColumnValue("name", "a");
+    const b: TestModel = newModel();
+    b.setColumnValue("name", "b");
+
+    const jsonArray: Array<Record<string, unknown>> = CommonModel.toJSONArray(
+      [a, b],
+      TestModel,
+    );
+
+    expect(jsonArray).toHaveLength(2);
+    expect(jsonArray[0]!["name"]).toBe("a");
+    expect(jsonArray[1]!["name"]).toBe("b");
+  });
+
+  test("fromJSONArray then toJSONArray preserves scalar values", () => {
+    const input: Array<Record<string, unknown>> = [
+      { name: "x", count: 1 },
+      { name: "y", count: 2 },
+    ];
+
+    const models: Array<CommonModel> = CommonModel.fromJSONArray(
+      input as never,
+      TestModel,
+    );
+    const output: Array<Record<string, unknown>> = CommonModel.toJSONArray(
+      models,
+      TestModel,
+    );
+
+    expect(output[0]!["name"]).toBe("x");
+    expect(output[0]!["count"]).toBe(1);
+    expect(output[1]!["name"]).toBe("y");
+    expect(output[1]!["count"]).toBe(2);
+  });
+});

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

@@ -0,0 +1,250 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { AddDeviceRoleAndDeclaredLinkParent1787400000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1787400000000-AddDeviceRoleAndDeclaredLinkParent";
+
+/*
+ * The migration behind #3192: NetworkDevice.deviceRole and
+ * NetworkDeviceLink.parentDeviceId.
+ *
+ * Two things are worth pinning about it, and neither is the SQL — the
+ * statements were generated rather than written, and the schema-drift job
+ * already proves they match the entities.
+ *
+ * The first is NULLABILITY, because it carries meaning here rather than
+ * just permissiveness. NULL is not "unset pending a backfill": on
+ * deviceRole it means "no override, let the classifier decide", and on
+ * parentDeviceId it means "peers, infer the direction". They are the
+ * values every existing row should hold, and a DEFAULT or a NOT NULL on
+ * either would silently restate every device and every link in every
+ * project as something an operator had chosen.
+ *
+ * The second is ORDERING. This is the newest registered migration, so it
+ * inherits the guard that used to live in
+ * EpisodeMemberNotifyIndexesMigration.test.ts: its timestamp must sort
+ * above every other. A migration generated with `generate-postgres-
+ * migration` carries a WALL-CLOCK timestamp, and the recent migrations in
+ * this repo use hand-picked round numbers that run ahead of it — so the
+ * generated file lands below several already-registered migrations unless
+ * somebody renumbers it. That is exactly what happened to this one.
+ * Whoever adds the next migration should move this test's ordering block
+ * to theirs.
+ */
+
+const MIGRATION_PATH: string = path.join(
+  __dirname,
+  "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1787400000000-AddDeviceRoleAndDeclaredLinkParent.ts",
+);
+
+const SOURCE: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+interface MigrationClass {
+  name: string;
+}
+
+function timestampOf(migrationClass: MigrationClass): number | null {
+  const match: RegExpMatchArray | null = migrationClass.name.match(/(\d+)$/);
+  return match ? Number(match[1]) : null;
+}
+
+describe("the columns it adds", () => {
+  test("NetworkDevice gains deviceRole", () => {
+    expect(SOURCE).toContain(
+      `ALTER TABLE "NetworkDevice" ADD "deviceRole" character varying(100)`,
+    );
+  });
+
+  test("NetworkDeviceLink gains parentDeviceId", () => {
+    expect(SOURCE).toContain(
+      `ALTER TABLE "NetworkDeviceLink" ADD "parentDeviceId" uuid`,
+    );
+  });
+
+  /*
+   * See the header: NULL is a meaningful value on both, so neither may
+   * arrive with a DEFAULT or a NOT NULL.
+   */
+  test("neither column is given a default", () => {
+    const addStatements: Array<string> = [
+      ...SOURCE.matchAll(/`(ALTER TABLE [^`]*ADD "[^"]+"[^`]*)`/g),
+    ].map((match: RegExpMatchArray): string => {
+      return match[1] as string;
+    });
+
+    expect(addStatements.length).toBe(2);
+    for (const statement of addStatements) {
+      expect(statement).not.toContain("DEFAULT");
+      expect(statement).not.toContain("NOT NULL");
+    }
+  });
+
+  test("the parent is indexed and cascades with the device it names", () => {
+    expect(SOURCE).toContain(
+      `CREATE INDEX "IDX_01752cd47b773df38b4a54ae53" ON "NetworkDeviceLink" ("parentDeviceId")`,
+    );
+    expect(SOURCE).toContain(
+      `FOREIGN KEY ("parentDeviceId") REFERENCES "NetworkDevice"("_id") ON DELETE CASCADE`,
+    );
+  });
+
+  /*
+   * The parent is always one of the link's own two ends, and both of those
+   * already cascade — so this cascade only ever fires alongside one of
+   * them. Anything weaker would leave a link pointing at a deleted device.
+   */
+  test("it touches nothing beyond those two tables", () => {
+    const touchedTables: Set<string> = new Set<string>(
+      [...SOURCE.matchAll(/ALTER TABLE "(\w+)"/g)].map(
+        (match: RegExpMatchArray): string => {
+          return match[1] as string;
+        },
+      ),
+    );
+
+    expect([...touchedTables].sort()).toEqual([
+      "NetworkDevice",
+      "NetworkDeviceLink",
+    ]);
+  });
+});
+
+describe("up and down are symmetric", () => {
+  test("down drops everything up adds, and nothing else", () => {
+    const added: Array<string> = [...SOURCE.matchAll(/ADD "(\w+)"/g)].map(
+      (match: RegExpMatchArray): string => {
+        return match[1] as string;
+      },
+    );
+    const dropped: Array<string> = [
+      ...SOURCE.matchAll(/DROP COLUMN "(\w+)"/g),
+    ].map((match: RegExpMatchArray): string => {
+      return match[1] as string;
+    });
+
+    expect(added.sort()).toEqual(dropped.sort());
+  });
+
+  test("the index and the constraint are dropped too", () => {
+    expect(SOURCE).toContain(
+      `DROP INDEX "public"."IDX_01752cd47b773df38b4a54ae53"`,
+    );
+    expect(SOURCE).toContain(
+      `DROP CONSTRAINT "FK_01752cd47b773df38b4a54ae539"`,
+    );
+  });
+
+  /*
+   * A stray semicolon would split one queryRunner.query() into two.
+   *
+   * Trailing whitespace is tolerated on purpose: TypeORM's generator ends
+   * a CREATE INDEX with no WHERE clause in a single space, and this file
+   * is generated. Normalising it here would mean the checked-in SQL no
+   * longer matched what `npm run generate-postgres-migration` produces,
+   * and the next person to regenerate would see a spurious diff. Newlines
+   * are a different matter — one inside a statement means the template
+   * literal wrapped, and that is worth catching.
+   */
+  test("every statement is a complete, single statement", () => {
+    for (const statement of [
+      ...SOURCE.matchAll(/`((?:ALTER TABLE|CREATE INDEX|DROP INDEX)[^`]+)`/g),
+    ]) {
+      expect(statement[1]).not.toContain(";");
+      expect(statement[1]).not.toContain("\n");
+      expect(statement[1]!.trimStart()).toBe(statement[1]);
+    }
+  });
+});
+
+describe("the migration runs", () => {
+  test("it is registered", () => {
+    const index: string = fs.readFileSync(
+      path.join(path.dirname(MIGRATION_PATH), "Index.ts"),
+      "utf8",
+    );
+
+    expect(index).toContain(
+      'from "./1787400000000-AddDeviceRoleAndDeclaredLinkParent"',
+    );
+    expect(index).toContain("AddDeviceRoleAndDeclaredLinkParent1787400000000,");
+  });
+
+  /*
+   * ...and registered for real, not just mentioned in the file: an import
+   * that never reaches the default-export array leaves the migration
+   * unregistered, and it silently never runs.
+   */
+  test("it is in the exported migration list", () => {
+    expect(SchemaMigrations).toContain(
+      AddDeviceRoleAndDeclaredLinkParent1787400000000,
+    );
+  });
+
+  /*
+   * TypeORM records applied migrations by the `name` property, not the file
+   * name. A mismatch re-runs the migration on every boot.
+   */
+  test("its declared name matches its class name", () => {
+    expect(new AddDeviceRoleAndDeclaredLinkParent1787400000000().name).toBe(
+      "AddDeviceRoleAndDeclaredLinkParent1787400000000",
+    );
+  });
+
+  // The guard described in the header. Hand it to the next migration.
+  test("its timestamp sorts after every other registered migration", () => {
+    const ourTimestamp: number | null = timestampOf(
+      AddDeviceRoleAndDeclaredLinkParent1787400000000,
+    );
+
+    expect(ourTimestamp).not.toBeNull();
+
+    const otherTimestamps: Array<number> = [];
+
+    for (const migrationClass of SchemaMigrations) {
+      if (migrationClass === AddDeviceRoleAndDeclaredLinkParent1787400000000) {
+        continue;
+      }
+
+      const timestamp: number | null = timestampOf(
+        migrationClass as MigrationClass,
+      );
+
+      if (timestamp !== null) {
+        otherTimestamps.push(timestamp);
+      }
+    }
+
+    /*
+     * Math.max() of an empty list is -Infinity, which every timestamp beats.
+     * Prove the list was actually enumerated before leaning on the maximum.
+     */
+    expect(otherTimestamps.length).toBeGreaterThan(100);
+
+    expect(ourTimestamp).toBeGreaterThan(Math.max(...otherTimestamps));
+  });
+
+  test("it is registered last, matching that timestamp", () => {
+    expect(SchemaMigrations[SchemaMigrations.length - 1]).toBe(
+      AddDeviceRoleAndDeclaredLinkParent1787400000000,
+    );
+  });
+
+  /*
+   * ...and the timestamp in the class name is the one on disk. A class
+   * renamed without renaming its file (or two migrations landing on the
+   * same timestamp) leaves the ordering above asserting something that is
+   * not what actually runs.
+   */
+  test("exactly one file on disk carries its timestamp, and it is this one", () => {
+    const directory: string = path.dirname(MIGRATION_PATH);
+    const matching: Array<string> = fs
+      .readdirSync(directory)
+      .filter((file: string): boolean => {
+        return file.startsWith("1787400000000-");
+      });
+
+    expect(matching).toEqual([
+      "1787400000000-AddDeviceRoleAndDeclaredLinkParent.ts",
+    ]);
+  });
+});

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

@@ -444,10 +444,31 @@ describe("the migration runs", () => {
     );
   });
 
-  test("it is appended last, matching its timestamp", () => {
-    expect(SchemaMigrations[SchemaMigrations.length - 1]).toBe(
+  /*
+   * Registered in timestamp order relative to whatever follows it.
+   *
+   * This asserted "it is last in the array" until a second migration was
+   * added behind it, which is a thing that happens to every migration
+   * exactly once and is not what the test was ever about. The invariant
+   * worth holding is the one the "matching its timestamp" half named:
+   * nothing registered AFTER this may carry an earlier timestamp, because
+   * the array is how a reader works out what runs when. A newly generated
+   * migration carries a wall-clock timestamp, which can easily fall below
+   * the hand-picked round numbers the recent ones use — appending it
+   * without renumbering is how the two orders drift apart.
+   */
+  test("nothing registered after it carries an earlier timestamp", () => {
+    const position: number = SchemaMigrations.indexOf(
       AddEpisodeMemberNotifyIndexes1787300000000,
     );
+    expect(position).toBeGreaterThan(-1);
+
+    for (const migration of SchemaMigrations.slice(position + 1)) {
+      const timestamp: number = Number(
+        (migration.name.match(/(\d+)$/) || [])[1],
+      );
+      expect(timestamp).toBeGreaterThan(1787300000000);
+    }
   });
 
   /*
@@ -461,34 +482,41 @@ describe("the migration runs", () => {
   });
 
   /*
-   * Migrations execute in timestamp order, and TypeORM will not re-order an
-   * already-applied set: a migration added with a timestamp below one that
-   * has already run is simply skipped on every existing deployment, so the
-   * index never appears in production and only ever shows up on fresh
-   * installs. Both sides of the comparison are therefore read off the
-   * registered classes themselves — rename this migration to a lower
-   * timestamp, or land another one above it, and this fails.
+   * Migrations execute in timestamp order, so one landing BELOW a migration
+   * that has already run applies out of order — and on a fresh install runs
+   * in a different order than it did in production, which is how a schema
+   * that passes drift locally still diverges between deployments.
+   *
+   * This used to read "above every OTHER registered migration", i.e. that
+   * this was the newest. That guard belongs to whichever migration is
+   * currently newest — see
+   * DeviceRoleAndDeclaredLinkParentMigration.test.ts, which now carries it
+   * — and it cannot live here, because it fails by design the moment
+   * anything lands above it. What is permanently true of this migration,
+   * and is the half that protects an existing deployment, is that nothing
+   * registered BEFORE it carries a later timestamp.
    */
-  test("its timestamp sorts after every other registered migration", () => {
+  test("its timestamp sorts after every migration registered before it", () => {
     const ourTimestamp: number | null = timestampOf(
       AddEpisodeMemberNotifyIndexes1787300000000,
     );
 
     expect(ourTimestamp).not.toBeNull();
 
-    const otherTimestamps: Array<number> = [];
+    const position: number = SchemaMigrations.indexOf(
+      AddEpisodeMemberNotifyIndexes1787300000000,
+    );
+    expect(position).toBeGreaterThan(-1);
 
-    for (const migrationClass of SchemaMigrations) {
-      if (migrationClass === AddEpisodeMemberNotifyIndexes1787300000000) {
-        continue;
-      }
+    const earlierTimestamps: Array<number> = [];
 
+    for (const migrationClass of SchemaMigrations.slice(0, position)) {
       const timestamp: number | null = timestampOf(
         migrationClass as MigrationClass,
       );
 
       if (timestamp !== null) {
-        otherTimestamps.push(timestamp);
+        earlierTimestamps.push(timestamp);
       }
     }
 
@@ -497,9 +525,9 @@ describe("the migration runs", () => {
      * Prove the list was actually enumerated before leaning on the maximum,
      * or the assertion below is vacuous again.
      */
-    expect(otherTimestamps.length).toBeGreaterThan(100);
+    expect(earlierTimestamps.length).toBeGreaterThan(100);
 
-    expect(ourTimestamp).toBeGreaterThan(Math.max(...otherTimestamps));
+    expect(ourTimestamp).toBeGreaterThan(Math.max(...earlierTimestamps));
   });
 
   /*