@oneuptime/common 14.0.6 → 14.0.8

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

@@ -87,9 +87,20 @@ const FOREIGN_KEY_COLUMNS: Array<Array<string>> = [
   ["deletedByUserId"],
 ];
 
-type DeclaredIndexColumnsFunction = (
-  modelType: ModelClass,
-) => Array<Array<string>>;
+interface DeclaredIndex {
+  columns: Array<string>;
+  /*
+   * The name the model pins with `@Index("NAME", [...])`, when it pins one.
+   *
+   * Only TypeORM's derived names contain the table name and so had to be
+   * renamed. A pinned name reads the same before and after the rename, so the
+   * rename has nothing to do for it - and must not claim to, or it would try
+   * to rename a name that never existed.
+   */
+  name: string | undefined;
+}
+
+type DeclaredIndexesFunction = (modelType: ModelClass) => Array<DeclaredIndex>;
 
 /*
  * The indexes a model actually declares, read out of TypeORM's decorator
@@ -97,19 +108,19 @@ type DeclaredIndexColumnsFunction = (
  * `@Index([...])` carries its columns; a column-level `@Index()` records the
  * property it decorates instead.
  */
-const getDeclaredIndexColumns: DeclaredIndexColumnsFunction = (
+const getDeclaredIndexes: DeclaredIndexesFunction = (
   modelType: ModelClass,
-): Array<Array<string>> => {
+): Array<DeclaredIndex> => {
   return getMetadataArgsStorage()
     .indices.filter((index: IndexMetadataArgs): boolean => {
       return index.target === modelType;
     })
-    .map((index: IndexMetadataArgs): Array<string> => {
-      if (Array.isArray(index.columns)) {
-        return index.columns as Array<string>;
-      }
+    .map((index: IndexMetadataArgs): DeclaredIndex => {
+      const columns: Array<string> = Array.isArray(index.columns)
+        ? (index.columns as Array<string>)
+        : [String((index as { propertyName?: string }).propertyName)];
 
-      return [String((index as { propertyName?: string }).propertyName)];
+      return { columns: columns, name: index.name };
     });
 };
 
@@ -145,9 +156,10 @@ const MIGRATION_TIMESTAMP: number = 1786800000000;
  * yet. Read out of the migration directory rather than hand-listed, so a
  * future migration adding an index does not require editing this test.
  */
-function getIndexesCreatedAfterTheRename(): Set<string> {
+/** The source of every migration that runs after the rename. */
+function getMigrationSourcesAfterTheRename(): Array<string> {
   const directory: string = path.dirname(MIGRATION_PATH);
-  const created: Set<string> = new Set<string>();
+  const sources: Array<string> = [];
 
   for (const file of fs.readdirSync(directory)) {
     const timestamp: number = Number(file.split("-")[0]);
@@ -156,11 +168,27 @@ function getIndexesCreatedAfterTheRename(): Set<string> {
       continue;
     }
 
-    const source: string = fs.readFileSync(path.join(directory, file), "utf8");
+    sources.push(fs.readFileSync(path.join(directory, file), "utf8"));
+  }
+
+  return sources;
+}
+
+const MIGRATIONS_AFTER_THE_RENAME: Array<string> =
+  getMigrationSourcesAfterTheRename();
+
+function getIndexesCreatedAfterTheRename(): Set<string> {
+  const created: Set<string> = new Set<string>();
 
+  for (const source of MIGRATIONS_AFTER_THE_RENAME) {
     for (const table of ["InventoryItem", "InventoryItemRelationship"]) {
+      /*
+       * `IF NOT EXISTS` is allowed for: a migration that has to be safe to
+       * re-run still creates the index, and skipping it here would demand a
+       * rename pair for an index that did not exist when the rename ran.
+       */
       const pattern: RegExp = new RegExp(
-        `CREATE (?:UNIQUE )?INDEX "(IDX_[a-f0-9]+)" ON "${table}"`,
+        `CREATE (?:UNIQUE )?INDEX (?:IF NOT EXISTS )?"(IDX_[a-f0-9]+)" ON "${table}"`,
         "g",
       );
 
@@ -178,6 +206,23 @@ function getIndexesCreatedAfterTheRename(): Set<string> {
 
 const INDEXES_ADDED_LATER: Set<string> = getIndexesCreatedAfterTheRename();
 
+type PinnedIndexCreatedFunction = (indexName: string) => boolean;
+
+/*
+ * Whether some migration after the rename creates the index a model pins by
+ * name. Matched by the name appearing anywhere in that migration rather than
+ * by a CREATE INDEX pattern: a pinned name is normally held in an exported
+ * constant and interpolated into the statement, so the statement itself
+ * carries `${THE_CONSTANT}` and only the declaration carries the literal.
+ */
+const isPinnedIndexCreatedAfterTheRename: PinnedIndexCreatedFunction = (
+  indexName: string,
+): boolean => {
+  return MIGRATIONS_AFTER_THE_RENAME.some((source: string): boolean => {
+    return source.includes(indexName);
+  });
+};
+
 type PairMapFunction = (prefix: string) => Map<string, string>;
 
 const pairsWithPrefix: PairMapFunction = (
@@ -228,15 +273,34 @@ describe("the data survives", () => {
 
 describe("index names match TypeORM's naming strategy", () => {
   for (const table of TABLES) {
-    const declared: Array<Array<string>> = getDeclaredIndexColumns(
-      table.modelType,
-    );
+    const declared: Array<DeclaredIndex> = getDeclaredIndexes(table.modelType);
 
     test(`${table.newTable} declares indexes to rename`, () => {
       expect(declared.length).toBeGreaterThan(0);
     });
 
-    for (const columns of declared) {
+    for (const index of declared) {
+      const columns: Array<string> = index.columns;
+      const pinnedName: string | undefined = index.name;
+
+      if (pinnedName) {
+        /*
+         * A pinned name carries no table name, so the rename had nothing to
+         * change and must not claim otherwise. What still has to hold is that
+         * a migration creates it - otherwise the model declares an index that
+         * only ever exists on a schema the builder synchronizes, and these are
+         * declared `synchronize: false` precisely so it does not.
+         */
+        test(`${table.newTable} (${columns.join(", ")}) is pinned by name, so the rename leaves it alone`, () => {
+          const indexPairs: Map<string, string> = pairsWithPrefix("IDX_");
+
+          expect(indexPairs.has(pinnedName)).toBe(false);
+          expect(Array.from(indexPairs.values())).not.toContain(pinnedName);
+          expect(isPinnedIndexCreatedAfterTheRename(pinnedName)).toBe(true);
+        });
+        continue;
+      }
+
       const oldName: string = namingStrategy.indexName(table.oldTable, columns);
       const newName: string = namingStrategy.indexName(table.newTable, columns);
 
@@ -263,16 +327,21 @@ describe("index names match TypeORM's naming strategy", () => {
     const expected: Set<string> = new Set<string>();
 
     for (const table of TABLES) {
-      for (const columns of getDeclaredIndexColumns(table.modelType)) {
+      for (const index of getDeclaredIndexes(table.modelType)) {
+        if (index.name) {
+          // Pinned name: table-independent, so the rename never touched it.
+          continue;
+        }
+
         if (
           INDEXES_ADDED_LATER.has(
-            namingStrategy.indexName(table.newTable, columns),
+            namingStrategy.indexName(table.newTable, index.columns),
           )
         ) {
           continue;
         }
 
-        expected.add(namingStrategy.indexName(table.oldTable, columns));
+        expected.add(namingStrategy.indexName(table.oldTable, index.columns));
       }
     }
 

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

@@ -0,0 +1,410 @@
+import Incident from "../../../../Models/DatabaseModels/Incident";
+import {
+  HIDDEN_FROM_STATUS_PAGES_MESSAGE,
+  SkipHiddenIncidentCreatedNotifications1795300000000,
+} from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1795300000000-SkipHiddenIncidentCreatedNotifications";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import ObjectID from "../../../../Types/ObjectID";
+import IncidentCreatedRenotify from "../../../../Types/StatusPage/IncidentCreatedRenotify";
+import StatusPageSubscriberNotificationStatus from "../../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+import {
+  DataSource,
+  MigrationInterface,
+  QueryRunner,
+  getMetadataArgsStorage,
+} from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+/*
+ * SkipHiddenIncidentCreatedNotifications1795300000000 settles the 'incident
+ * created' subscriber notification of hidden incidents that the old worker
+ * marked InProgress and then abandoned. The worker only picks up Pending
+ * rows, so those rows could never move again; Skipped is what the fixed
+ * worker writes for a hidden incident, and what lets publishing the incident
+ * re-queue the notification.
+ */
+
+interface Statement {
+  sql: string;
+  parameters: Array<unknown> | undefined;
+}
+
+async function statementsFor(
+  direction: "up" | "down",
+): Promise<Array<Statement>> {
+  const statements: Array<Statement> = [];
+  const runner: QueryRunner = {
+    query: async (sql: string, parameters?: Array<unknown>): Promise<void> => {
+      statements.push({ sql, parameters });
+    },
+  } as unknown as QueryRunner;
+
+  await new SkipHiddenIncidentCreatedNotifications1795300000000()[direction](
+    runner,
+  );
+  return statements;
+}
+
+function incidentColumn(property: string): ColumnMetadataArgs {
+  const column: ColumnMetadataArgs | undefined = getMetadataArgsStorage()
+    .columns.filter((args: ColumnMetadataArgs) => {
+      return args.target === Incident && args.propertyName === property;
+    })
+    .pop();
+
+  expect(column).toBeDefined();
+  return column!;
+}
+
+describe("SkipHiddenIncidentCreatedNotifications1795300000000 SQL contract", () => {
+  test("up() runs a single UPDATE of Incident and no schema change", async () => {
+    const statements: Array<Statement> = await statementsFor("up");
+
+    expect(statements).toHaveLength(1);
+    expect(statements[0]!.sql).toMatch(/^UPDATE "Incident" SET /);
+    // Keywords only: the status column's own name contains "Created".
+    expect(statements[0]!.sql).not.toMatch(
+      /\b(ALTER|CREATE|DROP|DELETE|INSERT|TRUNCATE)\b/,
+    );
+  });
+
+  test("sets the status to Skipped and the message to the worker's hidden-incident reason", async () => {
+    const statement: Statement = (await statementsFor("up"))[0]!;
+
+    expect(statement.sql).toContain(
+      `SET "subscriberNotificationStatusOnIncidentCreated" = '${StatusPageSubscriberNotificationStatus.Skipped}', "subscriberNotificationStatusMessage" = $1 `,
+    );
+    expect(statement.parameters).toEqual([
+      IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+    ]);
+  });
+
+  test("touches only InProgress rows of incidents that are not visible, counting NULL as hidden", async () => {
+    const statement: Statement = (await statementsFor("up"))[0]!;
+
+    expect(statement.sql).toContain(
+      `WHERE "subscriberNotificationStatusOnIncidentCreated" = '${StatusPageSubscriberNotificationStatus.InProgress}' AND "isVisibleOnStatusPage" IS NOT TRUE`,
+    );
+    // Nothing else narrows or widens it.
+    expect(statement.sql.split("WHERE")).toHaveLength(2);
+    expect(statement.sql).not.toMatch(/ OR /i);
+  });
+
+  test("migrated rows read exactly like rows the fixed worker skips", () => {
+    /*
+     * The migration keeps its own copy of the text so it never changes after
+     * it ships; the dashboard recognises the reason by this text.
+     */
+    expect(HIDDEN_FROM_STATUS_PAGES_MESSAGE).toBe(
+      IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+    );
+    expect(
+      IncidentCreatedRenotify.isHiddenFromStatusPagesSkip({
+        status: StatusPageSubscriberNotificationStatus.Skipped,
+        message: HIDDEN_FROM_STATUS_PAGES_MESSAGE,
+      }),
+    ).toBe(true);
+  });
+
+  test("names real Incident columns", () => {
+    expect(
+      incidentColumn("subscriberNotificationStatusOnIncidentCreated").options
+        .type,
+    ).toBeDefined();
+    expect(
+      incidentColumn("subscriberNotificationStatusMessage").options.nullable,
+    ).toBe(true);
+    // The worker reads a NULL visibility as hidden; the column allows it.
+    expect(incidentColumn("isVisibleOnStatusPage").options.nullable).toBe(true);
+  });
+
+  test("down() restores nothing", async () => {
+    expect(await statementsFor("down")).toEqual([]);
+  });
+
+  test("is registered exactly once, after the migrations before it, so it runs on boot", () => {
+    const registered: Array<new () => MigrationInterface> =
+      SchemaMigrations.filter(
+        (migration: new () => MigrationInterface): boolean => {
+          return (
+            migration === SkipHiddenIncidentCreatedNotifications1795300000000
+          );
+        },
+      );
+
+    expect(registered).toHaveLength(1);
+    expect(new SkipHiddenIncidentCreatedNotifications1795300000000().name).toBe(
+      "SkipHiddenIncidentCreatedNotifications1795300000000",
+    );
+    expect(
+      SchemaMigrations.indexOf(
+        SkipHiddenIncidentCreatedNotifications1795300000000,
+      ),
+    ).toBeGreaterThan(
+      SchemaMigrations.findIndex(
+        (migration: new () => MigrationInterface): boolean => {
+          return (
+            new migration().name === "AddUserProjectSsoConsent1795100000000"
+          );
+        },
+      ),
+    );
+  });
+});
+
+/*
+ * Opt in with RUN_POSTGRES_HIDDEN_INCIDENT_NOTIFICATION_MIGRATION_TESTS=true
+ * and the normal database credentials (the Common test job does). The table
+ * is a minimal stand-in for Incident with the columns the migration reads and
+ * writes, typed as the entity declares them, in a uniquely named schema whose
+ * search_path excludes public - so no application row is ever touched.
+ */
+const describePostgres: typeof describe.skip =
+  process.env["RUN_POSTGRES_HIDDEN_INCIDENT_NOTIFICATION_MIGRATION_TESTS"] ===
+  "true"
+    ? describe
+    : describe.skip;
+
+interface StoredIncident {
+  _id: string;
+  isVisibleOnStatusPage: boolean | null;
+  status: string;
+  message: string | null;
+  postmortemStatus: string;
+}
+
+describePostgres(
+  "SkipHiddenIncidentCreatedNotifications against Postgres",
+  () => {
+    const schema: string = `hidden_incident_notifications_${ObjectID.generate()
+      .toString()
+      .replace(/-/g, "")}`;
+    const migration: SkipHiddenIncidentCreatedNotifications1795300000000 =
+      new SkipHiddenIncidentCreatedNotifications1795300000000();
+
+    let database: DataSource;
+    let runner: QueryRunner;
+
+    async function insert(row: {
+      isVisibleOnStatusPage: boolean | null;
+      status: StatusPageSubscriberNotificationStatus;
+      message?: string | null;
+    }): Promise<string> {
+      const id: string = ObjectID.generate().toString();
+      await runner.query(
+        `INSERT INTO "Incident" ("_id", "isVisibleOnStatusPage", "subscriberNotificationStatusOnIncidentCreated", "subscriberNotificationStatusMessage") VALUES ($1, $2, $3, $4)`,
+        [id, row.isVisibleOnStatusPage, row.status, row.message ?? null],
+      );
+      return id;
+    }
+
+    async function read(id: string): Promise<StoredIncident> {
+      const rows: Array<StoredIncident> = await runner.query(
+        `SELECT "_id", "isVisibleOnStatusPage", "subscriberNotificationStatusOnIncidentCreated" AS status, "subscriberNotificationStatusMessage" AS message, "subscriberNotificationStatusOnPostmortemPublished" AS "postmortemStatus" FROM "Incident" WHERE "_id" = $1`,
+        [id],
+      );
+      expect(rows).toHaveLength(1);
+      return rows[0]!;
+    }
+
+    beforeAll(async () => {
+      database = new DataSource({
+        type: "postgres",
+        host:
+          process.env[
+            "HIDDEN_INCIDENT_NOTIFICATION_MIGRATION_TEST_DATABASE_HOST"
+          ] || "localhost",
+        port: Number(
+          process.env[
+            "HIDDEN_INCIDENT_NOTIFICATION_MIGRATION_TEST_DATABASE_PORT"
+          ] || "5400",
+        ),
+        username: process.env["DATABASE_USERNAME"] || "postgres",
+        password: process.env["DATABASE_PASSWORD"] || "password",
+        database: process.env["DATABASE_NAME"] || "oneuptimedb",
+        entities: [],
+        schema,
+        synchronize: false,
+        extra: { options: `-c search_path=${schema}` },
+      });
+      await database.initialize();
+      await database.query(`CREATE SCHEMA "${schema}"`);
+      runner = database.createQueryRunner();
+      await runner.connect();
+
+      const currentSchema: Array<{ current_schema: string }> =
+        await runner.query("SELECT current_schema()");
+      expect(currentSchema[0]?.current_schema).toBe(schema);
+    });
+
+    beforeEach(async () => {
+      await runner.startTransaction();
+      // The columns as the migrated Incident table declares them.
+      await runner.query(
+        `CREATE TABLE "Incident" ("_id" uuid PRIMARY KEY, "isVisibleOnStatusPage" boolean DEFAULT true, "subscriberNotificationStatusOnIncidentCreated" character varying NOT NULL DEFAULT 'Pending', "subscriberNotificationStatusMessage" text, "subscriberNotificationStatusOnPostmortemPublished" character varying NOT NULL DEFAULT 'Pending')`,
+      );
+    });
+
+    afterEach(async () => {
+      if (runner?.isTransactionActive) {
+        await runner.rollbackTransaction();
+      }
+    });
+
+    afterAll(async () => {
+      if (runner) {
+        await runner.release();
+      }
+      if (database?.isInitialized) {
+        await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+        await database.destroy();
+      }
+    });
+
+    test("moves a hidden incident stuck InProgress to Skipped, with the reason", async () => {
+      const id: string = await insert({
+        isVisibleOnStatusPage: false,
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+      });
+
+      await migration.up(runner);
+
+      expect(await read(id)).toEqual({
+        _id: id,
+        isVisibleOnStatusPage: false,
+        status: StatusPageSubscriberNotificationStatus.Skipped,
+        message: IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+        postmortemStatus: StatusPageSubscriberNotificationStatus.Pending,
+      });
+    });
+
+    test("treats a NULL visibility as hidden, as the worker did", async () => {
+      const id: string = await insert({
+        isVisibleOnStatusPage: null,
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+      });
+
+      await migration.up(runner);
+
+      expect((await read(id)).status).toBe(
+        StatusPageSubscriberNotificationStatus.Skipped,
+      );
+    });
+
+    test("overwrites a stale message on the rows it settles", async () => {
+      const id: string = await insert({
+        isVisibleOnStatusPage: false,
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+        message: "Notification queued for resending",
+      });
+
+      await migration.up(runner);
+
+      expect((await read(id)).message).toBe(
+        IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+      );
+    });
+
+    test("leaves a visible incident that is InProgress alone: it may be sending right now", async () => {
+      const id: string = await insert({
+        isVisibleOnStatusPage: true,
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+      });
+
+      await migration.up(runner);
+
+      expect(await read(id)).toEqual(
+        expect.objectContaining({
+          status: StatusPageSubscriberNotificationStatus.InProgress,
+          message: null,
+        }),
+      );
+    });
+
+    test.each([
+      StatusPageSubscriberNotificationStatus.Pending,
+      StatusPageSubscriberNotificationStatus.Success,
+      StatusPageSubscriberNotificationStatus.Failed,
+      StatusPageSubscriberNotificationStatus.Skipped,
+    ])(
+      "leaves a hidden incident whose notification is %s alone",
+      async (status: StatusPageSubscriberNotificationStatus) => {
+        const id: string = await insert({
+          isVisibleOnStatusPage: false,
+          status,
+          message: "original message",
+        });
+
+        await migration.up(runner);
+
+        expect(await read(id)).toEqual(
+          expect.objectContaining({ status, message: "original message" }),
+        );
+      },
+    );
+
+    test("settles every stuck row in one pass and nothing else", async () => {
+      const stuck: Array<string> = [];
+      for (let i: number = 0; i < 5; i++) {
+        stuck.push(
+          await insert({
+            isVisibleOnStatusPage: false,
+            status: StatusPageSubscriberNotificationStatus.InProgress,
+          }),
+        );
+      }
+      const untouched: string = await insert({
+        isVisibleOnStatusPage: true,
+        status: StatusPageSubscriberNotificationStatus.Success,
+      });
+
+      await migration.up(runner);
+
+      for (const id of stuck) {
+        expect((await read(id)).status).toBe(
+          StatusPageSubscriberNotificationStatus.Skipped,
+        );
+      }
+      expect((await read(untouched)).status).toBe(
+        StatusPageSubscriberNotificationStatus.Success,
+      );
+    });
+
+    test("is safe to run twice", async () => {
+      const id: string = await insert({
+        isVisibleOnStatusPage: false,
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+      });
+
+      await migration.up(runner);
+      await migration.up(runner);
+
+      expect((await read(id)).status).toBe(
+        StatusPageSubscriberNotificationStatus.Skipped,
+      );
+    });
+
+    test("down() leaves the settled rows as they are", async () => {
+      const id: string = await insert({
+        isVisibleOnStatusPage: false,
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+      });
+
+      await migration.up(runner);
+      await migration.down(runner);
+
+      expect((await read(id)).status).toBe(
+        StatusPageSubscriberNotificationStatus.Skipped,
+      );
+    });
+  },
+);