@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

package/src/core/post-diff-normalization.ts

@@ -0,0 +1,296 @@
+import type { Change } from "./change.types.ts";
+import { CreateIndex } from "./objects/index/changes/index.create.ts";
+import { DropIndex } from "./objects/index/changes/index.drop.ts";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
+import {
+  AlterTableAddConstraint,
+  AlterTableDropColumn,
+  AlterTableDropConstraint,
+  AlterTableSetReplicaIdentity,
+  AlterTableValidateConstraint,
+} from "./objects/table/changes/table.alter.ts";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.ts";
+import type { Table } from "./objects/table/table.model.ts";
+import { stableId } from "./objects/utils.ts";
+
+function constraintStableId(
+  table: { schema: string; name: string },
+  constraintName: string,
+) {
+  return stableId.constraint(table.schema, table.name, constraintName);
+}
+
+function isSupersededByTableReplacement(
+  change: Change,
+  replacedTableIds: ReadonlySet<string>,
+): boolean {
+  if (
+    change instanceof AlterTableDropColumn ||
+    change instanceof AlterTableDropConstraint
+  ) {
+    return replacedTableIds.has(change.table.stableId);
+  }
+
+  // `DropSequence(S)` is superseded when S is OWNED BY a column on a table
+  // that `expandReplaceDependencies` has promoted to `DropTable + CreateTable`
+  // in the same plan. PostgreSQL cascade-drops the OWNED BY sequence as part
+  // of the DROP TABLE, so the explicit DROP SEQUENCE is redundant and — more
+  // importantly — closes an unbreakable `DropSequence ↔ DropTable` cycle in
+  // the drop phase via the bidirectional pg_depend edges between the
+  // sequence and its owning column (`column → sequence` for the DEFAULT
+  // nextval reference, `sequence → column` for the OWNED BY auto-dependency).
+  // The alpha.15 short-circuit in `diffSequences.dropped` only suppresses
+  // `DropSequence` when the owning table itself is gone from `branchTables`;
+  // here the table survives in branch and the replacement is added later by
+  // the expander, so this whole-plan rewrite has to happen post-diff.
+  if (change instanceof DropSequence) {
+    if (
+      !change.sequence.owned_by_schema ||
+      !change.sequence.owned_by_table ||
+      !change.sequence.owned_by_column
+    ) {
+      return false;
+    }
+    const ownedByTableId = stableId.table(
+      change.sequence.owned_by_schema,
+      change.sequence.owned_by_table,
+    );
+    return replacedTableIds.has(ownedByTableId);
+  }
+
+  return false;
+}
+
+/**
+ * Drop earlier duplicates of `AlterTableAddConstraint` /
+ * `AlterTableValidateConstraint` / `CreateCommentOnConstraint` targeting
+ * replaced tables, keeping only the last occurrence of each
+ * `(changeType, table.stableId, constraint.name)`.
+ *
+ * When `expandReplaceDependencies()` promotes a table to a full
+ * `DropTable + CreateTable` pair, it also emits one
+ * `AlterTableAddConstraint` (plus optional `VALIDATE CONSTRAINT` /
+ * `COMMENT ON CONSTRAINT`) per branch constraint. If `diffTables()` already
+ * emitted the same change for a shape flip or a new constraint on that
+ * table, the plan ends up with two identical `ALTER TABLE ... ADD
+ * CONSTRAINT ...` statements and PostgreSQL fails at apply time with
+ * `constraint "..." for relation "..." already exists`. Because
+ * `expandReplaceDependencies()` appends its additions after the original
+ * `diffTables()` output, the last occurrence is the expansion's emission —
+ * keeping it preserves correctness while removing the duplicate.
+ */
+function dropReplacedTableDuplicateConstraintChanges(
+  changes: Change[],
+  replacedTableIds: ReadonlySet<string>,
+): Change[] {
+  if (replacedTableIds.size === 0) return changes;
+
+  const keyFor = (change: Change): string | null => {
+    if (
+      !(change instanceof AlterTableAddConstraint) &&
+      !(change instanceof AlterTableValidateConstraint) &&
+      !(change instanceof CreateCommentOnConstraint)
+    ) {
+      return null;
+    }
+    if (!replacedTableIds.has(change.table.stableId)) return null;
+    const tag =
+      change instanceof AlterTableAddConstraint
+        ? "add"
+        : change instanceof AlterTableValidateConstraint
+          ? "validate"
+          : "comment";
+    return `${tag}:${constraintStableId(change.table, change.constraint.name)}`;
+  };
+
+  const seen = new Set<string>();
+  const reversedKept: Change[] = [];
+  let mutated = false;
+
+  // Walk backwards: the first encounter of each key corresponds to its LAST
+  // occurrence in the original order. `expandReplaceDependencies()` appends
+  // additions after the original changes, so "last wins" keeps the
+  // expansion's emission and drops the earlier diffTables duplicate.
+  for (let i = changes.length - 1; i >= 0; i--) {
+    const change = changes[i] as Change;
+    const key = keyFor(change);
+    if (key !== null) {
+      if (seen.has(key)) {
+        mutated = true;
+        continue;
+      }
+      seen.add(key);
+    }
+    reversedKept.push(change);
+  }
+
+  return mutated ? reversedKept.reverse() : changes;
+}
+
+/**
+ * Re-emit `ALTER TABLE ... REPLICA IDENTITY USING INDEX <idx>` after any
+ * `DropIndex(idx) + CreateIndex(idx)` pair where `idx` is the replica-identity
+ * index of a branch table.
+ *
+ * Background: PostgreSQL silently flips a table's `relreplident` to `'d'`
+ * (DEFAULT) when the index it points to is dropped. `CREATE INDEX` cannot
+ * restore the marker — only `ALTER TABLE ... REPLICA IDENTITY USING INDEX`
+ * can. When both main and branch carry `replica_identity = 'i'` pointing at
+ * the same index name, `diffTables()` emits no replica-identity change of its
+ * own, so the marker would be lost on apply.
+ *
+ * This is a whole-plan interaction: `diffTables()` cannot detect it without
+ * also looking at index changes. Per the "whole-plan interactions belong in
+ * post-diff normalization" rule in the package CLAUDE.md, the restoration
+ * lives here.
+ *
+ * Insertion is idempotent: if `diffTables()` already emitted the same
+ * `AlterTableSetReplicaIdentity` for this table (e.g. when the user is also
+ * switching the replica-identity index name in the same migration), no
+ * duplicate is added.
+ */
+function restoreReplicaIdentityAfterIndexReplace(
+  changes: Change[],
+  branchTables: Record<string, Table>,
+): Change[] {
+  // Build the index-stable-id → owning-table map from branch state. Only
+  // tables in 'i' mode contribute, and only those whose configured index name
+  // is non-null (the extractor returns null for any other mode).
+  const replicaIdentityIndexToTable = new Map<string, Table>();
+  for (const table of Object.values(branchTables)) {
+    if (table.replica_identity !== "i" || !table.replica_identity_index) {
+      continue;
+    }
+    const indexId = stableId.index(
+      table.schema,
+      table.name,
+      table.replica_identity_index,
+    );
+    replicaIdentityIndexToTable.set(indexId, table);
+  }
+  if (replicaIdentityIndexToTable.size === 0) return changes;
+
+  // Find the indexes that are both dropped AND created in this plan. A pure
+  // drop or a pure create is handled by `diffTables()` directly (the table's
+  // replica_identity / replica_identity_index fields will have changed). The
+  // hole is specifically the drop+create pair that recreates the same name.
+  const droppedIndexIds = new Set<string>();
+  const createdIndexIds = new Set<string>();
+  for (const change of changes) {
+    if (change instanceof DropIndex) {
+      droppedIndexIds.add(change.index.stableId);
+    } else if (change instanceof CreateIndex) {
+      createdIndexIds.add(change.index.stableId);
+    }
+  }
+  const replacedIndexIds = new Set<string>();
+  for (const id of droppedIndexIds) {
+    if (createdIndexIds.has(id) && replicaIdentityIndexToTable.has(id)) {
+      replacedIndexIds.add(id);
+    }
+  }
+  if (replacedIndexIds.size === 0) return changes;
+
+  // Skip tables for which `diffTables()` already emitted a replica-identity
+  // setter — re-emitting would produce a redundant ALTER TABLE (harmless on
+  // apply, but noisy in plan output).
+  const tablesWithExistingReplicaIdentitySetter = new Set<string>();
+  for (const change of changes) {
+    if (change instanceof AlterTableSetReplicaIdentity) {
+      tablesWithExistingReplicaIdentitySetter.add(change.table.stableId);
+    }
+  }
+
+  // Insert one `AlterTableSetReplicaIdentity` per replaced index, immediately
+  // after the matching `CreateIndex`. The change's `requires` already names
+  // both the table and the recreated index, so the topo sort orders it
+  // correctly relative to the surrounding DDL.
+  const result: Change[] = [];
+  for (const change of changes) {
+    result.push(change);
+    if (
+      !(change instanceof CreateIndex) ||
+      !replacedIndexIds.has(change.index.stableId)
+    ) {
+      continue;
+    }
+    const table = replicaIdentityIndexToTable.get(change.index.stableId);
+    if (!table) continue;
+    if (tablesWithExistingReplicaIdentitySetter.has(table.stableId)) continue;
+
+    result.push(
+      new AlterTableSetReplicaIdentity({
+        table,
+        mode: "i",
+        indexName: table.replica_identity_index,
+      }),
+    );
+    // Mark as emitted so a second replaced index on the same table — if that
+    // ever arises — doesn't double-emit.
+    tablesWithExistingReplicaIdentitySetter.add(table.stableId);
+  }
+
+  return result;
+}
+
+/**
+ * Apply structural rewrites to the change list that are only obvious once
+ * every object diff has been collected. This pass does NOT prevent dependency
+ * cycles — that responsibility now lives in the sort phase, where
+ * `sortPhaseChanges` invokes `tryBreakCycleByChangeInjection` lazily on cycles
+ * that edge filtering can't break (FK SCC of dropped tables,
+ * AlterPublicationDropTables ↔ AlterTableDropColumn, …).
+ *
+ * Concretely, this pass:
+ *
+ * - Prunes `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)`
+ *   changes that are made redundant by an expansion-emitted
+ *   `DropTable(T) + CreateTable(T)` pair. Without this, the apply phase
+ *   would try to drop a column that no longer exists in the freshly
+ *   recreated table.
+ * - Prunes `DropSequence(S)` changes when `S` is `OWNED BY` a column on a
+ *   table promoted to `DropTable + CreateTable` by the expander. The
+ *   `DROP TABLE` cascade drops the sequence at apply time; emitting an
+ *   explicit `DROP SEQUENCE` in the same drop phase both duplicates the
+ *   cascade and forms an unbreakable `DropSequence ↔ DropTable` cycle on
+ *   the bidirectional pg_depend edges between the sequence and the
+ *   owning column.
+ * - Dedupes duplicate `AlterTableAddConstraint` /
+ *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
+ *   produced when `diffTables()` and `expandReplaceDependencies()` both
+ *   emit the same constraint operation for a replaced table. Last write
+ *   wins so the expansion's emission survives.
+ * - Re-emits `ALTER TABLE ... REPLICA IDENTITY USING INDEX <idx>` after any
+ *   `DropIndex(idx) + CreateIndex(idx)` pair where `idx` is the replica
+ *   identity index of a branch table — Postgres silently clears the marker
+ *   when the underlying index is dropped, and `CREATE INDEX` cannot restore
+ *   it.
+ *
+ * Object-local PostgreSQL semantics (for example owned-sequence cascades)
+ * stay in the corresponding `diff*` function instead of this pass.
+ */
+export function normalizePostDiffChanges({
+  changes,
+  replacedTableIds = new Set<string>(),
+  branchTables = {},
+}: {
+  changes: Change[];
+  replacedTableIds?: ReadonlySet<string>;
+  branchTables?: Record<string, Table>;
+}): Change[] {
+  const restoredChanges = restoreReplicaIdentityAfterIndexReplace(
+    changes,
+    branchTables,
+  );
+
+  const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(
+    restoredChanges,
+    replacedTableIds,
+  );
+
+  if (replacedTableIds.size === 0) return dedupedChanges;
+
+  return dedupedChanges.filter(
+    (change) => !isSupersededByTableReplacement(change, replacedTableIds),
+  );
+}

package/src/core/postgres-config.test.ts

@@ -0,0 +1,374 @@
+import { describe, expect, spyOn, test } from "bun:test";
+import {
+  connectWithRetry,
+  connectWithTimeout,
+  isRetryableConnectError,
+  poolConfigFromUrl,
+} from "./postgres-config.ts";
+
+function makeError(message: string, code?: string): Error {
+  const err = new Error(message) as Error & { code?: string };
+  if (code !== undefined) err.code = code;
+  return err;
+}
+
+describe("isRetryableConnectError", () => {
+  describe("non-retryable", () => {
+    test("PG auth code 28P01", () => {
+      expect(
+        isRetryableConnectError(makeError("password auth failed", "28P01")),
+      ).toBe(false);
+    });
+
+    test("PG auth code 28000", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("invalid authorization specification", "28000"),
+        ),
+      ).toBe(false);
+    });
+
+    test("ENOTFOUND (permanent DNS failure)", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("getaddrinfo ENOTFOUND bogus.host", "ENOTFOUND"),
+        ),
+      ).toBe(false);
+    });
+
+    test("TLS error via code (ERR_TLS_*)", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("TLS failure", "ERR_TLS_CERT_ALTNAME_INVALID"),
+        ),
+      ).toBe(false);
+    });
+
+    test("TLS error via message marker", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("self-signed certificate in certificate chain"),
+        ),
+      ).toBe(false);
+    });
+
+    test("SSL error via message marker", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("SSL connection has been closed unexpectedly"),
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe("retryable", () => {
+    test("ECONNRESET", () => {
+      expect(
+        isRetryableConnectError(makeError("socket hang up", "ECONNRESET")),
+      ).toBe(true);
+    });
+
+    test("ECONNREFUSED", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("connect ECONNREFUSED", "ECONNREFUSED"),
+        ),
+      ).toBe(true);
+    });
+
+    test("ETIMEDOUT", () => {
+      expect(
+        isRetryableConnectError(makeError("connect ETIMEDOUT", "ETIMEDOUT")),
+      ).toBe(true);
+    });
+
+    test("EAI_AGAIN (transient DNS)", () => {
+      expect(
+        isRetryableConnectError(
+          makeError("getaddrinfo EAI_AGAIN db.host", "EAI_AGAIN"),
+        ),
+      ).toBe(true);
+    });
+
+    test("our own eager-connect timeout wrapper", () => {
+      expect(
+        isRetryableConnectError(
+          new Error(
+            "Connection to target database timed out after 2500ms. " +
+              "The server may require SSL, use an invalid certificate, or be unreachable.",
+          ),
+        ),
+      ).toBe(true);
+    });
+
+    test("unknown generic Error is transient-by-default", () => {
+      expect(isRetryableConnectError(new Error("something weird"))).toBe(true);
+    });
+
+    test("non-Error values are transient-by-default", () => {
+      expect(isRetryableConnectError("string error")).toBe(true);
+      expect(isRetryableConnectError({ reason: "x" })).toBe(true);
+      expect(isRetryableConnectError(undefined)).toBe(true);
+    });
+  });
+});
+
+describe("connectWithRetry", () => {
+  const noSleep = async (_ms: number) => {
+    // no-op sleep to keep tests fast
+  };
+
+  test("resolves on first attempt without retrying", async () => {
+    let attempts = 0;
+    const result = await connectWithRetry({
+      connect: async () => {
+        attempts++;
+        return "ok" as const;
+      },
+      sleep: noSleep,
+    });
+    expect(result).toBe("ok");
+    expect(attempts).toBe(1);
+  });
+
+  test("retries a retryable error until success", async () => {
+    let attempts = 0;
+    const result = await connectWithRetry({
+      connect: async () => {
+        attempts++;
+        if (attempts < 3) {
+          throw makeError("connect ECONNREFUSED", "ECONNREFUSED");
+        }
+        return "ok" as const;
+      },
+      maxAttempts: 5,
+      sleep: noSleep,
+    });
+    expect(result).toBe("ok");
+    expect(attempts).toBe(3);
+  });
+
+  test("honours maxAttempts and throws the last error", async () => {
+    let attempts = 0;
+    const boom = makeError("connect ECONNREFUSED", "ECONNREFUSED");
+    await expect(
+      connectWithRetry({
+        connect: async () => {
+          attempts++;
+          throw boom;
+        },
+        maxAttempts: 4,
+        sleep: noSleep,
+      }),
+    ).rejects.toBe(boom);
+    expect(attempts).toBe(4);
+  });
+
+  test("stops immediately on a non-retryable error", async () => {
+    let attempts = 0;
+    const authError = makeError("password authentication failed", "28P01");
+    await expect(
+      connectWithRetry({
+        connect: async () => {
+          attempts++;
+          throw authError;
+        },
+        maxAttempts: 10,
+        sleep: noSleep,
+      }),
+    ).rejects.toBe(authError);
+    expect(attempts).toBe(1);
+  });
+
+  test("uses exponential backoff: 250ms, 500ms (3 attempts)", async () => {
+    const delays: number[] = [];
+    let attempts = 0;
+    await expect(
+      connectWithRetry({
+        connect: async () => {
+          attempts++;
+          throw makeError("connect ECONNREFUSED", "ECONNREFUSED");
+        },
+        maxAttempts: 3,
+        baseBackoffMs: 250,
+        maxBackoffMs: 1000,
+        sleep: async (ms) => {
+          delays.push(ms);
+        },
+      }),
+    ).rejects.toBeDefined();
+    expect(attempts).toBe(3);
+    // Sleep is invoked once after attempt 1 and once after attempt 2;
+    // the final failure throws without sleeping.
+    expect(delays).toEqual([250, 500]);
+  });
+
+  test("caps backoff at maxBackoffMs", async () => {
+    const delays: number[] = [];
+    await expect(
+      connectWithRetry({
+        connect: async () => {
+          throw makeError("connect ECONNREFUSED", "ECONNREFUSED");
+        },
+        maxAttempts: 5,
+        baseBackoffMs: 250,
+        maxBackoffMs: 600,
+        sleep: async (ms) => {
+          delays.push(ms);
+        },
+      }),
+    ).rejects.toBeDefined();
+    // Uncapped would be [250, 500, 1000, 2000]; the 1000/2000 values are
+    // both capped to 600.
+    expect(delays).toEqual([250, 500, 600, 600]);
+  });
+
+  test("injected isRetryable overrides the default predicate", async () => {
+    let attempts = 0;
+    const err = new Error("custom transient");
+    const neverRetry = () => false;
+    await expect(
+      connectWithRetry({
+        connect: async () => {
+          attempts++;
+          throw err;
+        },
+        maxAttempts: 5,
+        isRetryable: neverRetry,
+        sleep: noSleep,
+      }),
+    ).rejects.toBe(err);
+    expect(attempts).toBe(1);
+  });
+});
+
+describe("connectWithTimeout", () => {
+  test("clears the timer when connect resolves before it fires", async () => {
+    const clearSpy = spyOn(globalThis, "clearTimeout");
+    try {
+      const sentinel = { client: true };
+      const result = await connectWithTimeout(
+        () => Promise.resolve(sentinel),
+        60_000,
+        "source",
+      );
+      expect(result).toBe(sentinel);
+      expect(clearSpy).toHaveBeenCalled();
+    } finally {
+      clearSpy.mockRestore();
+    }
+  });
+
+  test("rejects with a timeout error when connect is too slow", async () => {
+    await expect(
+      connectWithTimeout(() => new Promise<never>(() => {}), 5, "target"),
+    ).rejects.toThrow(/timed out after 5ms/);
+  });
+
+  test("clears the timer even when connect rejects", async () => {
+    const clearSpy = spyOn(globalThis, "clearTimeout");
+    try {
+      const boom = new Error("connect ECONNREFUSED");
+      await expect(
+        connectWithTimeout(() => Promise.reject(boom), 60_000, "target"),
+      ).rejects.toBe(boom);
+      expect(clearSpy).toHaveBeenCalled();
+    } finally {
+      clearSpy.mockRestore();
+    }
+  });
+});
+
+describe("poolConfigFromUrl", () => {
+  describe("non-IPv6 URLs pass through as connectionString", () => {
+    test("DNS hostname", () => {
+      const url = "postgresql://user:pass@db.example.com:5432/mydb";
+      expect(poolConfigFromUrl(url)).toEqual({ connectionString: url });
+    });
+
+    test("IPv4 host", () => {
+      const url = "postgresql://user:pass@127.0.0.1:5432/mydb";
+      expect(poolConfigFromUrl(url)).toEqual({ connectionString: url });
+    });
+
+    test("DNS hostname with query params", () => {
+      const url =
+        "postgresql://user:pass@db.example.com:5432/mydb?application_name=test";
+      expect(poolConfigFromUrl(url)).toEqual({ connectionString: url });
+    });
+  });
+
+  describe("bracketed IPv6 URLs expand to explicit fields with no brackets", () => {
+    test("full 8-group IPv6 — host has no brackets and no connectionString", () => {
+      const url =
+        "postgresql://user:pass@[2600:1f16:1cd0:3340:f92e:f4cb:7a52:10a1]:5432/mydb";
+      const config = poolConfigFromUrl(url);
+      expect(config.connectionString).toBeUndefined();
+      expect(config.host).toBe("2600:1f16:1cd0:3340:f92e:f4cb:7a52:10a1");
+      expect(config.port).toBe(5432);
+      expect(config.user).toBe("user");
+      expect(config.password).toBe("pass");
+      expect(config.database).toBe("mydb");
+    });
+
+    test("compressed ::1 form", () => {
+      const url = "postgresql://user:pass@[::1]:5432/mydb";
+      const config = poolConfigFromUrl(url);
+      expect(config.host).toBe("::1");
+      expect(config.port).toBe(5432);
+    });
+
+    test("host bracket strip survives percent-decoded username/password", () => {
+      const url = "postgresql://user:p%40ss%2Fword@[::1]:5432/mydb";
+      const config = poolConfigFromUrl(url);
+      expect(config.host).toBe("::1");
+      expect(config.user).toBe("user");
+      expect(config.password).toBe("p@ss/word");
+    });
+
+    test("works without port", () => {
+      const url = "postgresql://user:pass@[::1]/mydb";
+      const config = poolConfigFromUrl(url);
+      expect(config.host).toBe("::1");
+      expect(config.port).toBeUndefined();
+    });
+
+    test("works without database (pathname='/')", () => {
+      const url = "postgresql://user:pass@[::1]:5432/";
+      const config = poolConfigFromUrl(url);
+      expect(config.host).toBe("::1");
+      expect(config.database).toBeUndefined();
+    });
+
+    test("works without userinfo", () => {
+      const url = "postgresql://[::1]:5432/mydb";
+      const config = poolConfigFromUrl(url);
+      expect(config.host).toBe("::1");
+      expect(config.user).toBeUndefined();
+      expect(config.password).toBeUndefined();
+    });
+
+    test("query params are forwarded as top-level config keys", () => {
+      const url =
+        "postgresql://user:pass@[::1]:5432/mydb?application_name=pgdelta&connect_timeout=5";
+      const config = poolConfigFromUrl(url) as unknown as Record<
+        string,
+        unknown
+      >;
+      expect(config.application_name).toBe("pgdelta");
+      expect(config.connect_timeout).toBe("5");
+      expect(config.host).toBe("::1");
+    });
+
+    test("IPv4-mapped IPv6 is stripped of brackets (WHATWG canonicalisation is fine)", () => {
+      // WHATWG URL canonicalises `::ffff:192.0.2.1` to `::ffff:c000:201`;
+      // either form resolves to the same IPv6 address, and the point of this
+      // test is purely that no brackets escape to pg.
+      const url = "postgresql://user:pass@[::ffff:192.0.2.1]:5432/mydb";
+      const config = poolConfigFromUrl(url);
+      expect(config.host).not.toContain("[");
+      expect(config.host).not.toContain("]");
+      expect(config.host).toBe("::ffff:c000:201");
+    });
+  });
+});