@oneuptime/common 13.0.5 → 13.0.7

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

@@ -15,24 +15,33 @@ import yaml from "js-yaml";
  * network_mode: host and no ClickHouse settings, the stacks CI starts publish
  * no ClickHouse port, and every e2e job on master failed in beforeAll. So:
  *
- *  - production compose files publish no ClickHouse port at all;
+ *  - production compose files publish no ClickHouse port at all, and neither
+ *    does the SaaS CI stack's billing overlay;
  *  - the test-only overlay publishes ClickHouse HTTP on loopback only, on the
- *    host port docker-compose.dev.yml uses and the fixture maps to;
+ *    host port Scripts/Dev/docker-compose.dev.yml uses and the fixture maps to;
  *  - the host-networked e2e service receives the connection settings;
  *  - every workflow job that runs the e2e service starts its stack with the
  *    overlay (the release workflow is where a partial fix would slip through,
  *    since it only runs when a release is cut).
+ *
+ * The overlays live in packages/E2E but their paths are relative to the repo
+ * root, which holds only while each command passes them after
+ * `-f docker-compose.yml`. That is guarded here too.
  */
 
-const REPO_ROOT: string = path.resolve(__dirname, "../../../..");
+const REPO_ROOT: string = path.resolve(__dirname, "../../../../..");
 const WORKFLOWS_DIRECTORY: string = path.join(
   REPO_ROOT,
   ".github",
   "workflows",
 );
-const OVERLAY_FILE_NAME: string = "docker-compose.e2e-clickhouse.yml";
+const OVERLAY_FILE_NAME: string =
+  "packages/E2E/docker-compose.e2e-clickhouse.yml";
+const BILLING_OVERLAY_FILE_NAME: string =
+  "packages/E2E/docker-compose.billing.yml";
 const FIXTURE_PATH: string = path.join(
   REPO_ROOT,
+  "packages",
   "E2E",
   "Tests",
   "Dashboard",
@@ -43,7 +52,6 @@ const FIXTURE_PATH: string = path.join(
 const PRODUCTION_COMPOSE_FILES: Array<string> = [
   "docker-compose.base.yml",
   "docker-compose.yml",
-  "docker-compose.billing.yml",
 ];
 
 const CLICKHOUSE_CONNECTION_SETTINGS: Array<string> = [
@@ -56,10 +64,17 @@ const CLICKHOUSE_CONNECTION_SETTINGS: Array<string> = [
 
 const CLICKHOUSE_HTTP_CONTAINER_PORT: string = "8123";
 
-// The step that runs the suite: `docker compose -f docker-compose.dev.yml up ... e2e`.
+/*
+ * The step that runs the suite:
+ * `docker compose --project-directory . -f Scripts/Dev/docker-compose.dev.yml up ... e2e`,
+ * or `... -f packages/E2E/docker-compose.e2e.yml up ... e2e` for the release image.
+ */
 const RUNS_E2E_SERVICE: RegExp =
-  /docker compose\s[^\n]*-f docker-compose\.(?:dev|e2e)\.yml\s+up\b[^\n]*\se2e\b/;
+  /docker compose\s[^\n]*-f (?:Scripts\/Dev\/docker-compose\.dev|packages\/E2E\/docker-compose\.e2e)\.yml\s+up\b[^\n]*\se2e\b/;
 const UP_SUBCOMMAND: RegExp = /\sup(?:\s|$)/;
+const DOWN_SUBCOMMAND: RegExp = /\sdown(?:\s|$)/;
+const ROOT_COMPOSE_FILE_FLAG: RegExp = /-f docker-compose\.yml\s/;
+const E2E_OVERLAY_FLAG: string = "-f packages/E2E/docker-compose.";
 const WORKFLOW_FILE: RegExp = /\.ya?ml$/;
 const FIXTURE_LOCAL_PORT: RegExp =
   /LOCAL_CLICKHOUSE_HTTP_PORT: string = "(\d+)"/;
@@ -87,6 +102,11 @@ interface WorkflowFile {
   jobs?: Record<string, WorkflowJob>;
 }
 
+interface WorkflowJobRun {
+  job: string;
+  runText: string;
+}
+
 interface PublishedPort {
   hostIp: string;
   hostPort: string;
@@ -128,6 +148,34 @@ function clickHouseHttpHostPort(compose: ComposeFile): string | undefined {
     })?.hostPort;
 }
 
+// Every workflow job, with the run scripts of its steps joined.
+function readWorkflowJobRuns(): Array<WorkflowJobRun> {
+  const jobRuns: Array<WorkflowJobRun> = [];
+
+  for (const fileName of fs.readdirSync(WORKFLOWS_DIRECTORY).sort()) {
+    if (!WORKFLOW_FILE.test(fileName)) {
+      continue;
+    }
+
+    const workflow: WorkflowFile = readYaml<WorkflowFile>(
+      path.join(WORKFLOWS_DIRECTORY, fileName),
+    );
+
+    for (const [jobName, job] of Object.entries(workflow.jobs || {})) {
+      jobRuns.push({
+        job: `${fileName}#${jobName}`,
+        runText: (job.steps || [])
+          .map((step: WorkflowStep) => {
+            return step.run || "";
+          })
+          .join("\n"),
+      });
+    }
+  }
+
+  return jobRuns;
+}
+
 function startsStackWithOverlay(runText: string): boolean {
   return runText.split("\n").some((line: string) => {
     return (
@@ -149,6 +197,13 @@ describe("E2E ClickHouse fixture access", () => {
     },
   );
 
+  test("the billing overlay leaves ClickHouse to docker-compose.yml, so the SaaS stack publishes no port either", () => {
+    const overlay: ComposeFile = readCompose(BILLING_OVERLAY_FILE_NAME);
+
+    expect(overlay.services?.["home"]).toBeDefined();
+    expect(overlay.services?.["clickhouse"]).toBeUndefined();
+  });
+
   test("the overlay publishes only ClickHouse HTTP, and only on loopback", () => {
     const overlay: ComposeFile = readCompose(OVERLAY_FILE_NAME);
 
@@ -174,9 +229,9 @@ describe("E2E ClickHouse fixture access", () => {
     expect(clickHouseHttpHostPort(readCompose(OVERLAY_FILE_NAME))).toBe(
       fixturePort,
     );
-    expect(clickHouseHttpHostPort(readCompose("docker-compose.dev.yml"))).toBe(
-      fixturePort,
-    );
+    expect(
+      clickHouseHttpHostPort(readCompose("Scripts/Dev/docker-compose.dev.yml")),
+    ).toBe(fixturePort);
   });
 
   test("the host-networked e2e service receives the fixture's ClickHouse settings", () => {
@@ -201,30 +256,14 @@ describe("E2E ClickHouse fixture access", () => {
     const e2eJobs: Array<string> = [];
     const jobsWithoutOverlay: Array<string> = [];
 
-    for (const fileName of fs.readdirSync(WORKFLOWS_DIRECTORY).sort()) {
-      if (!WORKFLOW_FILE.test(fileName)) {
+    for (const { job, runText } of readWorkflowJobRuns()) {
+      if (!RUNS_E2E_SERVICE.test(runText)) {
         continue;
       }
 
-      const workflow: WorkflowFile = readYaml<WorkflowFile>(
-        path.join(WORKFLOWS_DIRECTORY, fileName),
-      );
-
-      for (const [jobName, job] of Object.entries(workflow.jobs || {})) {
-        const runText: string = (job.steps || [])
-          .map((step: WorkflowStep) => {
-            return step.run || "";
-          })
-          .join("\n");
-
-        if (!RUNS_E2E_SERVICE.test(runText)) {
-          continue;
-        }
-
-        e2eJobs.push(`${fileName}#${jobName}`);
-        if (!startsStackWithOverlay(runText)) {
-          jobsWithoutOverlay.push(`${fileName}#${jobName}`);
-        }
+      e2eJobs.push(job);
+      if (!startsStackWithOverlay(runText)) {
+        jobsWithoutOverlay.push(job);
       }
     }
 
@@ -237,4 +276,40 @@ describe("E2E ClickHouse fixture access", () => {
     );
     expect(jobsWithoutOverlay).toEqual([]);
   });
+
+  /*
+   * A later -f resolves its paths against the first file's folder, so an
+   * overlay passed on its own looks for docker-compose.base.yml inside
+   * packages/E2E. And `down` on an overlay pair tears down the stack it sits
+   * on, volumes included, not just the overlay's service.
+   */
+  test("workflows pass packages/E2E compose overlays after docker-compose.yml, and never run down on them", () => {
+    const overlayCommands: Array<string> = [];
+    const misusedOverlayCommands: Array<string> = [];
+
+    for (const { job, runText } of readWorkflowJobRuns()) {
+      for (const line of runText.split("\n")) {
+        const overlayIndex: number = line.indexOf(E2E_OVERLAY_FLAG);
+
+        if (!line.includes("docker compose") || overlayIndex === -1) {
+          continue;
+        }
+
+        const command: string = `${job}: ${line.trim()}`;
+        const rootIndex: number = line.search(ROOT_COMPOSE_FILE_FLAG);
+
+        overlayCommands.push(command);
+        if (
+          rootIndex === -1 ||
+          rootIndex > overlayIndex ||
+          DOWN_SUBCOMMAND.test(line)
+        ) {
+          misusedOverlayCommands.push(command);
+        }
+      }
+    }
+
+    expect(overlayCommands.length).toBeGreaterThan(0);
+    expect(misusedOverlayCommands).toEqual([]);
+  });
 });

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

@@ -7,9 +7,9 @@ import path from "path";
  * Regression tests for "the quick start does not work on a fresh clone".
  *
  * `.gitignore` carries a repo-wide `**\/Dockerfile` rule. That rule is correct
- * for service images: `configure.sh` renders every `Dockerfile.tpl` through
- * gomplate at install time, so the rendered `Dockerfile` really is build
- * output and really should not be committed.
+ * for service images: `Scripts/Install/configure.sh` renders every
+ * `Dockerfile.tpl` through gomplate at install time, so the rendered
+ * `Dockerfile` really is build output and really should not be committed.
  *
  * It is wrong for `Examples/`, where the Dockerfiles are hand-written source.
  * `Examples/snmp-simulator/Dockerfile` was swallowed by it: `docker compose up
@@ -23,7 +23,7 @@ import path from "path";
  * it names is neither committed nor generated from something that is.
  */
 
-const REPO_ROOT: string = path.resolve(__dirname, "..", "..", "..", "..");
+const REPO_ROOT: string = path.resolve(__dirname, "..", "..", "..", "..", "..");
 
 // Where hand-written (as opposed to gomplate-rendered) Dockerfiles live.
 const EXAMPLES_DIR: string = "Examples";
@@ -34,6 +34,14 @@ const SNMP_SIMULATOR_DOCKERFILE: string = path.join(
   "Dockerfile",
 );
 
+/*
+ * The dev stack's compose file lives in Scripts/Dev but is always run from the
+ * repo root with `--project-directory .`, so compose resolves its build paths
+ * against the repo root instead of the file's own folder.
+ */
+const DEV_COMPOSE_FILE: string = "Scripts/Dev/docker-compose.dev.yml";
+const ROOT_PROJECT_COMPOSE_FILES: Array<string> = [DEV_COMPOSE_FILE];
+
 /*
  * Run a git command against the checkout under test. A failure here is a real
  * test failure and not something to swallow: the whole point of this file is to
@@ -46,6 +54,11 @@ const git: (args: Array<string>) => string = (args: Array<string>): string => {
       cwd: REPO_ROOT,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
+      /*
+       * `git ls-files` for the whole repository is over a megabyte, and
+       * execFileSync's default 1 MiB buffer fails it with ENOBUFS.
+       */
+      maxBuffer: 64 * 1024 * 1024,
     });
   } catch (err: unknown) {
     throw new Error(
@@ -136,7 +149,9 @@ const parseImageBuilds: (composeFile: string) => Array<ImageBuild> = (
   composeFile: string,
 ): Array<ImageBuild> => {
   const builds: Array<ImageBuild> = [];
-  const composeDir: string = path.dirname(composeFile);
+  const composeDir: string = ROOT_PROJECT_COMPOSE_FILES.includes(composeFile)
+    ? "."
+    : path.dirname(composeFile);
   const lines: Array<string> = readRepoFile(composeFile).split("\n");
 
   let inServices: boolean = false;
@@ -254,8 +269,9 @@ const imageBuilds: Array<ImageBuild> = composeFiles.flatMap(
 
 /*
  * A Dockerfile is reachable on a fresh clone if it is committed, or if
- * `configure.sh` renders it from a committed `Dockerfile.tpl` before anything
- * builds it. Anything else exists only on the machine that authored it.
+ * `Scripts/Install/configure.sh` renders it from a committed `Dockerfile.tpl`
+ * before anything builds it. Anything else exists only on the machine that
+ * authored it.
  */
 const templateFor: (dockerfile: string) => string = (
   dockerfile: string,
@@ -277,7 +293,7 @@ describe("Every Dockerfile a compose file builds survives a fresh clone", () =>
      * list is silently green -- the suite would keep passing while checking
      * nothing at all.
      */
-    expect(composeFiles).toContain("docker-compose.dev.yml");
+    expect(composeFiles).toContain(DEV_COMPOSE_FILE);
     expect(composeFiles).toContain(
       path
         .join(SNMP_SIMULATOR_DIR, "docker-compose.yml")
@@ -311,6 +327,22 @@ describe("Every Dockerfile a compose file builds survives a fresh clone", () =>
     },
   );
 
+  test("the dev compose file is run with the repo root as its project directory", () => {
+    /*
+     * Ties the build-path resolution above to the commands that run the file.
+     * Without the flag compose would resolve every build under Scripts/Dev.
+     */
+    const scripts: Record<string, string> = JSON.parse(
+      readRepoFile("package.json"),
+    ).scripts;
+
+    for (const script of ["build", "force-build", "dev"]) {
+      expect(scripts[script]).toContain(
+        `docker compose --project-directory . -f ${DEV_COMPOSE_FILE} `,
+      );
+    }
+  });
+
   test("the snmp-simulator quick start builds all three of its containers", () => {
     const builds: Array<ImageBuild> = imageBuilds.filter(
       (build: ImageBuild): boolean => {
@@ -398,8 +430,8 @@ describe("The .gitignore Dockerfile rules stay pointed at the right files", () =
       });
 
     expect(renderedDockerfiles.length).toBeGreaterThanOrEqual(10);
-    expect(renderedDockerfiles).toContain("App/Dockerfile");
-    expect(renderedDockerfiles).toContain("Probe/Dockerfile");
+    expect(renderedDockerfiles).toContain("packages/App/Dockerfile");
+    expect(renderedDockerfiles).toContain("packages/Probe/Dockerfile");
 
     for (const dockerfile of renderedDockerfiles) {
       expect({
@@ -435,13 +467,15 @@ describe("The .gitignore Dockerfile rules stay pointed at the right files", () =
     expect(templatesUnderExamples).toEqual([]);
   });
 
-  test("configure.sh is what renders the ignored Dockerfiles", () => {
+  test("Scripts/Install/configure.sh is what renders the ignored Dockerfiles", () => {
     /*
      * Ties the reasoning above to the code that makes it true. If the render
      * step moves or stops running over every template, the "ignored because
      * generated" justification stops holding and this file's premise is stale.
      */
-    const configureScript: string = readRepoFile("configure.sh");
+    const configureScript: string = readRepoFile(
+      path.join("Scripts", "Install", "configure.sh"),
+    );
 
     expect(configureScript).toContain('-name "Dockerfile.tpl"');
     expect(configureScript).toContain("gomplate");

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

@@ -10,6 +10,31 @@ const REMINDER_TABLES: ReadonlyArray<string> = [
   "ScheduledMaintenanceReminderRule",
 ];
 const NEVER_MATCH_PATTERN: string = "(?!)";
+
+/*
+ * Rule models registered AFTER this migration shipped. The expectations below
+ * are derived from the live registry, but a migration is a snapshot: it must
+ * never be edited to cover a table it predates (databases that already ran it
+ * would never see the change, and fresh ones would diverge from them). A new
+ * rule table created later gets its `criteria` column in its own CREATE TABLE
+ * and needs no legacy shadow trigger, because no older worker ever read it.
+ *
+ * Only ever append here, and only for a model whose table is created by a
+ * later migration.
+ */
+const RULE_MODELS_INTRODUCED_AFTER_MIGRATION: ReadonlyArray<string> = [
+  // 1793100000000-SloProductOverhaul
+  "ServiceLevelObjectiveMonitorRule",
+];
+
+type IsCoveredByMigrationFunction = (modelName: string) => boolean;
+
+const isCoveredByMigration: IsCoveredByMigrationFunction = (
+  modelName: string,
+): boolean => {
+  return !RULE_MODELS_INTRODUCED_AFTER_MIGRATION.includes(modelName);
+};
+
 const describePostgres: typeof describe.skip =
   process.env["RUN_POSTGRES_RULE_CRITERIA_MIGRATION_TESTS"] === "true"
     ? describe
@@ -54,10 +79,13 @@ function tablesMatching(
 }
 
 function expectedLegacyShadowMappings(): Array<readonly [string, string]> {
-  const registeredEntries: Array<[string, ReadonlyArray<string>]> =
+  const registeredEntries: Array<[string, ReadonlyArray<string>]> = (
     Object.entries(RULE_CRITERIA_FIELDS_BY_MODEL) as Array<
       [string, ReadonlyArray<string>]
-    >;
+    >
+  ).filter(([tableName]: [string, ReadonlyArray<string>]): boolean => {
+    return isCoveredByMigration(tableName);
+  });
 
   return registeredEntries.flatMap(
     ([tableName, fields]: [string, ReadonlyArray<string>]): Array<
@@ -134,7 +162,9 @@ describe("AddConfigurableRuleCriteria migration", () => {
     const downStatements: Array<string> = await queriesFor("down");
     const registeredModels: Array<string> = Object.keys(
       RULE_CRITERIA_FIELDS_BY_MODEL,
-    ).sort();
+    )
+      .filter(isCoveredByMigration)
+      .sort();
 
     const addedTables: Array<string> = tablesMatching(
       upStatements,

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

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import { MigrationInterface, QueryRunner } from "typeorm";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { AddDataResidencyToProject1793300000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1793300000000-AddDataResidencyToProject";
+
+/*
+ * The migration behind Project.dataResidency.
+ *
+ * The statements are EXECUTED against a fake QueryRunner rather than read as
+ * text, so up() and down() are told apart - a migration whose up() dropped the
+ * column would satisfy a `toContain` on the file. Beyond the SQL, the
+ * migration has to be registered, named consistently, and ordered after every
+ * migration already registered, or it silently never runs (or runs in a
+ * different order on fresh installs than on upgraded ones).
+ */
+
+const MIGRATION_TIMESTAMP: string = "1793300000000";
+
+const MIGRATION_BASE_NAME: string = "AddDataResidencyToProject";
+
+const MIGRATION_FILE_NAME: string = `${MIGRATION_TIMESTAMP}-${MIGRATION_BASE_NAME}.ts`;
+
+const MIGRATION_CLASS_NAME: string = `${MIGRATION_BASE_NAME}${MIGRATION_TIMESTAMP}`;
+
+const MIGRATION_DIRECTORY: string = path.join(
+  __dirname,
+  "../../../../Server/Infrastructure/Postgres/SchemaMigrations",
+);
+
+const ADD_SQL: string = `ALTER TABLE "Project" ADD "dataResidency" character varying(100)`;
+
+const DROP_SQL: string = `ALTER TABLE "Project" DROP COLUMN "dataResidency"`;
+
+const CLASS_TIMESTAMP: RegExp = /(\d{13})$/;
+
+type MakeQueryRunnerResult = {
+  runner: QueryRunner;
+  statements: Array<string>;
+};
+
+type MakeQueryRunnerFunction = () => MakeQueryRunnerResult;
+
+const makeQueryRunner: MakeQueryRunnerFunction = (): MakeQueryRunnerResult => {
+  const statements: Array<string> = [];
+
+  const query: (...args: Array<unknown>) => Promise<undefined> = (
+    ...args: Array<unknown>
+  ): Promise<undefined> => {
+    statements.push(String(args[0]));
+    return Promise.resolve(undefined);
+  };
+
+  return {
+    runner: { query } as unknown as QueryRunner,
+    statements,
+  };
+};
+
+async function upStatements(): Promise<Array<string>> {
+  const { runner, statements } = makeQueryRunner();
+  await new AddDataResidencyToProject1793300000000().up(runner);
+  return statements;
+}
+
+async function downStatements(): Promise<Array<string>> {
+  const { runner, statements } = makeQueryRunner();
+  await new AddDataResidencyToProject1793300000000().down(runner);
+  return statements;
+}
+
+describe("executing it", () => {
+  test("up() adds exactly the one column and does nothing else", async () => {
+    expect(await upStatements()).toEqual([ADD_SQL]);
+  });
+
+  test("down() drops exactly that column and nothing else", async () => {
+    expect(await downStatements()).toEqual([DROP_SQL]);
+  });
+
+  /*
+   * No backfill: every existing project is "not set", which is NULL, which
+   * is what ADD COLUMN without a default already gives them.
+   */
+  test("it does not backfill, set a default, or build an index", async () => {
+    for (const statement of [
+      ...(await upStatements()),
+      ...(await downStatements()),
+    ]) {
+      expect(statement).not.toContain("UPDATE");
+      expect(statement).not.toContain("DEFAULT");
+      expect(statement).not.toContain("INDEX");
+      expect(statement).not.toContain("NOT NULL");
+    }
+  });
+
+  test("every statement is a complete, single statement", async () => {
+    const statements: Array<string> = [
+      ...(await upStatements()),
+      ...(await downStatements()),
+    ];
+
+    expect(statements).toHaveLength(2);
+
+    for (const statement of statements) {
+      expect(statement).not.toContain(";");
+      expect(statement).not.toContain("\n");
+      expect(statement.trim()).toBe(statement);
+    }
+  });
+
+  test("is a MigrationInterface whose two steps are still named up and down", () => {
+    const migration: MigrationInterface =
+      new AddDataResidencyToProject1793300000000();
+
+    expect(typeof migration.up).toBe("function");
+    expect(typeof migration.down).toBe("function");
+    expect(
+      Object.getOwnPropertyNames(
+        AddDataResidencyToProject1793300000000.prototype,
+      ).sort(),
+    ).toEqual(["constructor", "down", "up"]);
+  });
+});
+
+describe("the migration runs", () => {
+  test("it is imported and listed in Index.ts", () => {
+    const index: string = fs.readFileSync(
+      path.join(MIGRATION_DIRECTORY, "Index.ts"),
+      "utf8",
+    );
+
+    expect(index).toContain(
+      `import { ${MIGRATION_CLASS_NAME} } from "./${MIGRATION_TIMESTAMP}-${MIGRATION_BASE_NAME}";`,
+    );
+    expect(index).toContain(`  ${MIGRATION_CLASS_NAME},\n`);
+  });
+
+  test("it is in the exported migration list, exactly once", () => {
+    expect(SchemaMigrations).toContain(AddDataResidencyToProject1793300000000);
+    expect(
+      SchemaMigrations.filter((migration: unknown): boolean => {
+        return migration === AddDataResidencyToProject1793300000000;
+      }),
+    ).toHaveLength(1);
+  });
+
+  /*
+   * TypeORM records applied migrations by `name`. A mismatch re-runs the
+   * migration on every boot, and an ADD COLUMN without IF NOT EXISTS fails
+   * the boot the second time.
+   */
+  test("its declared name, its class name and its timestamp agree", () => {
+    expect(new AddDataResidencyToProject1793300000000().name).toBe(
+      MIGRATION_CLASS_NAME,
+    );
+    expect(AddDataResidencyToProject1793300000000.name).toBe(
+      MIGRATION_CLASS_NAME,
+    );
+    expect(
+      AddDataResidencyToProject1793300000000.name.match(CLASS_TIMESTAMP)?.[1],
+    ).toBe(MIGRATION_TIMESTAMP);
+  });
+
+  test("exactly one file on disk carries its timestamp, and it is this one", () => {
+    const matching: Array<string> = fs
+      .readdirSync(MIGRATION_DIRECTORY)
+      .filter((file: string): boolean => {
+        return file.startsWith(`${MIGRATION_TIMESTAMP}-`);
+      });
+
+    expect(matching).toEqual([MIGRATION_FILE_NAME]);
+  });
+
+  test("its timestamp sorts after every migration registered before it", () => {
+    const position: number = SchemaMigrations.indexOf(
+      AddDataResidencyToProject1793300000000,
+    );
+
+    expect(position).toBeGreaterThan(-1);
+
+    const earlierTimestamps: Array<number> = [];
+
+    for (const migrationClass of SchemaMigrations.slice(0, position)) {
+      const match: RegExpMatchArray | null = (
+        migrationClass as { name: string }
+      ).name.match(CLASS_TIMESTAMP);
+
+      if (match) {
+        earlierTimestamps.push(Number(match[1]));
+      }
+    }
+
+    // Math.max() of an empty list is -Infinity; prove the list was read.
+    expect(earlierTimestamps.length).toBeGreaterThan(100);
+
+    expect(Number(MIGRATION_TIMESTAMP)).toBeGreaterThan(
+      Math.max(...earlierTimestamps),
+    );
+  });
+});