@oneuptime/common 12.0.1 → 12.0.2

package/Tests/Server/Services/HookFreeWriteLengthClamp.test.ts

@@ -0,0 +1,503 @@
+import CephClusterService from "../../../Server/Services/CephClusterService";
+import CloudResourceService from "../../../Server/Services/CloudResourceService";
+import DatabaseService from "../../../Server/Services/DatabaseService";
+import DockerHostService from "../../../Server/Services/DockerHostService";
+import DockerSwarmClusterService from "../../../Server/Services/DockerSwarmClusterService";
+import HostService from "../../../Server/Services/HostService";
+import IoTFleetService from "../../../Server/Services/IoTFleetService";
+import KubernetesClusterService from "../../../Server/Services/KubernetesClusterService";
+import PodmanHostService from "../../../Server/Services/PodmanHostService";
+import ProxmoxClusterService from "../../../Server/Services/ProxmoxClusterService";
+import RumApplicationService from "../../../Server/Services/RumApplicationService";
+import ServerlessFunctionService from "../../../Server/Services/ServerlessFunctionService";
+import CephCluster from "../../../Models/DatabaseModels/CephCluster";
+import CloudResource from "../../../Models/DatabaseModels/CloudResource";
+import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import DockerHost from "../../../Models/DatabaseModels/DockerHost";
+import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
+import Host from "../../../Models/DatabaseModels/Host";
+import IoTFleet from "../../../Models/DatabaseModels/IoTFleet";
+import KubernetesCluster from "../../../Models/DatabaseModels/KubernetesCluster";
+import PodmanHost from "../../../Models/DatabaseModels/PodmanHost";
+import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import RumApplication from "../../../Models/DatabaseModels/RumApplication";
+import ServerlessFunction from "../../../Models/DatabaseModels/ServerlessFunction";
+import LogDropFilter from "../../../Models/DatabaseModels/LogDropFilter";
+import LogDropFilterService from "../../../Server/Services/LogDropFilterService";
+import ObjectID from "../../../Types/ObjectID";
+import { getMaxLengthFromTableColumnType } from "../../../Types/Database/ColumnLength";
+import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
+import { getJestSpyOn } from "../../Spy";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * Follow-up to issue #3006, one layer below where it was first fixed.
+ *
+ * The raw write paths — updateColumnsByIdWithoutHooks and
+ * atomicAddToColumnsByIdWithoutHooks — deliberately skip the whole hook
+ * pipeline, and with it checkMaxLengthOfFields. That made every caller
+ * individually responsible for not handing Postgres an over-long string,
+ * and eleven telemetry services independently forgot to be. When one
+ * oversized OpenTelemetry resource attribute reached Postgres raw, the
+ * ENTIRE statement was rejected — including the lastSeenAt /
+ * otelCollectorStatus columns riding along with it — and markDisconnected*
+ * stranded a healthy resource as "disconnected" 15 minutes later while its
+ * telemetry kept arriving.
+ *
+ * The clamp now lives inside those two methods, so a caller cannot forget
+ * it and a service added tomorrow inherits it. This suite pins that:
+ *
+ *   1. the clamp really runs inside the raw write path (asserted on the
+ *      values BOUND to the SQL, not on what the caller passed),
+ *   2. it clamps to each column's own declared width, model by model,
+ *      for every string column the updateLastSeen paths can write,
+ *   3. it touches nothing it should not — text columns, non-strings, and
+ *      the caller's own object.
+ *
+ * The repository is faked, so no Postgres and no Redis; the column
+ * metadata, the clamp and the SQL generation are all real.
+ */
+
+const ROW_ID: ObjectID = new ObjectID("11111111-1111-4111-8111-111111111111");
+
+interface CapturedQuery {
+  sql: string;
+  params: Array<unknown>;
+}
+
+/**
+ * A stand-in for the TypeORM repository that is just faithful enough for
+ * the raw write paths: real column names come from the model itself, and
+ * values are captured rather than sent anywhere.
+ */
+function fakeRepository(
+  model: DatabaseBaseModel,
+  captured: Array<CapturedQuery>,
+): unknown {
+  return {
+    metadata: {
+      tableName: model.tableName || "FakeTable",
+      findColumnWithPropertyName: (
+        propertyName: string,
+      ): { databaseName: string } | undefined => {
+        return model.hasColumn(propertyName)
+          ? { databaseName: propertyName }
+          : undefined;
+      },
+      updateDateColumn: { databaseName: "updatedAt" },
+      primaryColumns: [{ databaseName: "_id" }],
+    },
+    manager: {
+      connection: {
+        driver: {
+          preparePersistentValue: (value: unknown): unknown => {
+            return value;
+          },
+        },
+      },
+      query: async (
+        sql: string,
+        params: Array<unknown>,
+      ): Promise<Array<unknown>> => {
+        captured.push({ sql, params });
+        return [];
+      },
+    },
+  };
+}
+
+/** The width the column declares, or undefined for an unbounded one. */
+function declaredMaxLength(
+  model: DatabaseBaseModel,
+  column: string,
+): number | undefined {
+  const metadata: TableColumnMetadata = model.getTableColumnMetadata(column);
+  return metadata.type
+    ? getMaxLengthFromTableColumnType(metadata.type)
+    : undefined;
+}
+
+/*
+ * Every string column the eleven telemetry updateLastSeen paths can write.
+ * Widths are NOT hardcoded — each case reads the column's own declaration,
+ * so widening a column keeps the suite honest instead of breaking it.
+ */
+type ClampCase = {
+  name: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  service: DatabaseService<any>;
+  model: DatabaseBaseModel;
+  columns: Array<string>;
+};
+
+/*
+ * `PartialEntity<any>` degenerates to a type that rejects plain strings and
+ * dates, so the model-agnostic cases below go through this one cast rather
+ * than sprinkling casts across every call.
+ */
+async function rawWrite(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  service: DatabaseService<any>,
+  data: Record<string, unknown>,
+): Promise<void> {
+  await service.updateColumnsByIdWithoutHooks({
+    id: ROW_ID,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data: data as any,
+  });
+}
+
+const CLAMP_CASES: Array<ClampCase> = [
+  {
+    name: "HostService",
+    service: HostService,
+    model: new Host(),
+    columns: [
+      "osType",
+      "osVersion",
+      "hostId",
+      "hostArch",
+      "hostType",
+      "containerRuntime",
+      "agentVersion",
+      "deploymentEnvironment",
+      "runtimeName",
+      "runtimeVersion",
+      "cloudProvider",
+      "cloudPlatform",
+      "cloudRegion",
+      "cloudAccountId",
+    ],
+  },
+  {
+    name: "DockerHostService",
+    service: DockerHostService,
+    model: new DockerHost(),
+    columns: ["osType", "osVersion", "agentVersion"],
+  },
+  {
+    name: "PodmanHostService",
+    service: PodmanHostService,
+    model: new PodmanHost(),
+    columns: ["osType", "osVersion", "agentVersion"],
+  },
+  {
+    name: "KubernetesClusterService",
+    service: KubernetesClusterService,
+    model: new KubernetesCluster(),
+    columns: ["agentVersion"],
+  },
+  {
+    name: "ProxmoxClusterService",
+    service: ProxmoxClusterService,
+    model: new ProxmoxCluster(),
+    columns: ["pveVersion", "agentVersion"],
+  },
+  {
+    name: "IoTFleetService",
+    service: IoTFleetService,
+    model: new IoTFleet(),
+    columns: ["agentVersion"],
+  },
+  {
+    name: "DockerSwarmClusterService",
+    service: DockerSwarmClusterService,
+    model: new DockerSwarmCluster(),
+    columns: ["dockerVersion", "swarmId", "agentVersion"],
+  },
+  {
+    name: "CephClusterService",
+    service: CephClusterService,
+    model: new CephCluster(),
+    columns: ["cephVersion", "fsid", "agentVersion"],
+  },
+  {
+    name: "ServerlessFunctionService",
+    service: ServerlessFunctionService,
+    model: new ServerlessFunction(),
+    columns: [
+      "agentVersion",
+      "cloudPlatform",
+      "cloudProvider",
+      "cloudRegion",
+      "cloudAccountId",
+      "functionVersion",
+      "runtimeName",
+      "runtimeVersion",
+    ],
+  },
+  {
+    name: "CloudResourceService",
+    service: CloudResourceService,
+    model: new CloudResource(),
+    columns: [
+      "agentVersion",
+      "cloudPlatform",
+      "cloudProvider",
+      "cloudRegion",
+      "cloudAccountId",
+      "runtimeName",
+      "runtimeVersion",
+    ],
+  },
+  {
+    name: "RumApplicationService",
+    service: RumApplicationService,
+    model: new RumApplication(),
+    columns: ["agentVersion", "clientType", "sdkLanguage"],
+  },
+];
+
+describe("updateColumnsByIdWithoutHooks clamps oversized strings", () => {
+  let captured: Array<CapturedQuery>;
+
+  beforeEach(() => {
+    captured = [];
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  /** The value bound for `column` in the single captured statement. */
+  function boundValue(column: string, columns: Array<string>): unknown {
+    /*
+     * Values are bound in Object.entries order, which for these writes is
+     * insertion order — the same order the caller built the payload in.
+     */
+    return captured[0]!.params[columns.indexOf(column)];
+  }
+
+  describe.each(CLAMP_CASES)(
+    "$name",
+    ({ service, model, columns }: ClampCase) => {
+      beforeEach(() => {
+        getJestSpyOn(service, "getRepository").mockReturnValue(
+          fakeRepository(model, captured),
+        );
+      });
+
+      test.each(columns)(
+        "clamps an oversized %s to the width its column declares",
+        async (column: string) => {
+          const maxLength: number | undefined = declaredMaxLength(
+            model,
+            column,
+          );
+
+          /*
+           * A column with no declared width (text) cannot overflow, so
+           * there is nothing to clamp — that case is covered separately.
+           */
+          expect(maxLength).toBeDefined();
+
+          await rawWrite(service, {
+            [column]: "x".repeat(maxLength! + 250),
+          });
+
+          expect(boundValue(column, [column])).toHaveLength(maxLength!);
+        },
+      );
+
+      test("clamping one bad column never costs the liveness columns", async () => {
+        const column: string = columns[0]!;
+        const lastSeenAt: Date = new Date();
+
+        await rawWrite(service, {
+          lastSeenAt: lastSeenAt,
+          otelCollectorStatus: "connected",
+          [column]: "x".repeat(5000),
+        });
+
+        const order: Array<string> = [
+          "lastSeenAt",
+          "otelCollectorStatus",
+          column,
+        ];
+        expect(boundValue("lastSeenAt", order)).toBe(lastSeenAt);
+        expect(boundValue("otelCollectorStatus", order)).toBe("connected");
+        expect(captured).toHaveLength(1);
+      });
+
+      test("a value that already fits is bound byte-for-byte", async () => {
+        const column: string = columns[0]!;
+
+        await rawWrite(service, { [column]: "fits-easily" });
+
+        expect(boundValue(column, [column])).toBe("fits-easily");
+      });
+
+      test("the caller's own object is not mutated", async () => {
+        const column: string = columns[0]!;
+        const original: string = "x".repeat(5000);
+        const data: Record<string, unknown> = { [column]: original };
+
+        await rawWrite(service, data);
+
+        expect(data[column]).toBe(original);
+      });
+    },
+  );
+});
+
+describe("updateColumnsByIdWithoutHooks clamp boundaries", () => {
+  let captured: Array<CapturedQuery>;
+  const host: Host = new Host();
+
+  beforeEach(() => {
+    captured = [];
+    getJestSpyOn(HostService, "getRepository").mockReturnValue(
+      fakeRepository(host, captured),
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("binds a 55-address host.ip list whole — the column is text now", async () => {
+    const hostIpAddresses: string = Array.from(
+      { length: 55 },
+      (_unused: unknown, i: number) => {
+        return `fe80::42:acff:fe11:${(0x1000 + i).toString(16)}`;
+      },
+    ).join(", ");
+
+    await HostService.updateColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      data: { hostIpAddresses: hostIpAddresses },
+    });
+
+    expect(hostIpAddresses.length).toBeGreaterThan(500);
+    expect(captured[0]!.params[0]).toBe(hostIpAddresses);
+  });
+
+  test("a value exactly at the limit is left alone", async () => {
+    const exact: string = "l".repeat(declaredMaxLength(host, "osType")!);
+
+    await HostService.updateColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      data: { osType: exact },
+    });
+
+    expect(captured[0]!.params[0]).toBe(exact);
+  });
+
+  test("a clamped value stays a prefix of the original", async () => {
+    const original: string = "abcdefghij".repeat(40);
+
+    await HostService.updateColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      data: { osType: original },
+    });
+
+    expect(original.startsWith(captured[0]!.params[0] as string)).toBe(true);
+  });
+
+  test("non-string values pass through untouched", async () => {
+    const lastSeenAt: Date = new Date();
+
+    await HostService.updateColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      data: {
+        lastSeenAt: lastSeenAt,
+        cpuCores: 64,
+        totalMemoryBytes: 274877906944,
+      },
+    });
+
+    expect(captured[0]!.params.slice(0, 3)).toEqual([
+      lastSeenAt,
+      64,
+      274877906944,
+    ]);
+  });
+
+  test("an unknown column is still rejected, not silently clamped away", async () => {
+    await expect(
+      HostService.updateColumnsByIdWithoutHooks({
+        id: ROW_ID,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        data: { notAColumn: "z".repeat(5000) } as any,
+      }),
+    ).rejects.toThrow("unknown column");
+  });
+
+  test("the clamp does not disturb the primary-key predicate", async () => {
+    await HostService.updateColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      data: { osType: "l".repeat(5000) },
+    });
+
+    expect(captured[0]!.sql).toMatch(/WHERE "_id" = \$\d+$/);
+    expect(captured[0]!.params[captured[0]!.params.length - 1]).toBe(
+      ROW_ID.toString(),
+    );
+  });
+});
+
+/*
+ * The counter-flush primitive is the other raw path, and it has exactly the
+ * same exposure: an over-long string in `set` would abort the increments
+ * bound into the same statement.
+ */
+describe("atomicAddToColumnsByIdWithoutHooks clamps its set values", () => {
+  let captured: Array<CapturedQuery>;
+  const model: LogDropFilter = new LogDropFilter();
+
+  beforeEach(() => {
+    captured = [];
+    getJestSpyOn(LogDropFilterService, "getRepository").mockReturnValue(
+      fakeRepository(model, captured),
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("clamps an oversized set value to its declared width", async () => {
+    const maxLength: number = declaredMaxLength(model, "name")!;
+
+    await LogDropFilterService.atomicAddToColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      add: { droppedCount: 5 },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      set: { name: "n".repeat(maxLength + 250) } as any,
+    });
+
+    // params: [delta, set value, ...]
+    expect(captured[0]!.params[1]).toHaveLength(maxLength);
+  });
+
+  test("leaves the numeric delta alone", async () => {
+    await LogDropFilterService.atomicAddToColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      add: { droppedCount: 7 },
+    });
+
+    expect(captured[0]!.params[0]).toBe(7);
+    expect(captured[0]!.sql).toContain("COALESCE");
+  });
+
+  test("does not mutate the caller's set object", async () => {
+    const original: string = "n".repeat(5000);
+    const set: Record<string, unknown> = { name: original };
+
+    await LogDropFilterService.atomicAddToColumnsByIdWithoutHooks({
+      id: ROW_ID,
+      add: { droppedCount: 1 },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      set: set as any,
+    });
+
+    expect(set["name"]).toBe(original);
+  });
+});

package/Tests/Server/Services/HostIpAddressesColumnWidth.test.ts

@@ -0,0 +1,198 @@
+import Host from "../../../Models/DatabaseModels/Host";
+import { AddHostIpAddresses1778013317872 } from "../../../Server/Infrastructure/Postgres/SchemaMigrations/1778013317872-AddHostIpAddresses";
+import { IncreaseHostIpAddressesLength1785915638551 } from "../../../Server/Infrastructure/Postgres/SchemaMigrations/1785915638551-IncreaseHostIpAddressesLength";
+import SchemaMigrations from "../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import ColumnType from "../../../Types/Database/ColumnType";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import { getMaxLengthFromTableColumnType } from "../../../Types/Database/ColumnLength";
+import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
+import { QueryRunner, getMetadataArgsStorage } from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Issue #3006: Host.hostIpAddresses was character varying(500). The OTel
+ * `host.ip` resource attribute is an ARRAY of every address on every
+ * interface, and a Docker host with IPv6 enabled reported 55 of them
+ * (~1450 characters). The overflow aborted the whole Host metadata UPDATE
+ * — which also carries lastSeenAt and otelCollectorStatus — so a host with
+ * healthy, still-arriving telemetry was displayed as "Disconnected".
+ *
+ * Three things have to line up for the fix to hold, and a regression in any
+ * one of them silently reintroduces the bug:
+ *   1. the entity declares a `text` column (no max length),
+ *   2. the migration actually widens the existing column in Postgres, and
+ *      its down() can narrow back without exploding on rows written since,
+ *   3. the migration is registered in SchemaMigrations/Index.ts — an
+ *      unregistered migration is dead code that never runs on boot.
+ *
+ * Pure metadata/mocks — no Postgres connection anywhere.
+ */
+
+function hostIpColumnArgs(): ColumnMetadataArgs {
+  const args: ColumnMetadataArgs | undefined = getMetadataArgsStorage()
+    .columns.filter((column: ColumnMetadataArgs) => {
+      return column.target === Host;
+    })
+    .find((column: ColumnMetadataArgs) => {
+      return column.propertyName === "hostIpAddresses";
+    });
+
+  if (!args) {
+    throw new Error("Host.hostIpAddresses has no TypeORM @Column metadata");
+  }
+
+  return args;
+}
+
+function makeQueryRunner(): { runner: QueryRunner; query: jest.Mock } {
+  const query: jest.Mock = jest.fn().mockResolvedValue(undefined);
+  return { runner: { query } as unknown as QueryRunner, query };
+}
+
+function executedSql(query: jest.Mock): Array<string> {
+  return query.mock.calls.map((call: Array<unknown>) => {
+    return String(call[0]);
+  });
+}
+
+describe("Host.hostIpAddresses entity declaration", () => {
+  test("is a text column, not a bounded varchar", () => {
+    expect(hostIpColumnArgs().options.type).toBe(ColumnType.VeryLongText);
+    expect(ColumnType.VeryLongText).toBe("text");
+  });
+
+  test("declares no length — a length on a text column is what regenerates drift", () => {
+    expect(hostIpColumnArgs().options.length).toBeUndefined();
+  });
+
+  test("is still nullable, so hosts that report no host.ip are unaffected", () => {
+    expect(hostIpColumnArgs().options.nullable).toBe(true);
+  });
+
+  test("its TableColumn type is VeryLongText", () => {
+    const metadata: TableColumnMetadata = new Host().getTableColumnMetadata(
+      "hostIpAddresses",
+    );
+    expect(metadata.type).toBe(TableColumnType.VeryLongText);
+  });
+
+  test("has no max length, so DatabaseService length validation cannot reject a long IP list", () => {
+    const metadata: TableColumnMetadata = new Host().getTableColumnMetadata(
+      "hostIpAddresses",
+    );
+    expect(getMaxLengthFromTableColumnType(metadata.type)).toBeUndefined();
+  });
+
+  test("would have been rejected under the old LongText declaration", () => {
+    /*
+     * Guards the premise of the fix: 500 really was the bound that the
+     * reported ~1450-character payload blew through.
+     */
+    expect(getMaxLengthFromTableColumnType(TableColumnType.LongText)).toBe(500);
+  });
+
+  test("is still readable on relation queries and optional", () => {
+    const metadata: TableColumnMetadata = new Host().getTableColumnMetadata(
+      "hostIpAddresses",
+    );
+    expect(metadata.canReadOnRelationQuery).toBe(true);
+    expect(metadata.required).toBeFalsy();
+  });
+});
+
+describe("IncreaseHostIpAddressesLength1785915638551 SQL contract", () => {
+  const migration: IncreaseHostIpAddressesLength1785915638551 =
+    new IncreaseHostIpAddressesLength1785915638551();
+
+  test("up() widens the column to text in a single statement", async () => {
+    const { runner, query } = makeQueryRunner();
+    await migration.up(runner);
+
+    expect(executedSql(query)).toEqual([
+      `ALTER TABLE "Host" ALTER COLUMN "hostIpAddresses" TYPE text`,
+    ]);
+  });
+
+  test("up() touches no other table or column", async () => {
+    const { runner, query } = makeQueryRunner();
+    await migration.up(runner);
+
+    for (const sql of executedSql(query)) {
+      expect(sql).toContain(`"Host"`);
+      expect(sql).toContain(`"hostIpAddresses"`);
+      expect(sql).not.toContain("DROP");
+    }
+  });
+
+  test("down() clips oversized rows BEFORE narrowing, so the revert cannot fail", async () => {
+    const { runner, query } = makeQueryRunner();
+    await migration.down(runner);
+
+    const statements: Array<string> = executedSql(query);
+    expect(statements).toHaveLength(2);
+
+    const [clip, narrow] = statements as [string, string];
+    expect(clip).toContain("UPDATE");
+    expect(clip).toContain("LEFT");
+    expect(clip).toContain("500");
+    expect(narrow).toBe(
+      `ALTER TABLE "Host" ALTER COLUMN "hostIpAddresses" TYPE character varying(500)`,
+    );
+  });
+
+  test("down() restores exactly the width the original migration created", async () => {
+    const addColumn: AddHostIpAddresses1778013317872 =
+      new AddHostIpAddresses1778013317872();
+    const { runner: addRunner, query: addQuery } = makeQueryRunner();
+    await addColumn.up(addRunner);
+
+    const { runner: downRunner, query: downQuery } = makeQueryRunner();
+    await migration.down(downRunner);
+
+    // The ADD used "character varying(500)"; the revert must land on the same.
+    expect(executedSql(addQuery).join("\n")).toContain(
+      "character varying(500)",
+    );
+    expect(executedSql(downQuery).join("\n")).toContain(
+      "character varying(500)",
+    );
+  });
+
+  test("the class name carries its own timestamp, matching the file name", () => {
+    expect(migration.name).toBe("IncreaseHostIpAddressesLength1785915638551");
+  });
+});
+
+describe("IncreaseHostIpAddressesLength1785915638551 registration", () => {
+  test("is registered in SchemaMigrations/Index.ts", () => {
+    expect(SchemaMigrations).toContain(
+      IncreaseHostIpAddressesLength1785915638551,
+    );
+  });
+
+  test("is registered exactly once", () => {
+    const occurrences: number = SchemaMigrations.filter(
+      (migration: unknown) => {
+        return migration === IncreaseHostIpAddressesLength1785915638551;
+      },
+    ).length;
+    expect(occurrences).toBe(1);
+  });
+
+  test("runs after the migration that created the column", () => {
+    /*
+     * TypeORM executes registered migrations in array order. Widening a
+     * column that does not exist yet fails, so the ADD must come first.
+     */
+    const addIndex: number = SchemaMigrations.indexOf(
+      AddHostIpAddresses1778013317872,
+    );
+    const widenIndex: number = SchemaMigrations.indexOf(
+      IncreaseHostIpAddressesLength1785915638551,
+    );
+
+    expect(addIndex).toBeGreaterThanOrEqual(0);
+    expect(widenIndex).toBeGreaterThan(addIndex);
+  });
+});