): array)|null rewrites fetchAssociative() rows of the proxy */ private $fetchRewrite; /** @var array> getMetadataFor() answers of the factory proxy */ private array $metadataOverrides = []; /** @var list answers of the schema-manager proxy tablesExist() before delegating */ private array $tablesExistAnswers = []; private string $driver = 'sqlite'; private static function dedicatedDatabase(): string { return self::DEDICATED_DATABASE . getmypid(); } protected function connect(string $driver): Connection { $this->driver = $driver; if ($driver === 'sqlite') { $this->realConnection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'memory' => true]); return $this->realConnection; } $url = getenv($driver === 'mysql' ? 'DATABASE_URL' : 'DATABASE_URL_PG'); if (!is_string($url) || $url === '') { self::markTestSkipped('No ' . $driver . ' database configured.'); } $params = (new DsnParser(['mysql' => 'pdo_mysql', 'postgresql' => 'pdo_pgsql']))->parse($url); try { $server = DriverManager::getConnection(['dbname' => $driver === 'mysql' ? null : 'postgres'] + $params); $server->executeStatement('DROP DATABASE IF EXISTS ' . self::dedicatedDatabase()); $server->executeStatement('CREATE DATABASE ' . self::dedicatedDatabase()); $server->close(); } catch (Throwable $e) { self::markTestSkipped($driver . ' unavailable: ' . $e->getMessage()); } $this->realConnection = DriverManager::getConnection(['dbname' => self::dedicatedDatabase()] + $params); return $this->realConnection; } protected function dropDatabase(): void { $this->realEntityManager?->close(); $this->realConnection?->close(); $this->realEntityManager = null; $this->realConnection = null; $this->failPattern = null; $this->swallowPattern = null; $this->fetchRewrite = null; $this->metadataOverrides = []; if ($this->driver === 'sqlite') { return; } $url = (string) getenv($this->driver === 'mysql' ? 'DATABASE_URL' : 'DATABASE_URL_PG'); $params = (new DsnParser(['mysql' => 'pdo_mysql', 'postgresql' => 'pdo_pgsql']))->parse($url); $server = DriverManager::getConnection(['dbname' => $this->driver === 'mysql' ? null : 'postgres'] + $params); $server->executeStatement('DROP DATABASE IF EXISTS ' . self::dedicatedDatabase()); $server->close(); $this->driver = 'sqlite'; } protected function realEntityManager(): EntityManager { if ($this->realEntityManager === null) { $config = ORMSetup::createAttributeMetadataConfiguration([dirname(__DIR__, 3) . '/src/Entity'], true); $config->setNamingStrategy(new UnderscoreNamingStrategy(CASE_LOWER, true)); // ORM 3.6+ needs native lazy objects on PHP 8.4+ (symfony/var-exporter 8 dropped LazyGhost) if (PHP_VERSION_ID >= 80400 && method_exists($config, 'enableNativeLazyObjects')) { $config->enableNativeLazyObjects(true); } if ($this->realConnection === null) { throw new RuntimeException('connect() first.'); } $this->realEntityManager = new EntityManager($this->realConnection, $config); } return $this->realEntityManager; } /** * @return ClassMetadata */ protected function routeDataMetadata(): ClassMetadata { return $this->realEntityManager()->getClassMetadata(RouteData::class); } /** * @return ClassMetadata */ protected function recordMetadata(): ClassMetadata { return $this->realEntityManager()->getClassMetadata(RouteDataRecord::class); } /** * Runs SQL on the real connection (test setup). */ protected function sql(string $sql): void { if ($this->realConnection === null) { throw new RuntimeException('connect() first.'); } $this->realConnection->executeStatement($sql); } /** * @param (callable(array): array)|null $rewrite */ protected function rewriteFetch(?callable $rewrite): void { $this->fetchRewrite = $rewrite; } /** * Makes the metadata factory proxy answer $metadata for $class (e.g. a bare Persistence ClassMetadata without the * ORM table-name API). * * @param class-string $class * @param \Doctrine\Persistence\Mapping\ClassMetadata $metadata */ protected function overrideMetadata(string $class, \Doctrine\Persistence\Mapping\ClassMetadata $metadata): void { $this->metadataOverrides[$class] = $metadata; } protected function swallow(?string $regex): void { $this->swallowPattern = $regex; } protected function failOn(?string $regex): void { $this->failPattern = $regex; } /** * @param list $answers */ protected function tablesExistAnswers(array $answers): void { $this->tablesExistAnswers = $answers; } /** * Registry returning proxies of the real connection / entity manager. * * @param list>|null $allMetadata getAllMetadata() answer (null: the real one) */ protected function registry(?array $allMetadata = null): ManagerRegistry&MockObject { $connection = $this->connectionProxy(); $em = $this->entityManagerProxy($connection, $allMetadata); $registry = $this->createMock(ManagerRegistry::class); $registry->method('getConnection')->willReturn($connection); $registry->method('getManager')->willReturn($em); return $registry; } protected function connectionProxy(): Connection&MockObject { $real = $this->realConnection ?? throw new RuntimeException('connect() first.'); $conn = $this->createMock(Connection::class); $fail = function (string $sql): void { if ($this->failPattern !== null && preg_match($this->failPattern, $sql) === 1) { throw new RuntimeException('Forced failure: ' . $sql); } }; $conn->method('getDatabasePlatform')->willReturnCallback(static fn () => $real->getDatabasePlatform()); $conn->method('executeStatement')->willReturnCallback(function (string $sql) use ($real, $fail): int|string { $fail($sql); if ($this->swallowPattern !== null && preg_match($this->swallowPattern, $sql) === 1) { return 0; } return $real->executeStatement($sql); }); $conn->method('fetchAssociative')->willReturnCallback(function (string $sql) use ($real, $fail): array|false { $fail($sql); $row = $real->fetchAssociative($sql); return $row !== false && $this->fetchRewrite !== null ? ($this->fetchRewrite)($row) : $row; }); $conn->method('fetchAllAssociative')->willReturnCallback(static function (string $sql) use ($real, $fail): array { $fail($sql); return $real->fetchAllAssociative($sql); }); $conn->method('createSchemaManager')->willReturnCallback(fn (): AbstractSchemaManager => $this->schemaManagerProxy($real->createSchemaManager())); return $conn; } /** * @param AbstractSchemaManager $real * * @return AbstractSchemaManager&MockObject */ private function schemaManagerProxy(AbstractSchemaManager $real): AbstractSchemaManager&MockObject { $sm = $this->createMock(AbstractSchemaManager::class); $sm->method('tablesExist')->willReturnCallback(function (array $names) use ($real): bool { if ($this->tablesExistAnswers !== []) { return array_shift($this->tablesExistAnswers); } return $real->tablesExist($names); }); $sm->method('introspectTable')->willReturnCallback(static fn (string $name): Table => $real->introspectTable($name)); $sm->method('dropTable')->willReturnCallback(static function (string $name) use ($real): void { $real->dropTable($name); }); $sm->method('createSchemaConfig')->willReturnCallback(static fn (): SchemaConfig => $real->createSchemaConfig()); $sm->method('introspectSchema')->willReturnCallback(static fn (): Schema => $real->introspectSchema()); return $sm; } /** * @param list>|null $allMetadata */ private function entityManagerProxy(Connection $connection, ?array $allMetadata): EntityManagerInterface&MockObject { $real = $this->realEntityManager(); $factory = $this->createMock(ClassMetadataFactory::class); $factory->method('getMetadataFor')->willReturnCallback(fn (string $class) => $this->metadataOverrides[$class] ?? $real->getMetadataFactory()->getMetadataFor($class)); $factory->method('getAllMetadata')->willReturnCallback(static fn (): array => $allMetadata ?? $real->getMetadataFactory()->getAllMetadata()); $em = $this->createMock(EntityManagerInterface::class); $em->method('getConnection')->willReturn($connection); $em->method('getMetadataFactory')->willReturn($factory); $em->method('getConfiguration')->willReturnCallback(static fn () => $real->getConfiguration()); $em->method('getEventManager')->willReturnCallback(static fn () => $real->getEventManager()); $em->method('getClassMetadata')->willReturnCallback(static fn (string $class) => $real->getClassMetadata($class)); return $em; } }