{

private ?Capsule $capsule = null;

private PostgresAdapter $adapter;

private string $database = 'dbdiff_pgdump_test';

protected function setUp(): void

{

$host = getenv('DB_HOST_POSTGRES') ?: getenv('DB_HOST');

if (!$host) {

$this->markTestSkipped('DB_HOST_POSTGRES not set.');

}

if (!self::commandExists('pg_dump') || !self::commandExists('pg_restore')) {

// Legitimately absent: the renderer steps aside and so do these.

$this->markTestSkipped('pg_dump/pg_restore not on PATH.');

}

// The suite pins the renderer off for the fixture-based tests; this one

// is about the renderer, so it opts back in.

putenv('DBDIFF_PG_DUMP_RENDERER=');

$port = getenv('DB_PORT_POSTGRES') ?: '5432';

$user = getenv('DB_USER_POSTGRES') ?: 'dbdiff';

$pass = getenv('DB_PASSWORD_POSTGRES') ?: 'rootpass';

$admin = $this->connect($host, $port, $user, $pass, 'postgres');

// A connection left open by the previous case blocks DROP DATABASE.

$admin->statement(

"SELECT pg_terminate_backend(pid) FROM pg_stat_activity

WHERE datname = ? AND pid <> pg_backend_pid()",

[$this->database]

);

$admin->statement("DROP DATABASE IF EXISTS {$this->database}");

$admin->statement("CREATE DATABASE {$this->database}");

$admin->disconnect();

$this->capsule = null;

$this->connection = $this->connect($host, $port, $user, $pass, $this->database);

$this->adapter = new PostgresAdapter();

PgDumpRenderer::reset();

// Present but unusable is a misconfiguration, not a reason to skip. On

// CI, Debian's pg_wrapper resolved /usr/bin/pg_dump to 16 even with

// postgresql-client-18 installed, so against newer servers the guard

// declined and every case below silently ran on the built-in renderer

// — passing, because the two now agree on collation and identity.

$reason = PgDumpRenderer::unavailableReason($this->connection);

if ($reason !== null) {

$this->fail("pg_dump is installed but unusable, so this suite would test the wrong renderer: $reason");

}

// That check dumps the database to find out, and the archive is cached.

// Each case creates its table afterwards, so the cache has to go or the

// renderer would look for tables in a snapshot taken before they

// existed — and silently fall back.

PgDumpRenderer::reset();

}

protected function tearDown(): void

{

PgDumpRenderer::reset();

putenv('DBDIFF_PG_DUMP_RENDERER=off');

if (isset($this->connection)) {

$this->connection->disconnect();

}

}

private \Illuminate\Database\Connection $connection;

private function connect(string $host, string $port, string $user, string $pass, string $db): \Illuminate\Database\Connection

{

$capsule = new Capsule();

// DBDiff's own manager fetches associative rows; the adapters index

// into them by column name, so a test connection must match or it

// fails with "Cannot use object of type stdClass as array".

$dispatcher = new Dispatcher();

$dispatcher->listen(StatementPrepared::class, static function ($event): void {

$event->statement->setFetchMode(\PDO::FETCH_ASSOC);

});

$capsule->setEventDispatcher($dispatcher);

$capsule->addConnection([

'driver' => 'pgsql', 'host' => $host, 'port' => $port,

'database' => $db, 'username' => $user, 'password' => $pass,

'charset' => 'utf8', 'schema' => 'public',

], $db . '_' . spl_object_id($this));

return $capsule->getConnection($db . '_' . spl_object_id($this));

}

private static function commandExists(string $name): bool

{

$descriptors = [1 => ['pipe', 'w'], 2 => ['pipe', 'w']];

$process = @proc_open([$name, '--version'], $descriptors, $pipes);

if (!is_resource($process)) {

return false;

}

fclose($pipes[1]);

fclose($pipes[2]);

return proc_close($process) === 0;

}

/**

private function assertCameFromPgDump(string $ddl): void

{

$this->assertTrue(PgDumpRenderer::wasUsed(), 'DDL did not come from pg_dump');

// pg_dump schema-qualifies; the built-in renderer emits bare quoted names.

$this->assertStringContainsString('public.', $ddl);

}

/** Collation decides sort order, and the built-in renderer dropped it. */

public function testRendersAnExplicitCollation(): void

{

$this->connection->statement('CREATE TABLE t (id int, name text COLLATE "C")');

$ddl = $this->adapter->getCreateStatement($this->connection, 't');

$this->assertCameFromPgDump($ddl);

$this->assertStringContainsString('COLLATE', $ddl);

$this->assertStringContainsString('"C"', $ddl);

}

/**

public function testRendersIdentitySequenceOptions(): void

{

$this->connection->statement(

'CREATE TABLE t (id bigint GENERATED ALWAYS AS IDENTITY (INCREMENT 10 START 100), n text)'

);

$ddl = $this->adapter->getCreateStatement($this->connection, 't');

$this->assertCameFromPgDump($ddl);

$this->assertStringContainsString('GENERATED ALWAYS AS IDENTITY', $ddl);

$this->assertStringContainsString('INCREMENT BY 10', $ddl);

$this->assertStringContainsString('START WITH 100', $ddl);

}

/** Indexes are their own entries, under their own names. */

public function testRendersIndexesBelongingToTheTable(): void

{

$this->connection->statement('CREATE TABLE t (id int, b int)');

$this->connection->statement('CREATE INDEX t_b_idx ON t (b)');

$ddl = $this->adapter->getCreateStatement($this->connection, 't');

$this->assertCameFromPgDump($ddl);

$this->assertStringContainsString('CREATE INDEX t_b_idx', $ddl);

}

/** An unrelated table must not be dragged in by a shared listing. */

public function testRendersOnlyTheRequestedTable(): void

{

$this->connection->statement('CREATE TABLE wanted (id int)');

$this->connection->statement('CREATE TABLE other (id int)');

$ddl = $this->adapter->getCreateStatement($this->connection, 'wanted');

$this->assertStringContainsString('wanted', $ddl);

$this->assertStringNotContainsString('other', $ddl);

}

/**

public function testDoesNotLeaveATrailingSemicolon(): void

{

$this->connection->statement('CREATE TABLE t (id int PRIMARY KEY)');

$ddl = $this->adapter->getCreateStatement($this->connection, 't');

$this->assertStringEndsNotWith(';', $ddl);

}

/** Ownership and psql meta-commands are not part of a migration. */

public function testStripsOwnershipAndMetaCommands(): void

{

$this->connection->statement('CREATE TABLE t (id int)');

$ddl = $this->adapter->getCreateStatement($this->connection, 't');

$this->assertStringNotContainsString('OWNER TO', $ddl);

$this->assertStringNotContainsString('\\restrict', $ddl);

$this->assertStringNotContainsString('SET statement_timeout', $ddl);

}

/**

public function testTheOffSwitchFallsBackToTheBuiltInRenderer(): void

{

$this->connection->statement('CREATE TABLE t (id int, name text COLLATE "C")');

putenv('DBDIFF_PG_DUMP_RENDERER=off');

PgDumpRenderer::reset();

$builtIn = $this->adapter->getCreateStatement($this->connection, 't');

// The built-in renderer quotes identifiers; pg_dump schema-qualifies them.

$this->assertStringContainsString('"t"', $builtIn);

$this->assertStringNotContainsString('public.t', $builtIn);

}

/**

public function testDeclinesWhenPgDumpIsOlderThanTheServer(): void

{

$stub = sys_get_temp_dir() . '/fake_pg_dump_' . getmypid();

file_put_contents($stub, "#!/bin/sh\necho 'pg_dump (PostgreSQL) 9.6.24'\n");

chmod($stub, 0755);

putenv('DBDIFF_PG_DUMP=' . $stub);

PgDumpRenderer::reset();

try {

$this->assertFalse(PgDumpRenderer::isActive($this->connection));

$this->assertStringContainsString('older than the server', (string) PgDumpRenderer::unavailableReason($this->connection));

} finally {

putenv('DBDIFF_PG_DUMP');

@unlink($stub);

}

}

/**

public function testAReproducedSerialColumnKeepsItsSequenceOwnership(): void

{

$this->connection->statement('CREATE TABLE t (id serial PRIMARY KEY, n text)');

$ddl = $this->adapter->getCreateStatement($this->connection, 't');

$this->assertCameFromPgDump($ddl);

$this->assertStringContainsString(

'OWNED BY',

$ddl,

'without ALTER SEQUENCE ... OWNED BY the copy holds an unowned sequence'

);

// The original does not report it: it belongs to the column.

$this->assertSame(

[],

\DBDiff\DB\Support\PostgresObjectKinds::sequences($this->connection),

'a serial column\'s sequence is not a standalone object'

);

$replayDb = $this->database . '_replay';

$host = getenv('DB_HOST_POSTGRES') ?: getenv('DB_HOST');

$port = getenv('DB_PORT_POSTGRES') ?: '5432';

$user = getenv('DB_USER_POSTGRES') ?: 'dbdiff';

$pass = getenv('DB_PASSWORD_POSTGRES') ?: 'rootpass';

$admin = $this->connect($host, $port, $user, $pass, 'postgres');

$admin->statement("DROP DATABASE IF EXISTS $replayDb");

$admin->statement("CREATE DATABASE $replayDb");

$admin->disconnect();

$replay = $this->connect($host, $port, $user, $pass, $replayDb);

try {

foreach (explode(";\n", $ddl) as $stmt) {

$stmt = trim(rtrim(trim($stmt), ';'));

if ($stmt !== '') {

$replay->statement($stmt);

}

}

// And neither does the copy — which is the whole point. A mismatch

// here is a DROP SEQUENCE in the next migration.

$this->assertSame(

[],

\DBDiff\DB\Support\PostgresObjectKinds::sequences($replay),

'the reproduced sequence is unowned, so it reads as standalone'

);

} finally {

$replay->disconnect();

$admin = $this->connect($host, $port, $user, $pass, 'postgres');

$admin->statement(

"SELECT pg_terminate_backend(pid) FROM pg_stat_activity

WHERE datname = ? AND pid <> pg_backend_pid()",

[$replayDb]

);

$admin->statement("DROP DATABASE IF EXISTS $replayDb");

$admin->disconnect();

}

}