{

private string $db = 'dbdiff_object_kinds';

private string $roundTripDb = 'dbdiff_object_kinds_rt';

private ?PDO $adminDb = null;

private $capsule;

private $connection;

private string $host;

private int $port = 5432;

private string $user = 'dbdiff';

private string $pass = 'rootpass';

private function dropDb(string $name): void

{

try {

$this->adminDb->exec("DROP DATABASE IF EXISTS $name WITH (FORCE)");

} catch (PDOException $e) {

$this->adminDb->exec("DROP DATABASE IF EXISTS $name");

}

}

private function connect(string $database, string $name)

{

$capsule = new Capsule;

$dispatcher = new Dispatcher();

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

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

});

$capsule->setEventDispatcher($dispatcher);

$capsule->addConnection([

'driver' => 'pgsql',

'host' => $this->host,

'port' => $this->port,

'database' => $database,

'username' => $this->user,

'password' => $this->pass,

'charset' => 'utf8',

'schema' => 'public',

], $name);

$this->capsule = $capsule;

return $capsule->getConnection($name);

}

protected function setUp(): void

{

if (!extension_loaded('pdo_pgsql')) {

$this->markTestSkipped('pdo_pgsql extension not loaded — skipping object kind tests.');

}

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

if (!$host) {

$this->markTestSkipped('DB_HOST_POSTGRES env var not set — skipping object kind tests.');

}

$this->host = $host;

$this->adminDb = new PDO(

"pgsql:host={$this->host};port={$this->port};dbname=diff1",

$this->user,

$this->pass,

[PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]

);

$this->dropDb($this->db);

$this->dropDb($this->roundTripDb);

$this->adminDb->exec("CREATE DATABASE {$this->db}");

$this->connection = $this->connect($this->db, 'kinds');

$this->connection->unprepared(<<<'SQL'

SQL);

}

protected function tearDown(): void

{

if ($this->adminDb) {

$this->capsule = null;

$this->connection = null;

$this->dropDb($this->db);

$this->dropDb($this->roundTripDb);

}

}

// ── No over-reporting ─────────────────────────────────────────────────

public function testSequencesExcludeSerialAndIdentityOwnedOnes(): void

{

$sequences = PostgresObjectKinds::sequences($this->connection);

$this->assertSame(['o_seq', 'o_small'], array_keys($sequences));

// o_ser_id_seq depends on its column with deptype 'a', o_ident's with

// deptype 'i'. Both are the column's, not objects of their own.

$this->assertArrayNotHasKey('o_ser_id_seq', $sequences);

$this->assertArrayNotHasKey('o_ident_id_seq', $sequences);

}

public function testCompositeTypesExcludeRelationRowTypes(): void

{

$types = PostgresObjectKinds::compositeTypes($this->connection);

$this->assertSame(['o_addr'], array_keys($types));

foreach (['o_mt', 'o_sec', 'o_plain', 'o_v', 'o_mv', 'o_ser', 'o_ident'] as $relation) {

$this->assertArrayNotHasKey(

$relation,

$types,

"the row type of relation $relation must not be reported as a composite type"

);

}

}

public function testDomainsAreNotReportedAsCompositeTypes(): void

{

$types = PostgresObjectKinds::compositeTypes($this->connection);

$this->assertArrayNotHasKey('o_pos', $types);

$this->assertArrayNotHasKey('o_code', $types);

}

public function testMaterializedViewsAreSeparateFromViews(): void

{

$views = (new \DBDiff\DB\Adapters\PostgresAdapter())->getViews($this->connection);

$matviews = PostgresObjectKinds::materializedViews($this->connection);

$this->assertArrayHasKey('o_v', $views);

$this->assertArrayNotHasKey('o_mv', $views, 'a matview must not appear as an ordinary view');

$this->assertSame(['o_mv', 'o_mv_empty'], array_keys($matviews));

}

// ── Rendering ─────────────────────────────────────────────────────────

public function testSequenceRendersEveryOption(): void

{

$sequences = PostgresObjectKinds::sequences($this->connection);

// Every option is explicit: MINVALUE and MAXVALUE defaults follow the

// type, so a bigint sequence recreated as an integer one would differ.

$this->assertSame(

'CREATE SEQUENCE "o_seq" AS bigint INCREMENT BY 5 MINVALUE 100 '

. 'MAXVALUE 100000 START WITH 100 CACHE 1 CYCLE',

$sequences['o_seq']

);

$this->assertStringContainsString('AS smallint', $sequences['o_small']);

$this->assertStringContainsString('NO CYCLE', $sequences['o_small']);

}

public function testCompositeTypeRendersItsAttributes(): void

{

$types = PostgresObjectKinds::compositeTypes($this->connection);

$this->assertSame('CREATE TYPE "o_addr" AS (street text, city text)', $types['o_addr']);

}

public function testDomainRendersConstraintsDefaultAndNullability(): void

{

$domains = PostgresObjectKinds::domains($this->connection);

$this->assertSame(

'CREATE DOMAIN "o_pos" AS integer CONSTRAINT o_pos_positive CHECK ((VALUE > 0))',

$domains['o_pos']

);

// Named so that several CHECKs are not renamed on every recreation.

$this->assertStringContainsString('CONSTRAINT o_code_len', $domains['o_code']);

$this->assertStringContainsString('NOT NULL', $domains['o_code']);

$this->assertStringContainsString("DEFAULT 'zz'", $domains['o_code']);

// PG 17+ also records NOT NULL as a constraint row; it must not be

// emitted twice.

$this->assertSame(1, substr_count($domains['o_code'], 'NOT NULL'));

}

public function testMaterializedViewIgnoresPopulationState(): void

{

// Whether a matview holds its rows yet is not part of its schema: a

// REFRESH changes it and no DDL does, and pg_dump restores every

// matview unpopulated. Rendering it made the same view compare unequal

// across any pg_dump-based copy — reported as an extra view to DROP and

// a missing one to create, with its existing index reported missing

// too (issue #227).

$matviews = PostgresObjectKinds::materializedViews($this->connection);

$this->assertStringStartsWith('CREATE MATERIALIZED VIEW "o_mv" AS', $matviews['o_mv']);

$this->assertStringNotContainsString('WITH NO DATA', $matviews['o_mv']);

$this->assertStringNotContainsString('WITH NO DATA', $matviews['o_mv_empty']);

}

public function testAPopulatedAndAnUnpopulatedMatviewRenderIdentically(): void

{

// The property the fix is for, stated directly: o_mv is populated and

// o_mv_empty is not, so their definitions must differ only in the name

// and the query, never in population state.

$matviews = PostgresObjectKinds::materializedViews($this->connection);

$populated = $matviews['o_mv'];

$empty = $matviews['o_mv_empty'];

$this->assertSame(

str_replace('"o_mv"', '"X"', preg_replace('/ AS .*/s', '', $populated)),

str_replace('"o_mv_empty"', '"X"', preg_replace('/ AS .*/s', '', $empty)),

'the clause before AS must not depend on whether the view is populated'

);

}

public function testPoliciesAreKeyedByTableAndName(): void

{

$policies = PostgresObjectKinds::policies($this->connection);

$this->assertSame(['o_sec.o_sec_read', 'o_sec.o_sec_write'], array_keys($policies));

$this->assertSame('o_sec', $policies['o_sec.o_sec_read']['table']);

$this->assertSame(

'CREATE POLICY "o_sec_read" ON "o_sec" FOR SELECT USING (true)',

$policies['o_sec.o_sec_read']['definition']

);

$restrictive = $policies['o_sec.o_sec_write']['definition'];

$this->assertStringContainsString('AS RESTRICTIVE', $restrictive);

$this->assertStringContainsString('FOR UPDATE', $restrictive);

$this->assertStringContainsString('TO dbdiff', $restrictive);

$this->assertStringContainsString('USING (', $restrictive);

$this->assertStringContainsString('WITH CHECK (', $restrictive);

}

public function testRowSecurityFlagsAreReadPerTable(): void

{

$rls = PostgresObjectKinds::rowSecurity($this->connection);

$this->assertSame(['enabled' => true, 'forced' => true], $rls['o_sec']);

$this->assertSame(['enabled' => false, 'forced' => false], $rls['o_plain']);

// A matview is not a table and carries no RLS flags.

$this->assertArrayNotHasKey('o_mv', $rls);

}

// ── Round-trip ────────────────────────────────────────────────────────

/**

public function testEmittedDdlRoundTripsThroughTheServer(): void

{

$source = $this->connection;

$sequences = PostgresObjectKinds::sequences($source);

$types = PostgresObjectKinds::compositeTypes($source);

$domains = PostgresObjectKinds::domains($source);

$matviews = PostgresObjectKinds::materializedViews($source);

$policies = PostgresObjectKinds::policies($source);

$this->adminDb->exec("CREATE DATABASE {$this->roundTripDb}");

$target = $this->connect($this->roundTripDb, 'kinds_rt');

// The tables a matview and a policy need, then the objects themselves.

$target->unprepared(<<<'SQL'

SQL);

foreach ([$types, $domains, $sequences, $matviews] as $group) {

foreach ($group as $ddl) {

$target->unprepared($ddl . ';');

}

}

foreach ($policies as $policy) {

$target->unprepared($policy['definition'] . ';');

}

$this->assertSame($sequences, PostgresObjectKinds::sequences($target));

$this->assertSame($types, PostgresObjectKinds::compositeTypes($target));

$this->assertSame($domains, PostgresObjectKinds::domains($target));

$this->assertSame($matviews, PostgresObjectKinds::materializedViews($target));

$this->assertSame($policies, PostgresObjectKinds::policies($target));

$this->assertSame(

PostgresObjectKinds::rowSecurity($source)['o_sec'],

PostgresObjectKinds::rowSecurity($target)['o_sec']

);

}