@oneuptime/common 14.0.0 → 14.0.1

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

@@ -0,0 +1,407 @@
+import { AddSloLabelAndOwnerRules1794100000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1794100000000-AddSloLabelAndOwnerRules";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import ServiceLevelObjectiveLabelRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveLabelRule";
+import ServiceLevelObjectiveOwnerRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerRule";
+import { describe, expect, test } from "@jest/globals";
+import {
+  DefaultNamingStrategy,
+  QueryRunner,
+  getMetadataArgsStorage,
+} from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+/*
+ * The schema half of SLO label and owner rules.
+ *
+ * The migration was generated against the models, so its names are TypeORM's
+ * by construction. What this pins is that it STAYS the migration for these
+ * models: every table and join table is created with every column the models
+ * persist (criteria included, which 1792500000000 never added to these new
+ * tables), every constraint carries TypeORM's own name - a hand edit that
+ * renamed one would pass review and then fail the Schema Drift job - rules go
+ * with their project and a label, user or team leaves every rule that named
+ * it, nothing unrelated rode along, and down() undoes up() in reverse.
+ *
+ * Fake QueryRunner only. Applying it to Postgres 15, re-generating to "No
+ * changes in database schema were found", reverting and applying it again is
+ * how it was verified when written.
+ */
+
+const namingStrategy: DefaultNamingStrategy = new DefaultNamingStrategy();
+
+type RecordQueriesFunction = (
+  direction: "up" | "down",
+) => Promise<Array<string>>;
+
+const recordQueries: RecordQueriesFunction = async (
+  direction: "up" | "down",
+): Promise<Array<string>> => {
+  const statements: Array<string> = [];
+
+  const queryRunner: QueryRunner = {
+    query: async (statement: string): Promise<void> => {
+      statements.push(statement);
+    },
+  } as unknown as QueryRunner;
+
+  await new AddSloLabelAndOwnerRules1794100000000()[direction](queryRunner);
+
+  return statements;
+};
+
+// Columns a model persists, inherited ones (_id, version, criteria) included.
+function persistedColumns(modelType: unknown): Array<string> {
+  const names: Array<string> = [];
+  let current: unknown = modelType;
+
+  while (typeof current === "function" && current !== Function.prototype) {
+    for (const column of getMetadataArgsStorage().columns) {
+      if (column.target === current) {
+        const args: ColumnMetadataArgs = column;
+        names.push(args.options.name || args.propertyName);
+      }
+    }
+
+    current = Object.getPrototypeOf(current);
+  }
+
+  return names;
+}
+
+function createTableStatement(
+  statements: Array<string>,
+  tableName: string,
+): string {
+  const matches: Array<string> = statements.filter(
+    (statement: string): boolean => {
+      return statement.startsWith(`CREATE TABLE "${tableName}" (`);
+    },
+  );
+
+  expect({ tableName, found: matches.length }).toEqual({
+    tableName,
+    found: 1,
+  });
+
+  return matches[0]!;
+}
+
+function foreignKeyStatement(
+  statements: Array<string>,
+  tableName: string,
+  columnName: string,
+): string {
+  const name: string = namingStrategy.foreignKeyName(tableName, [columnName]);
+  const matches: Array<string> = statements.filter(
+    (statement: string): boolean => {
+      return statement.startsWith(
+        `ALTER TABLE "${tableName}" ADD CONSTRAINT "${name}" FOREIGN KEY ("${columnName}")`,
+      );
+    },
+  );
+
+  expect({ tableName, columnName, found: matches.length }).toEqual({
+    tableName,
+    columnName,
+    found: 1,
+  });
+
+  return matches[0]!;
+}
+
+const RULE_TABLES: Array<[string, unknown]> = [
+  ["ServiceLevelObjectiveLabelRule", ServiceLevelObjectiveLabelRule],
+  ["ServiceLevelObjectiveOwnerRule", ServiceLevelObjectiveOwnerRule],
+];
+
+interface JoinTableSpec {
+  tableName: string;
+  ruleColumn: string;
+  ruleTable: string;
+  relatedColumn: string;
+  relatedTable: string;
+}
+
+const JOIN_TABLES: Array<JoinTableSpec> = [
+  {
+    tableName: "ServiceLevelObjectiveLabelRuleServiceLevelObjectiveLabel",
+    ruleColumn: "serviceLevelObjectiveLabelRuleId",
+    ruleTable: "ServiceLevelObjectiveLabelRule",
+    relatedColumn: "labelId",
+    relatedTable: "Label",
+  },
+  {
+    tableName: "ServiceLevelObjectiveLabelRuleLabelToAdd",
+    ruleColumn: "serviceLevelObjectiveLabelRuleId",
+    ruleTable: "ServiceLevelObjectiveLabelRule",
+    relatedColumn: "labelId",
+    relatedTable: "Label",
+  },
+  {
+    tableName: "ServiceLevelObjectiveOwnerRuleServiceLevelObjectiveLabel",
+    ruleColumn: "serviceLevelObjectiveOwnerRuleId",
+    ruleTable: "ServiceLevelObjectiveOwnerRule",
+    relatedColumn: "labelId",
+    relatedTable: "Label",
+  },
+  {
+    tableName: "ServiceLevelObjectiveOwnerRuleOwnerUser",
+    ruleColumn: "serviceLevelObjectiveOwnerRuleId",
+    ruleTable: "ServiceLevelObjectiveOwnerRule",
+    relatedColumn: "userId",
+    relatedTable: "User",
+  },
+  {
+    tableName: "ServiceLevelObjectiveOwnerRuleOwnerTeam",
+    ruleColumn: "serviceLevelObjectiveOwnerRuleId",
+    ruleTable: "ServiceLevelObjectiveOwnerRule",
+    relatedColumn: "teamId",
+    relatedTable: "Team",
+  },
+];
+
+const ALL_TABLES: Array<string> = [
+  ...RULE_TABLES.map(([tableName]: [string, unknown]): string => {
+    return tableName;
+  }),
+  ...JOIN_TABLES.map((spec: JoinTableSpec): string => {
+    return spec.tableName;
+  }),
+];
+
+describe("AddSloLabelAndOwnerRules1794100000000", () => {
+  test("is registered under the name its class carries", () => {
+    const migration: AddSloLabelAndOwnerRules1794100000000 =
+      new AddSloLabelAndOwnerRules1794100000000();
+
+    expect(migration.name).toBe("AddSloLabelAndOwnerRules1794100000000");
+    expect(SchemaMigrations).toContain(AddSloLabelAndOwnerRules1794100000000);
+  });
+
+  /*
+   * Not "is registered last": the next migration to land falsifies that
+   * without going anywhere near these tables. What this migration must not do
+   * is jump the queue of those registered before it; the registry-wide guard
+   * on the newest entry lives in SchemaMigrationsOrdering.
+   */
+  test("its timestamp keeps it behind every migration registered before it", () => {
+    const timestampOf: (className: string) => number | null = (
+      className: string,
+    ): number | null => {
+      const match: RegExpMatchArray | null = className.match(/(\d{13})$/);
+      return match ? Number(match[1]) : null;
+    };
+
+    const names: Array<string> = (
+      SchemaMigrations as unknown as Array<{ name: string }>
+    ).map((registered: { name: string }): string => {
+      return registered.name;
+    });
+
+    const ownIndex: number = names.indexOf(
+      "AddSloLabelAndOwnerRules1794100000000",
+    );
+
+    // indexOf -1 would make the slice below empty and this test vacuous.
+    expect(ownIndex).toBeGreaterThan(0);
+
+    const notBehind: Array<string> = names
+      .slice(0, ownIndex)
+      .filter((className: string): boolean => {
+        const timestamp: number | null = timestampOf(className);
+        return timestamp !== null && timestamp >= 1794100000000;
+      });
+
+    expect(notBehind).toEqual([]);
+  });
+
+  test("touches only the seven new tables", async () => {
+    const statements: Array<string> = await recordQueries("up");
+
+    for (const statement of statements) {
+      const table: RegExpMatchArray | null = statement.match(
+        /^(?:CREATE TABLE|ALTER TABLE|CREATE INDEX "[^"]+" ON) "([^"]+)"/,
+      );
+
+      expect({ statement, table: table?.[1] }).toEqual({
+        statement,
+        table: expect.stringMatching(new RegExp(`^(${ALL_TABLES.join("|")})$`)),
+      });
+    }
+
+    expect(
+      statements.filter((statement: string): boolean => {
+        return statement.startsWith("CREATE TABLE");
+      }),
+    ).toHaveLength(ALL_TABLES.length);
+  });
+
+  test.each(RULE_TABLES)(
+    "creates %s with every column the model persists",
+    async (tableName: string, modelType: unknown) => {
+      const statement: string = createTableStatement(
+        await recordQueries("up"),
+        tableName,
+      );
+
+      for (const column of persistedColumns(modelType)) {
+        expect({
+          tableName,
+          column,
+          created: statement.includes(`"${column}"`),
+        }).toEqual({ tableName, column, created: true });
+      }
+
+      expect(statement).toContain('"criteria" jsonb');
+      expect(statement).toContain('"isEnabled" boolean NOT NULL DEFAULT true');
+      expect(statement).toContain('"projectId" uuid NOT NULL');
+    },
+  );
+
+  test("defaults an owner rule to notifying the owners it adds", async () => {
+    expect(
+      createTableStatement(
+        await recordQueries("up"),
+        "ServiceLevelObjectiveOwnerRule",
+      ),
+    ).toContain('"notifyOwners" boolean NOT NULL DEFAULT true');
+  });
+
+  test.each(RULE_TABLES)(
+    "deletes %s with its project, and keeps it when its author is deleted",
+    async (tableName: string) => {
+      const statements: Array<string> = await recordQueries("up");
+
+      expect(foreignKeyStatement(statements, tableName, "projectId")).toContain(
+        'REFERENCES "Project"("_id") ON DELETE CASCADE',
+      );
+      expect(
+        foreignKeyStatement(statements, tableName, "createdByUserId"),
+      ).toContain('REFERENCES "User"("_id") ON DELETE SET NULL');
+      expect(
+        foreignKeyStatement(statements, tableName, "deletedByUserId"),
+      ).toContain('REFERENCES "User"("_id") ON DELETE SET NULL');
+    },
+  );
+
+  test.each(JOIN_TABLES)(
+    "creates $tableName, keyed by the rule and the $relatedTable",
+    async (spec: JoinTableSpec) => {
+      const statements: Array<string> = await recordQueries("up");
+      const statement: string = createTableStatement(
+        statements,
+        spec.tableName,
+      );
+
+      expect(statement).toContain(
+        `PRIMARY KEY ("${spec.ruleColumn}", "${spec.relatedColumn}")`,
+      );
+      expect(spec.tableName.length).toBeLessThanOrEqual(63);
+
+      // Both sides clean up after themselves.
+      expect(
+        foreignKeyStatement(statements, spec.tableName, spec.ruleColumn),
+      ).toContain(`REFERENCES "${spec.ruleTable}"("_id") ON DELETE CASCADE`);
+      expect(
+        foreignKeyStatement(statements, spec.tableName, spec.relatedColumn),
+      ).toContain(`REFERENCES "${spec.relatedTable}"("_id") ON DELETE CASCADE`);
+
+      for (const column of [spec.ruleColumn, spec.relatedColumn]) {
+        const indexName: string = namingStrategy.indexName(spec.tableName, [
+          column,
+        ]);
+
+        expect(statements).toContain(
+          `CREATE INDEX "${indexName}" ON "${spec.tableName}" ("${column}") `,
+        );
+      }
+    },
+  );
+
+  test("indexes the columns the rule engines and tables filter on", async () => {
+    const statements: Array<string> = await recordQueries("up");
+
+    for (const [tableName] of RULE_TABLES) {
+      for (const column of ["projectId", "name", "isEnabled"]) {
+        const indexName: string = namingStrategy.indexName(tableName, [column]);
+
+        expect(statements).toContain(
+          `CREATE INDEX "${indexName}" ON "${tableName}" ("${column}") `,
+        );
+      }
+    }
+  });
+
+  test("down() drops every table up() created, join tables first", async () => {
+    const down: Array<string> = await recordQueries("down");
+    const dropped: Array<string> = down
+      .map((statement: string): string | null => {
+        const match: RegExpMatchArray | null = statement.match(
+          /^DROP TABLE "([^"]+)"$/,
+        );
+        return match ? match[1]! : null;
+      })
+      .filter((tableName: string | null): tableName is string => {
+        return tableName !== null;
+      });
+
+    expect([...dropped].sort()).toEqual([...ALL_TABLES].sort());
+
+    for (const spec of JOIN_TABLES) {
+      expect(dropped.indexOf(spec.tableName)).toBeLessThan(
+        dropped.indexOf(spec.ruleTable),
+      );
+    }
+  });
+
+  test("down() removes every constraint and index up() added, in reverse", async () => {
+    const up: Array<string> = await recordQueries("up");
+    const down: Array<string> = await recordQueries("down");
+
+    const addedConstraints: Array<string> = up
+      .map((statement: string): string | null => {
+        const match: RegExpMatchArray | null = statement.match(
+          /ADD CONSTRAINT "([^"]+)"/,
+        );
+        return match ? match[1]! : null;
+      })
+      .filter((name: string | null): name is string => {
+        return name !== null;
+      });
+    const droppedConstraints: Array<string> = down
+      .map((statement: string): string | null => {
+        const match: RegExpMatchArray | null = statement.match(
+          /DROP CONSTRAINT "([^"]+)"/,
+        );
+        return match ? match[1]! : null;
+      })
+      .filter((name: string | null): name is string => {
+        return name !== null;
+      });
+
+    expect(droppedConstraints).toEqual([...addedConstraints].reverse());
+
+    const addedIndexes: Array<string> = up
+      .map((statement: string): string | null => {
+        const match: RegExpMatchArray | null = statement.match(
+          /^CREATE INDEX "([^"]+)"/,
+        );
+        return match ? match[1]! : null;
+      })
+      .filter((name: string | null): name is string => {
+        return name !== null;
+      });
+    const droppedIndexes: Array<string> = down
+      .map((statement: string): string | null => {
+        const match: RegExpMatchArray | null = statement.match(
+          /^DROP INDEX "public"\."([^"]+)"$/,
+        );
+        return match ? match[1]! : null;
+      })
+      .filter((name: string | null): name is string => {
+        return name !== null;
+      });
+
+    expect([...droppedIndexes].sort()).toEqual([...addedIndexes].sort());
+  });
+});

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

@@ -0,0 +1,171 @@
+import { AddSloMonitorRuleMonitorType1794200000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1794200000000-AddSloMonitorRuleMonitorType";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import ServiceLevelObjectiveMonitorRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveMonitorRule";
+import ColumnLength from "../../../../Types/Database/ColumnLength";
+import ColumnType from "../../../../Types/Database/ColumnType";
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import { QueryRunner, getMetadataArgsStorage } from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+/*
+ * The schema half of "monitor type" as an SLO monitor rule criterion: one
+ * nullable column on a table 1793100000000-SloProductOverhaul created.
+ *
+ * SloProductOverhaul has shipped, so its CREATE TABLE is never edited to carry
+ * the column; that migration's own test accepts a column a later registered
+ * migration adds, and this is the later migration's test. It pins that the
+ * column is added exactly as the model declares it (a mismatch is a green
+ * deploy followed by a red Schema Drift job), that existing rules stay valid
+ * without a backfill, and that down() undoes up().
+ *
+ * Fake QueryRunner only. Applying it to Postgres and re-running the Schema
+ * Drift check to "No schema drift." is how it was verified.
+ */
+
+const OWN_CLASS_NAME: string = "AddSloMonitorRuleMonitorType1794200000000";
+
+const TABLE_CREATED_BY: string = "SloProductOverhaul1793100000000";
+
+const MIGRATION_PATH: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+  "1794200000000-AddSloMonitorRuleMonitorType.ts",
+);
+
+type TimestampOfClassNameFunction = (className: string) => number | null;
+
+// The timestamp TypeORM sorts by and records: the one in the CLASS name.
+const timestampOfClassName: TimestampOfClassNameFunction = (
+  className: string,
+): number | null => {
+  const match: RegExpMatchArray | null = className.match(/(\d{13})$/);
+  return match ? Number(match[1]) : null;
+};
+
+const registeredNames: Array<string> = (
+  SchemaMigrations as unknown as Array<{ name: string }>
+).map((migration: { name: string }): string => {
+  return migration.name;
+});
+
+type RecordQueriesFunction = (
+  direction: "up" | "down",
+) => Promise<Array<string>>;
+
+const recordQueries: RecordQueriesFunction = async (
+  direction: "up" | "down",
+): Promise<Array<string>> => {
+  const statements: Array<string> = [];
+
+  const queryRunner: QueryRunner = {
+    query: async (statement: string): Promise<void> => {
+      statements.push(statement);
+    },
+  } as unknown as QueryRunner;
+
+  await new AddSloMonitorRuleMonitorType1794200000000()[direction](queryRunner);
+
+  return statements;
+};
+
+describe("AddSloMonitorRuleMonitorType migration - identity and registration", () => {
+  test("lives at its round stamp, with a class and name that carry it", () => {
+    const source: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+    expect(source).toContain(`export class ${OWN_CLASS_NAME}`);
+    expect(source).toContain(`public name: string = "${OWN_CLASS_NAME}";`);
+    expect(new AddSloMonitorRuleMonitorType1794200000000().name).toBe(
+      OWN_CLASS_NAME,
+    );
+  });
+
+  test("is registered, so the column actually reaches every database", () => {
+    expect(registeredNames).toContain(OWN_CLASS_NAME);
+  });
+
+  /*
+   * Not "is registered last": that claim is falsified by whichever migration
+   * lands next, without it going anywhere near this column. What matters is
+   * the queue this one must not jump - see SchemaMigrationsOrdering for the
+   * registry-wide guard on the newest entry.
+   */
+  test("its timestamp keeps it behind every migration registered before it", () => {
+    const ownIndex: number = registeredNames.indexOf(OWN_CLASS_NAME);
+
+    // indexOf -1 would make the slice below empty and this test vacuous.
+    expect(ownIndex).toBeGreaterThan(0);
+
+    const ownTimestamp: number = timestampOfClassName(OWN_CLASS_NAME)!;
+
+    const notBehind: Array<string> = registeredNames
+      .slice(0, ownIndex)
+      .filter((className: string): boolean => {
+        const timestamp: number | null = timestampOfClassName(className);
+        return timestamp !== null && timestamp >= ownTimestamp;
+      });
+
+    expect(notBehind).toEqual([]);
+  });
+
+  test("runs after the migration that creates the table it alters", () => {
+    expect(registeredNames.indexOf(TABLE_CREATED_BY)).toBeGreaterThan(-1);
+    expect(registeredNames.indexOf(TABLE_CREATED_BY)).toBeLessThan(
+      registeredNames.indexOf(OWN_CLASS_NAME),
+    );
+    expect(timestampOfClassName(TABLE_CREATED_BY)!).toBeLessThan(
+      timestampOfClassName(OWN_CLASS_NAME)!,
+    );
+  });
+});
+
+describe("AddSloMonitorRuleMonitorType migration - up()", () => {
+  /*
+   * Nullable with no default and no backfill: every rule saved before this
+   * column existed reads as "no type filter", which is what it meant.
+   */
+  test("adds exactly the nullable monitorType column and nothing else", async () => {
+    expect(await recordQueries("up")).toEqual([
+      'ALTER TABLE "ServiceLevelObjectiveMonitorRule" ADD "monitorType" character varying(100)',
+    ]);
+  });
+
+  test("matches the column the model declares, so the Schema Drift job stays green", () => {
+    const declared: ColumnMetadataArgs | undefined =
+      getMetadataArgsStorage().columns.find(
+        (column: ColumnMetadataArgs): boolean => {
+          return (
+            column.target === ServiceLevelObjectiveMonitorRule &&
+            column.propertyName === "monitorType"
+          );
+        },
+      );
+
+    expect(declared).toBeDefined();
+    expect(declared!.options.name).toBeUndefined();
+    expect(declared!.options.type).toBe(ColumnType.ShortText);
+    expect(declared!.options.length).toBe(ColumnLength.ShortText);
+    expect(declared!.options.nullable).toBe(true);
+    expect(declared!.options.default).toBeUndefined();
+
+    // ColumnType.ShortText is varchar, which Postgres spells character varying.
+    expect(ColumnType.ShortText).toBe("varchar");
+    expect(ColumnLength.ShortText).toBe(100);
+  });
+});
+
+describe("AddSloMonitorRuleMonitorType migration - down()", () => {
+  test("drops exactly the column up() added", async () => {
+    expect(await recordQueries("down")).toEqual([
+      'ALTER TABLE "ServiceLevelObjectiveMonitorRule" DROP COLUMN "monitorType"',
+    ]);
+  });
+});

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

@@ -100,6 +100,76 @@ const persistedColumns: PersistedColumnsFunction = (
   return names;
 };
 
+const MIGRATION_TIMESTAMP: number = 1793100000000;
+
+const MIGRATIONS_DIRECTORY: string = path.dirname(MIGRATION_PATH);
+
+/*
+ * Columns that a migration registered AFTER this one adds to `tableName`.
+ *
+ * This migration has shipped, so a column its models gain later arrives in a
+ * later migration, never in an edit to the CREATE TABLE here: editing it would
+ * do nothing for the databases that already ran it while putting them out of
+ * step with fresh ones. So the invariant the column checks below pin is "every
+ * column the model persists is created here or added by a later registered
+ * migration", which still fails a column that no migration creates at all. The
+ * later migration's own test pins that column's definition, and the Schema
+ * Drift job owns the end-state schema.
+ *
+ * "Later" is by the timestamp in the class name, which is what TypeORM sorts
+ * by, and only registered migrations count - a file nobody registered never
+ * runs. Their source is read rather than run against the fake QueryRunner, so
+ * a later data migration that reads rows back cannot break this suite.
+ */
+type ColumnsAddedLaterFunction = (tableName: string) => Set<string>;
+
+const columnsAddedByLaterMigrations: ColumnsAddedLaterFunction = (
+  tableName: string,
+): Set<string> => {
+  const laterTimestamps: Set<string> = new Set<string>();
+
+  for (const migration of SchemaMigrations as unknown as Array<{
+    name: string;
+  }>) {
+    const timestamp: string | undefined =
+      migration.name.match(/(\d{13})$/)?.[1];
+
+    if (timestamp && Number(timestamp) > MIGRATION_TIMESTAMP) {
+      laterTimestamps.add(timestamp);
+    }
+  }
+
+  const addColumn: RegExp = new RegExp(
+    `ALTER TABLE "${tableName}" ADD (?:COLUMN )?"([^"]+)"`,
+    "g",
+  );
+
+  const added: Set<string> = new Set<string>();
+
+  for (const fileName of fs.readdirSync(MIGRATIONS_DIRECTORY)) {
+    if (
+      !fileName.endsWith(".ts") ||
+      !laterTimestamps.has(fileName.split("-")[0]!)
+    ) {
+      continue;
+    }
+
+    const source: string = fs.readFileSync(
+      path.join(MIGRATIONS_DIRECTORY, fileName),
+      "utf8",
+    );
+
+    let match: RegExpExecArray | null = addColumn.exec(source);
+
+    while (match) {
+      added.add(match[1]!);
+      match = addColumn.exec(source);
+    }
+  }
+
+  return added;
+};
+
 type CreateTableStatementFunction = (
   statements: Array<string>,
   tableName: string,
@@ -391,7 +461,7 @@ describe("SloProductOverhaul migration - scope", () => {
 });
 
 describe("SloProductOverhaul migration - ServiceLevelObjectiveMonitorRule", () => {
-  test("creates every column the model persists, criteria included", async () => {
+  test("creates every column the model persists, criteria included, bar those a later migration adds", async () => {
     const statement: string = createTableStatement(
       await recordQueries("up"),
       "ServiceLevelObjectiveMonitorRule",
@@ -404,8 +474,15 @@ describe("SloProductOverhaul migration - ServiceLevelObjectiveMonitorRule", () =
     expect(columns).toContain("criteria");
     expect(columns).toContain("monitorNamePattern");
 
+    const addedLater: Set<string> = columnsAddedByLaterMigrations(
+      "ServiceLevelObjectiveMonitorRule",
+    );
+
     for (const column of columns) {
-      expect({ column, created: statement.includes(`"${column}"`) }).toEqual({
+      expect({
+        column,
+        created: statement.includes(`"${column}"`) || addedLater.has(column),
+      }).toEqual({
         column,
         created: true,
       });
@@ -460,14 +537,21 @@ describe("SloProductOverhaul migration - ServiceLevelObjectiveMonitorRule", () =
 });
 
 describe("SloProductOverhaul migration - ServiceLevelObjectiveFeed", () => {
-  test("creates every column the model persists", async () => {
+  test("creates every column the model persists, bar those a later migration adds", async () => {
     const statement: string = createTableStatement(
       await recordQueries("up"),
       "ServiceLevelObjectiveFeed",
     );
 
+    const addedLater: Set<string> = columnsAddedByLaterMigrations(
+      "ServiceLevelObjectiveFeed",
+    );
+
     for (const column of persistedColumns(ServiceLevelObjectiveFeed)) {
-      expect({ column, created: statement.includes(`"${column}"`) }).toEqual({
+      expect({
+        column,
+        created: statement.includes(`"${column}"`) || addedLater.has(column),
+      }).toEqual({
         column,
         created: true,
       });