@oneuptime/common 12.0.13 → 12.0.14

package/Tests/Server/Services/AddNetworkDeviceReachabilityColumnsMigration.test.ts

@@ -27,15 +27,11 @@ import { describe, expect, test } from "@jest/globals";
  *
  * Pure SQL-contract assertions against a fake QueryRunner. No Postgres.
  *
- * This file also carries the ORDERING guard, handed on from
- * DeviceRoleAndDeclaredLinkParentMigration.test.ts: this is the newest
- * registered migration, so its timestamp must sort above every other one.
- * `generate-postgres-migration` stamps a WALL-CLOCK timestamp, while the
- * recent migrations here use hand-picked round numbers that already run
- * ahead of it — so a generated file lands BELOW several registered
- * migrations unless somebody renumbers it, and runs out of order without
- * anything saying so. Whoever adds the next migration should move this
- * block to theirs.
+ * This file used to carry the ORDERING guard. It has moved on to
+ * FixTotpOtpUrlAlgorithmMigration.test.ts, which is the newest registered
+ * migration — the guard only says anything while it sits on the newest one.
+ * What stays here is the file-on-disk check, which is about THIS migration
+ * and stays true forever.
  */
 
 const MIGRATION_DIRECTORY: string = path.join(
@@ -45,15 +41,6 @@ const MIGRATION_DIRECTORY: string = path.join(
 
 const MIGRATION_TIMESTAMP: string = "1787600000000";
 
-interface MigrationClass {
-  name: string;
-}
-
-function timestampOf(migrationClass: MigrationClass): number | null {
-  const match: RegExpMatchArray | null = migrationClass.name.match(/(\d+)$/);
-  return match ? Number(match[1]) : null;
-}
-
 type MakeQueryRunnerResult = {
   runner: QueryRunner;
   statements: Array<string>;
@@ -237,51 +224,12 @@ describe("registration", () => {
   });
 });
 
-// The guard described in the header. Hand it to the next migration.
-describe("ordering", () => {
-  test("its timestamp sorts after every other registered migration", () => {
-    const ourTimestamp: number | null = timestampOf(
-      AddNetworkDeviceReachabilityColumns1787600000000,
-    );
-
-    expect(ourTimestamp).not.toBeNull();
-
-    const otherTimestamps: Array<number> = [];
-
-    for (const migrationClass of SchemaMigrations) {
-      if (migrationClass === AddNetworkDeviceReachabilityColumns1787600000000) {
-        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(
-      AddNetworkDeviceReachabilityColumns1787600000000,
-    );
-  });
-
+describe("identity on disk", () => {
   /*
-   * ...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.
+   * 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 — makes the registered ordering describe something that is not
+   * what actually runs.
    */
   test("exactly one file on disk carries its timestamp, and it is this one", () => {
     const matching: Array<string> = fs

package/Tests/Server/Services/AnalyticsDatabasePaginationStability.test.ts

@@ -314,6 +314,35 @@ describe("AnalyticsDatabaseService pagination stability", () => {
       jest.restoreAllMocks();
     });
 
+    /*
+     * The sort-key boundary filter (toSortKeyBoundaryFilter) puts its own
+     * `ORDER BY <key> LIMIT n` in a subquery inside the WHERE, so the
+     * statement now carries two. The tiebreaker lives on the LAST one —
+     * the outer sort that actually orders the page.
+     */
+    const outerOrderBy: (query: string) => string = (query: string): string => {
+      return query
+        .slice(query.lastIndexOf("ORDER BY "))
+        .replace("ORDER BY ", "")
+        .split(" LIMIT")[0]!;
+    };
+
+    /*
+     * Resolves the rendered `{pN:Identifier}` terms of an ORDER BY back to
+     * the column names they are bound to, so the assertions do not depend
+     * on parameter numbering.
+     */
+    const orderByColumns: (statement: Statement) => Array<string> = (
+      statement: Statement,
+    ): Array<string> => {
+      return outerOrderBy(statement.query)
+        .split(", ")
+        .map((term: string): string => {
+          const param: string = term.split(":")[0]!.replace("{", "");
+          return statement.query_params[param] as string;
+        });
+    };
+
     /*
      * The generator is NOT mocked here, so this asserts the real ORDER BY
      * text — the separator fix and the tiebreaker together.
@@ -328,13 +357,10 @@ describe("AnalyticsDatabaseService pagination stability", () => {
         skip: 100,
       } as never);
 
-      expect(statement.query).toContain(
-        "ORDER BY {p2:Identifier} DESC, {p3:Identifier} DESC",
+      expect(outerOrderBy(statement.query)).toMatch(
+        /^\{p\d+:Identifier\} DESC, \{p\d+:Identifier\} DESC$/,
       );
-      expect(statement.query_params).toMatchObject({
-        p2: TIME_COLUMN,
-        p3: "_id",
-      });
+      expect(orderByColumns(statement)).toStrictEqual([TIME_COLUMN, "_id"]);
     });
 
     test("the ORDER BY ends with _id, immediately before LIMIT", () => {
@@ -347,13 +373,7 @@ describe("AnalyticsDatabaseService pagination stability", () => {
         skip: 0,
       } as never);
 
-      const orderBy: string = statement.query
-        .split("ORDER BY ")[1]!
-        .split(" LIMIT")[0]!;
-      const lastTerm: string = orderBy.split(", ").pop()!;
-      const lastParam: string = lastTerm.split(":")[0]!.replace("{", "");
-
-      expect(statement.query_params[lastParam]).toBe("_id");
+      expect(orderByColumns(statement).pop()).toBe("_id");
     });
   });