@oneuptime/common 14.0.0 → 14.0.2

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

@@ -0,0 +1,254 @@
+import { AddOAuth2WorkflowVariables1794300000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1794300000000-AddOAuth2WorkflowVariables";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import WorkflowVariable from "../../../../Models/DatabaseModels/WorkflowVariable";
+import ColumnLength from "../../../../Types/Database/ColumnLength";
+import ColumnType from "../../../../Types/Database/ColumnType";
+import { WorkflowVariableType } from "../../../../Types/Workflow/WorkflowVariableOAuth";
+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 OAuth 2.0 workflow variables: a type column and the
+ * columns an OAuth variable keeps, on the WorkflowVariable table the initial
+ * migration created.
+ *
+ * It pins that every column is added exactly as the model declares it (a
+ * mismatch is a green deploy followed by a red Schema Drift job), that
+ * existing variables become Static without a backfill, and that down() undoes
+ * up().
+ *
+ * Fake QueryRunner only. Applying every registered migration to an empty
+ * Postgres, then this one, and generating again to "No changes in database
+ * schema were found" is how it was verified; WorkflowVariableOAuthPostgres
+ * exercises the columns against a real database.
+ */
+
+const OWN_CLASS_NAME: string = "AddOAuth2WorkflowVariables1794300000000";
+
+const MIGRATION_PATH: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+  "1794300000000-AddOAuth2WorkflowVariables.ts",
+);
+
+type TimestampOfClassNameFunction = (className: string) => number | null;
+
+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 AddOAuth2WorkflowVariables1794300000000()[direction](queryRunner);
+
+  return statements;
+};
+
+/*
+ * What each column's DDL must be, given the model. character varying(n) is
+ * varchar with a length; text, jsonb and timestamptz carry none.
+ */
+const EXPECTED_COLUMNS: Array<{ property: string; ddl: string }> = [
+  {
+    property: "variableType",
+    ddl: "character varying(100) NOT NULL DEFAULT 'Static'",
+  },
+  { property: "oauthGrantType", ddl: "character varying(100)" },
+  { property: "oauthTokenUrl", ddl: "text" },
+  { property: "oauthClientId", ddl: "character varying(500)" },
+  { property: "oauthClientSecret", ddl: "text" },
+  { property: "oauthRefreshToken", ddl: "text" },
+  { property: "oauthScope", ddl: "text" },
+  { property: "oauthAdditionalParameters", ddl: "jsonb" },
+  {
+    property: "oauthClientAuthenticationMethod",
+    ddl: "character varying(100)",
+  },
+  { property: "oauthAccessToken", ddl: "text" },
+  { property: "oauthAccessTokenExpiresAt", ddl: "TIMESTAMP WITH TIME ZONE" },
+  { property: "oauthLastRefreshedAt", ddl: "TIMESTAMP WITH TIME ZONE" },
+  { property: "oauthLastRefreshError", ddl: "text" },
+  { property: "oauthLastRefreshErrorAt", ddl: "TIMESTAMP WITH TIME ZONE" },
+];
+
+function declaredColumn(property: string): ColumnMetadataArgs {
+  const declared: ColumnMetadataArgs | undefined =
+    getMetadataArgsStorage().columns.find(
+      (column: ColumnMetadataArgs): boolean => {
+        return (
+          column.target === WorkflowVariable && column.propertyName === property
+        );
+      },
+    );
+
+  if (!declared) {
+    throw new Error(`WorkflowVariable declares no column ${property}`);
+  }
+
+  return declared;
+}
+
+const POSTGRES_SPELLING: Record<string, string> = {
+  [ColumnType.ShortText]: "character varying",
+  [ColumnType.VeryLongText]: "text",
+  [ColumnType.JSON]: "jsonb",
+  [ColumnType.Date]: "TIMESTAMP WITH TIME ZONE",
+};
+
+describe("AddOAuth2WorkflowVariables 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 AddOAuth2WorkflowVariables1794300000000().name).toBe(
+      OWN_CLASS_NAME,
+    );
+  });
+
+  test("is registered, so the columns actually reach every database", () => {
+    expect(registeredNames).toContain(OWN_CLASS_NAME);
+  });
+
+  test("its timestamp keeps it behind every migration registered before it", () => {
+    const ownIndex: number = registeredNames.indexOf(OWN_CLASS_NAME);
+
+    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([]);
+  });
+});
+
+describe("AddOAuth2WorkflowVariables migration - up()", () => {
+  test("adds exactly the new columns, in order, and nothing else", async () => {
+    expect(await recordQueries("up")).toEqual(
+      EXPECTED_COLUMNS.map((column: { property: string; ddl: string }) => {
+        return `ALTER TABLE "WorkflowVariable" ADD "${column.property}" ${column.ddl}`;
+      }),
+    );
+  });
+
+  test("adds every column the model declares that the table did not have", async () => {
+    const added: Array<string> = EXPECTED_COLUMNS.map(
+      (column: { property: string }) => {
+        return column.property;
+      },
+    );
+
+    const modelColumns: Array<string> = getMetadataArgsStorage()
+      .columns.filter((column: ColumnMetadataArgs): boolean => {
+        return (
+          column.target === WorkflowVariable &&
+          (column.propertyName.startsWith("oauth") ||
+            column.propertyName === "variableType")
+        );
+      })
+      .map((column: ColumnMetadataArgs): string => {
+        return column.propertyName;
+      });
+
+    expect([...modelColumns].sort()).toEqual([...added].sort());
+  });
+
+  test.each(EXPECTED_COLUMNS)(
+    "$property matches the column the model declares",
+    ({ property, ddl }: { property: string; ddl: string }) => {
+      const declared: ColumnMetadataArgs = declaredColumn(property);
+      const type: string = String(declared.options.type);
+
+      expect(declared.options.name).toBeUndefined();
+      expect(ddl.startsWith(POSTGRES_SPELLING[type] || "unknown")).toBe(true);
+
+      if (declared.options.length) {
+        expect(ddl).toContain(`(${declared.options.length})`);
+      }
+
+      if (property === "variableType") {
+        expect(declared.options.nullable).toBe(false);
+        expect(declared.options.default).toBe(WorkflowVariableType.Static);
+        expect(ddl).toContain("NOT NULL");
+      } else {
+        expect(declared.options.nullable).toBe(true);
+        expect(declared.options.default).toBeUndefined();
+        expect(ddl).not.toContain("NOT NULL");
+      }
+    },
+  );
+
+  test("uses the lengths ColumnLength defines", () => {
+    expect(ColumnLength.ShortText).toBe(100);
+    expect(ColumnLength.LongText).toBe(500);
+    expect(declaredColumn("oauthClientId").options.type).toBe(
+      ColumnType.LongText,
+    );
+  });
+
+  /*
+   * Every variable saved before this migration is a Static variable, and the
+   * NOT NULL DEFAULT makes it one in the same statement - no backfill, no
+   * window in which a row has no type.
+   */
+  test("turns every existing variable into a Static one without a backfill", async () => {
+    const statements: Array<string> = await recordQueries("up");
+
+    expect(statements[0]).toBe(
+      `ALTER TABLE "WorkflowVariable" ADD "variableType" character varying(100) NOT NULL DEFAULT '${WorkflowVariableType.Static}'`,
+    );
+    expect(
+      statements.some((statement: string) => {
+        return statement.startsWith("UPDATE");
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("AddOAuth2WorkflowVariables migration - down()", () => {
+  test("drops exactly the columns up() added, in reverse order", async () => {
+    expect(await recordQueries("down")).toEqual(
+      [...EXPECTED_COLUMNS].reverse().map((column: { property: string }) => {
+        return `ALTER TABLE "WorkflowVariable" DROP COLUMN "${column.property}"`;
+      }),
+    );
+  });
+});

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());
+  });
+});