@oneuptime/common 12.0.29 → 12.0.31

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

@@ -0,0 +1,394 @@
+import { AddOnCallCalendarFeeds1790400000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1790400000000-AddOnCallCalendarFeeds";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { MigrationInterface, QueryRunner } from "typeorm";
+import fs from "fs";
+import path from "path";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+
+/*
+ * The migration was generated by TypeORM against a fully migrated throwaway
+ * database, so the SQL itself is not hand-written - but what it contains is
+ * still worth pinning: that it creates exactly the five tables and the one
+ * column this feature adds and nothing else (a generator pointed at a
+ * drifted database happily emits DROP TABLE for half the schema), that the
+ * uniqueness rules the services rely on exist at the database, that rows
+ * cascade away with the things they belong to, and that down() undoes all of
+ * it.
+ */
+
+const MIGRATION_NAME: string = "AddOnCallCalendarFeeds1790400000000";
+
+const NEW_TABLES: Array<string> = [
+  "UserOnCallCalendarFeed",
+  "OnCallDutyPolicyScheduleCalendarFeed",
+  "ProjectOnCallCalendarFeed",
+  "UserOnCallShiftReminder",
+  "UserOnCallShiftReminderLog",
+];
+
+const FEED_TABLES: Array<string> = [
+  "UserOnCallCalendarFeed",
+  "OnCallDutyPolicyScheduleCalendarFeed",
+  "ProjectOnCallCalendarFeed",
+];
+
+type MigrationClass = new () => MigrationInterface;
+
+async function run(direction: "up" | "down"): Promise<Array<string>> {
+  const queries: Array<string> = [];
+
+  const runner: QueryRunner = {
+    query: async (sql: string): Promise<void> => {
+      queries.push(sql);
+    },
+  } as unknown as QueryRunner;
+
+  const migration: AddOnCallCalendarFeeds1790400000000 =
+    new AddOnCallCalendarFeeds1790400000000();
+
+  if (direction === "up") {
+    await migration.up(runner);
+  } else {
+    await migration.down(runner);
+  }
+
+  return queries;
+}
+
+function createTableStatement(queries: Array<string>, table: string): string {
+  const statement: string | undefined = queries.find((sql: string) => {
+    return sql.startsWith(`CREATE TABLE "${table}" (`);
+  });
+
+  if (!statement) {
+    throw new Error(`No CREATE TABLE for ${table}`);
+  }
+
+  return statement;
+}
+
+// "IDX_..." index names created in up(); the same names must be dropped in down().
+function indexNames(queries: Array<string>): Array<string> {
+  return queries
+    .map((sql: string) => {
+      const match: RegExpMatchArray | null = sql.match(
+        /CREATE (?:UNIQUE )?INDEX "([^"]+)"/,
+      );
+      return match ? match[1]! : null;
+    })
+    .filter((name: string | null): name is string => {
+      return name !== null;
+    });
+}
+
+// Every table name a statement touches, in any position.
+function tablesMentioned(sql: string): Array<string> {
+  return [
+    ...new Set(
+      [...sql.matchAll(/(?:TABLE|ON|REFERENCES) "([A-Za-z]+)"/g)].map(
+        (match: RegExpMatchArray) => {
+          return match[1]!;
+        },
+      ),
+    ),
+  ];
+}
+
+let up: Array<string> = [];
+let down: Array<string> = [];
+
+beforeAll(async () => {
+  up = await run("up");
+  down = await run("down");
+});
+
+describe("AddOnCallCalendarFeeds migration", () => {
+  test("names itself after its timestamp, in the class and the recorded name", () => {
+    const migration: AddOnCallCalendarFeeds1790400000000 =
+      new AddOnCallCalendarFeeds1790400000000();
+
+    expect(AddOnCallCalendarFeeds1790400000000.name).toBe(MIGRATION_NAME);
+    expect(migration.name).toBe(MIGRATION_NAME);
+  });
+
+  /*
+   * Registered ONCE, and after everything older than it.
+   *
+   * This used to assert it was the last entry in the array, which was true on
+   * the day it was written and false the moment anybody added a migration —
+   * an assertion every future PR has to edit is a tripwire, not a guard. The
+   * property actually worth holding is that this migration sits in ascending
+   * timestamp order and is not registered twice, which is what breaks
+   * migration runs. (SchemaMigrationsOrdering.test.ts holds the same rule for
+   * the array as a whole.)
+   */
+  test("is registered exactly once, after every migration older than it", () => {
+    const registered: Array<MigrationClass> =
+      SchemaMigrations as Array<MigrationClass>;
+
+    const occurrences: Array<MigrationClass> = registered.filter(
+      (migration: MigrationClass) => {
+        return migration === AddOnCallCalendarFeeds1790400000000;
+      },
+    );
+    expect(occurrences).toHaveLength(1);
+
+    const index: number = registered.indexOf(
+      AddOnCallCalendarFeeds1790400000000,
+    );
+    expect(index).toBeGreaterThan(-1);
+
+    const timestampOf: (migration: MigrationClass) => number = (
+      migration: MigrationClass,
+    ): number => {
+      const match: RegExpMatchArray | null = migration.name.match(/(\d+)$/);
+      return match ? parseInt(match[1]!, 10) : 0;
+    };
+
+    for (let before: number = 0; before < index; before++) {
+      expect(timestampOf(registered[before]!)).toBeLessThan(1790400000000);
+    }
+  });
+
+  test("is backed by exactly one file carrying the same timestamp", () => {
+    const directory: string = path.join(
+      __dirname,
+      "../../../../Server/Infrastructure/Postgres/SchemaMigrations",
+    );
+
+    const files: Array<string> = fs
+      .readdirSync(directory)
+      .filter((file: string) => {
+        return file.startsWith("1790400000000-");
+      });
+
+    expect(files).toEqual(["1790400000000-AddOnCallCalendarFeeds.ts"]);
+  });
+
+  test("creates exactly the five new tables", () => {
+    const created: Array<string> = up
+      .map((sql: string) => {
+        const match: RegExpMatchArray | null = sql.match(
+          /^CREATE TABLE "([A-Za-z]+)"/,
+        );
+        return match ? match[1]! : null;
+      })
+      .filter((name: string | null): name is string => {
+        return name !== null;
+      });
+
+    expect(created.sort()).toEqual([...NEW_TABLES].sort());
+  });
+
+  test("adds shiftConfigVersion to OnCallDutyPolicySchedule as NOT NULL DEFAULT 0", () => {
+    const statements: Array<string> = up.filter((sql: string) => {
+      return sql.startsWith('ALTER TABLE "OnCallDutyPolicySchedule"');
+    });
+
+    expect(statements).toHaveLength(1);
+    expect(statements[0]).toMatch(
+      /^ALTER TABLE "OnCallDutyPolicySchedule" ADD "shiftConfigVersion" integer NOT NULL DEFAULT '?0'?$/,
+    );
+  });
+
+  test("touches nothing outside the feature (no pre-existing drift smuggled in)", () => {
+    const allowed: Set<string> = new Set<string>([
+      ...NEW_TABLES,
+      "OnCallDutyPolicySchedule",
+      "Project",
+      "User",
+    ]);
+
+    for (const sql of [...up, ...down]) {
+      for (const table of tablesMentioned(sql)) {
+        expect({
+          sql: sql.slice(0, 80),
+          table,
+          allowed: allowed.has(table),
+        }).toEqual({ sql: sql.slice(0, 80), table, allowed: true });
+      }
+
+      /*
+       * Project / User / the schedule only ever appear as FK targets or
+       * as the one ALTER above - never as a table being created/dropped.
+       */
+      expect(sql).not.toMatch(/^(CREATE|DROP) TABLE "(Project|User)"/);
+      expect(sql).not.toMatch(/^DROP TABLE "OnCallDutyPolicySchedule"/);
+    }
+  });
+
+  test.each(FEED_TABLES)(
+    "%s stores a NOT NULL, UNIQUE token hash and a nullable encrypted token",
+    (table: string) => {
+      const statement: string = createTableStatement(up, table);
+
+      expect(statement).toMatch(
+        /"tokenHash" character varying\(100\) NOT NULL/,
+      );
+      expect(statement).toMatch(/UNIQUE \("tokenHash"\)/);
+      expect(statement).toMatch(/"token" text,/);
+      expect(statement).toMatch(
+        /"previousTokenHash" character varying\(100\),/,
+      );
+      expect(statement).toMatch(
+        /"previousTokenExpiresAt" TIMESTAMP WITH TIME ZONE,/,
+      );
+      expect(statement).toMatch(/"isEnabled" boolean NOT NULL DEFAULT true/);
+      expect(statement).toMatch(/"pastDays" integer NOT NULL DEFAULT '?2'?/);
+      expect(statement).toMatch(/"futureDays" integer NOT NULL DEFAULT '?90'?/);
+      expect(statement).toMatch(/"fetchCount" integer NOT NULL DEFAULT '?0'?/);
+      expect(statement).toMatch(
+        /"lastRenderTruncated" boolean NOT NULL DEFAULT false/,
+      );
+    },
+  );
+
+  test("indexes previousTokenHash on every feed table (the grace-period lookup)", () => {
+    for (const table of FEED_TABLES) {
+      expect(
+        up.some((sql: string) => {
+          return new RegExp(
+            `^CREATE INDEX "IDX_[0-9a-f]+" ON "${table}" \\("previousTokenHash"\\) $`,
+          ).test(sql);
+        }),
+      ).toBe(true);
+    }
+  });
+
+  test("creates the uniqueness rules the services rely on", () => {
+    const uniqueIndexes: Array<string> = up.filter((sql: string) => {
+      return sql.startsWith("CREATE UNIQUE INDEX");
+    });
+
+    const expected: Array<[string, string]> = [
+      ["UserOnCallCalendarFeed", '("projectId", "userId")'],
+      [
+        "OnCallDutyPolicyScheduleCalendarFeed",
+        '("onCallDutyPolicyScheduleId")',
+      ],
+      ["ProjectOnCallCalendarFeed", '("projectId")'],
+      [
+        "UserOnCallShiftReminder",
+        '("projectId", "userId", "minutesBeforeShift")',
+      ],
+      [
+        "UserOnCallShiftReminderLog",
+        '("userId", "onCallDutyPolicyScheduleId", "shiftStartsAt", "minutesBeforeShift", "kind")',
+      ],
+    ];
+
+    for (const [table, columns] of expected) {
+      expect(
+        uniqueIndexes.some((sql: string) => {
+          return sql.includes(`ON "${table}" ${columns}`);
+        }),
+      ).toBe(true);
+    }
+
+    expect(uniqueIndexes).toHaveLength(expected.length);
+  });
+
+  test("rows cascade away with their project, user and schedule; creators are kept informationally", () => {
+    const cascades: Array<[string, string, string]> = [
+      ["UserOnCallCalendarFeed", "projectId", "Project"],
+      ["UserOnCallCalendarFeed", "userId", "User"],
+      ["OnCallDutyPolicyScheduleCalendarFeed", "projectId", "Project"],
+      [
+        "OnCallDutyPolicyScheduleCalendarFeed",
+        "onCallDutyPolicyScheduleId",
+        "OnCallDutyPolicySchedule",
+      ],
+      ["ProjectOnCallCalendarFeed", "projectId", "Project"],
+      ["UserOnCallShiftReminder", "projectId", "Project"],
+      ["UserOnCallShiftReminder", "userId", "User"],
+      ["UserOnCallShiftReminderLog", "projectId", "Project"],
+      ["UserOnCallShiftReminderLog", "userId", "User"],
+      [
+        "UserOnCallShiftReminderLog",
+        "onCallDutyPolicyScheduleId",
+        "OnCallDutyPolicySchedule",
+      ],
+    ];
+
+    for (const [table, column, target] of cascades) {
+      expect(
+        up.some((sql: string) => {
+          return (
+            sql.startsWith(`ALTER TABLE "${table}" ADD CONSTRAINT`) &&
+            sql.includes(
+              `FOREIGN KEY ("${column}") REFERENCES "${target}"("_id") ON DELETE CASCADE`,
+            )
+          );
+        }),
+      ).toBe(true);
+    }
+
+    for (const table of [
+      "OnCallDutyPolicyScheduleCalendarFeed",
+      "ProjectOnCallCalendarFeed",
+    ]) {
+      expect(
+        up.some((sql: string) => {
+          return (
+            sql.startsWith(`ALTER TABLE "${table}" ADD CONSTRAINT`) &&
+            sql.includes(
+              'FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL',
+            )
+          );
+        }),
+      ).toBe(true);
+    }
+  });
+
+  test("the reminder log's key columns are NOT NULL and its lead defaults to 0", () => {
+    const statement: string = createTableStatement(
+      up,
+      "UserOnCallShiftReminderLog",
+    );
+
+    expect(statement).toMatch(
+      /"shiftStartsAt" TIMESTAMP WITH TIME ZONE NOT NULL/,
+    );
+    expect(statement).toMatch(
+      /"minutesBeforeShift" integer NOT NULL DEFAULT '?0'?/,
+    );
+    expect(statement).toMatch(/"kind" character varying\(100\) NOT NULL/);
+    expect(statement).toMatch(/"claimedAt" TIMESTAMP WITH TIME ZONE NOT NULL/);
+    expect(statement).toMatch(/"sentAt" TIMESTAMP WITH TIME ZONE,/);
+  });
+
+  test("down() drops every table, every index and the column that up() created", () => {
+    for (const table of NEW_TABLES) {
+      expect(down).toContain(`DROP TABLE "${table}"`);
+    }
+
+    expect(down).toContain(
+      'ALTER TABLE "OnCallDutyPolicySchedule" DROP COLUMN "shiftConfigVersion"',
+    );
+
+    const created: Array<string> = indexNames(up);
+    expect(created.length).toBeGreaterThan(0);
+
+    for (const name of created) {
+      expect(down).toContain(`DROP INDEX "public"."${name}"`);
+    }
+
+    // And nothing in down() creates anything.
+    expect(
+      down.filter((sql: string) => {
+        return sql.startsWith("CREATE");
+      }),
+    ).toEqual([]);
+  });
+
+  test("the file carries no hand-written SQL names (every constraint id is a TypeORM hash)", () => {
+    for (const sql of up) {
+      for (const match of sql.matchAll(/CONSTRAINT "([^"]+)"/g)) {
+        expect(match[1]).toMatch(/^(PK|UQ|FK)_[0-9a-f]{27,}$/);
+      }
+      for (const match of sql.matchAll(/INDEX "([^"]+)"/g)) {
+        expect(match[1]).toMatch(/^IDX_[0-9a-f]{26,}$/);
+      }
+    }
+  });
+});