Merge remote-tracking branch 'origin/2.17.x' into 3.0.x

Author: greg0ire

src/DependencyInjection/Compiler/EntityListenerPass.php

@@ -8,7 +8,6 @@
 use Doctrine\Bundle\DoctrineBundle\Mapping\EntityListenerServiceResolver;
 use Symfony\Component\DependencyInjection\ChildDefinition;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
-use Symfony\Component\DependencyInjection\Compiler\PriorityTaggedServiceTrait;
 use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
@@ -19,6 +18,7 @@
 use function method_exists;
 use function sprintf;
 use function substr;
+use function usort;
 
 /**
  * Class for Symfony bundles to register entity listeners
@@ -27,66 +27,73 @@
  */
 class EntityListenerPass implements CompilerPassInterface
 {
-    use PriorityTaggedServiceTrait;
-
     public function process(ContainerBuilder $container): void
     {
-        $resolvers = $this->findAndSortTaggedServices('doctrine.orm.entity_listener', $container);
-
         $lazyServiceReferencesByResolver = [];
 
-        foreach ($resolvers as $reference) {
-            $id = $reference->__toString();
-            foreach ($container->getDefinition($id)->getTag('doctrine.orm.entity_listener') as $attributes) {
-                $name          = $attributes['entity_manager'] ?? $container->getParameter('doctrine.default_entity_manager');
-                $entityManager = sprintf('doctrine.orm.%s_entity_manager', $name);
+        $serviceTags = [];
+        foreach ($container->findTaggedServiceIds('doctrine.orm.entity_listener', true) as $id => $tags) {
+            foreach ($tags as $attributes) {
+                $serviceTags[] = [
+                    'serviceId' => $id,
+                    'attributes' => $attributes,
+                ];
+            }
+        }
 
-                if (! $container->hasDefinition($entityManager)) {
-                    continue;
-                }
+        usort($serviceTags, static fn (array $a, array $b) => ($b['attributes']['priority'] ?? 0) <=> ($a['attributes']['priority'] ?? 0));
 
-                $resolverId = sprintf('doctrine.orm.%s_entity_listener_resolver', $name);
+        foreach ($serviceTags as $tag) {
+            $id            = $tag['serviceId'];
+            $attributes    = $tag['attributes'];
+            $name          = $attributes['entity_manager'] ?? $container->getParameter('doctrine.default_entity_manager');
+            $entityManager = sprintf('doctrine.orm.%s_entity_manager', $name);
 
-                if (! $container->has($resolverId)) {
-                    continue;
-                }
+            if (! $container->hasDefinition($entityManager)) {
+                continue;
+            }
 
-                $resolver = $container->findDefinition($resolverId);
-                $resolver->setPublic(true);
+            $resolverId = sprintf('doctrine.orm.%s_entity_listener_resolver', $name);
 
-                if (isset($attributes['entity'])) {
-                    $this->attachToListener($container, $name, $this->getConcreteDefinitionClass($container->findDefinition($id), $container, $id), $attributes);
-                }
+            if (! $container->has($resolverId)) {
+                continue;
+            }
 
-                $resolverClass                 = $this->getResolverClass($resolver, $container, $resolverId);
-                $resolverSupportsLazyListeners = is_a($resolverClass, EntityListenerServiceResolver::class, true);
+            $resolver = $container->findDefinition($resolverId);
+            $resolver->setPublic(true);
 
-                $lazyByAttribute = isset($attributes['lazy']) && $attributes['lazy'];
-                if ($lazyByAttribute && ! $resolverSupportsLazyListeners) {
-                    throw new InvalidArgumentException(sprintf(
-                        'Lazy-loaded entity listeners can only be resolved by a resolver implementing %s.',
-                        EntityListenerServiceResolver::class,
-                    ));
-                }
+            if (isset($attributes['entity'])) {
+                $this->attachToListener($container, $name, $this->getConcreteDefinitionClass($container->findDefinition($id), $container, $id), $attributes);
+            }
 
-                if (! isset($attributes['lazy']) && $resolverSupportsLazyListeners || $lazyByAttribute) {
-                    $listener = $container->findDefinition($id);
+            $resolverClass                 = $this->getResolverClass($resolver, $container, $resolverId);
+            $resolverSupportsLazyListeners = is_a($resolverClass, EntityListenerServiceResolver::class, true);
 
-                    $resolver->addMethodCall('registerService', [$this->getConcreteDefinitionClass($listener, $container, $id), $id]);
+            $lazyByAttribute = isset($attributes['lazy']) && $attributes['lazy'];
+            if ($lazyByAttribute && ! $resolverSupportsLazyListeners) {
+                throw new InvalidArgumentException(sprintf(
+                    'Lazy-loaded entity listeners can only be resolved by a resolver implementing %s.',
+                    EntityListenerServiceResolver::class,
+                ));
+            }
+
+            if (! isset($attributes['lazy']) && $resolverSupportsLazyListeners || $lazyByAttribute) {
+                $listener = $container->findDefinition($id);
 
-                    // if the resolver uses the default class we will use a service locator for all listeners
-                    if ($resolverClass === ContainerEntityListenerResolver::class) {
-                        if (! isset($lazyServiceReferencesByResolver[$resolverId])) {
-                            $lazyServiceReferencesByResolver[$resolverId] = [];
-                        }
+                $resolver->addMethodCall('registerService', [$this->getConcreteDefinitionClass($listener, $container, $id), $id]);
 
-                        $lazyServiceReferencesByResolver[$resolverId][$id] = new Reference($id);
-                    } else {
-                        $listener->setPublic(true);
+                // if the resolver uses the default class we will use a service locator for all listeners
+                if ($resolverClass === ContainerEntityListenerResolver::class) {
+                    if (! isset($lazyServiceReferencesByResolver[$resolverId])) {
+                        $lazyServiceReferencesByResolver[$resolverId] = [];
                     }
+
+                    $lazyServiceReferencesByResolver[$resolverId][$id] = new Reference($id);
                 } else {
-                    $resolver->addMethodCall('register', [new Reference($id)]);
+                    $listener->setPublic(true);
                 }
+            } else {
+                $resolver->addMethodCall('register', [new Reference($id)]);
             }
         }
 

src/DependencyInjection/Configuration.php

@@ -21,7 +21,6 @@
 use function array_key_exists;
 use function array_keys;
 use function array_pop;
-use function assert;
 use function class_exists;
 use function constant;
 use function count;
@@ -54,9 +53,7 @@ public function getConfigTreeBuilder(): TreeBuilder
         $treeBuilder = new TreeBuilder('doctrine');
         $rootNode    = $treeBuilder->getRootNode();
 
-        /* @phpstan-ignore argument.type (symfony plugin needed) */
         $this->addDbalSection($rootNode);
-        /* @phpstan-ignore argument.type (symfony plugin needed) */
         $this->addOrmSection($rootNode);
 
         return $treeBuilder;
@@ -166,7 +163,6 @@ private function getDbalConnectionsNode(): ArrayNodeDefinition
             ->requiresAtLeastOneElement()
             ->useAttributeAsKey('name')
             ->prototype('array');
-        assert($connectionNode instanceof ArrayNodeDefinition);
 
         $this->configureDbalDriverNode($connectionNode);
 
@@ -222,13 +218,8 @@ private function getDbalConnectionsNode(): ArrayNodeDefinition
                 ->arrayNode('replicas')
                     ->useAttributeAsKey('name')
                     ->prototype('array');
-
-        assert($replicaNode instanceof ArrayNodeDefinition);
-
         $this->configureDbalDriverNode($replicaNode);
 
-        assert($node instanceof ArrayNodeDefinition);
-
         return $node;
     }
 
@@ -715,8 +706,6 @@ private function getOrmEntityManagersNode(): ArrayNodeDefinition
                 ->end()
             ->end();
 
-        assert($node instanceof ArrayNodeDefinition);
-
         return $node;
     }
 
@@ -743,8 +732,6 @@ private function getOrmCacheDriverNode(string $name): ArrayNodeDefinition
             $node->addDefaultsIfNotSet();
         }
 
-        assert($node instanceof ArrayNodeDefinition);
-
         return $node;
     }
 }

tests/Command/CreateDatabaseDoctrineTest.php

@@ -64,37 +64,22 @@ public function testExecute(): void
     private function getMockContainer(string $connectionName, array|null $params = null): MockObject
     {
         // Mock the container and everything you'll need here
-        $mockDoctrine = $this->getMockBuilder(ManagerRegistry::class)
-            ->getMock();
+        $mockDoctrine = $this->createStub(ManagerRegistry::class);
 
-        $mockDoctrine->expects($this->any())
-            ->method('getDefaultConnectionName')
-            ->withAnyParameters()
-            ->willReturn($connectionName);
+        $mockDoctrine->method('getDefaultConnectionName')->willReturn($connectionName);
 
         $config = (new Configuration())->setSchemaManagerFactory($this->createMock(SchemaManagerFactory::class));
 
-        $mockConnection = $this->createMock(Connection::class);
+        $mockConnection = $this->createStub(Connection::class);
         $mockConnection->method('getConfiguration')->willReturn($config);
-
-        $mockConnection->expects($this->any())
-            ->method('getParams')
-            ->withAnyParameters()
-            ->willReturn($params);
-
-        $mockDoctrine->expects($this->any())
-            ->method('getConnection')
-            ->withAnyParameters()
-            ->willReturn($mockConnection);
+        $mockConnection->method('getParams')->willReturn($params);
+        $mockDoctrine->method('getConnection')->willReturn($mockConnection);
 
         $mockContainer = $this->getMockBuilder(Container::class)
             ->onlyMethods(['get'])
             ->getMock();
 
-        $mockContainer->expects($this->any())
-            ->method('get')
-            ->with('doctrine')
-            ->willReturn($mockDoctrine);
+        $mockContainer->method('get')->with('doctrine')->willReturn($mockDoctrine);
 
         return $mockContainer;
     }

tests/Command/DropDatabaseDoctrineTest.php

@@ -142,35 +142,22 @@ public static function provideIncompatibleDriverOptions(): Generator
     private function getMockContainer(string $connectionName, array $params): MockObject
     {
         // Mock the container and everything you'll need here
-        $mockDoctrine = $this->getMockBuilder(ManagerRegistry::class)
-            ->getMock();
+        $mockDoctrine = $this->createStub(ManagerRegistry::class);
 
-        $mockDoctrine->expects($this->any())
-            ->method('getDefaultConnectionName')
-            ->withAnyParameters()
-            ->willReturn($connectionName);
+        $mockDoctrine->method('getDefaultConnectionName')->willReturn($connectionName);
 
         $config = (new Configuration())->setSchemaManagerFactory(new DefaultSchemaManagerFactory());
 
         $mockConnection = $this->createMock(Connection::class);
         $mockConnection->method('getConfiguration')->willReturn($config);
-
-        $mockConnection->expects($this->any())
-            ->method('getParams')
-            ->withAnyParameters()
-            ->willReturn($params);
-
-        $mockDoctrine->expects($this->any())
-            ->method('getConnection')
-            ->withAnyParameters()
-            ->willReturn($mockConnection);
+        $mockConnection->method('getParams')->willReturn($params);
+        $mockDoctrine->method('getConnection')->willReturn($mockConnection);
 
         $mockContainer = $this->getMockBuilder(Container::class)
             ->onlyMethods(['get'])
             ->getMock();
 
-        $mockContainer->expects($this->any())
-            ->method('get')
+        $mockContainer->method('get')
             ->with('doctrine')
             ->willReturn($mockDoctrine);
 

tests/ConnectionFactoryTest.php

@@ -9,12 +9,9 @@
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Driver;
 use Doctrine\DBAL\Schema\DefaultSchemaManagerFactory;
-use Doctrine\Deprecations\PHPUnit\VerifyDeprecations;
 
 class ConnectionFactoryTest extends TestCase
 {
-    use VerifyDeprecations;
-
     private Configuration $configuration;
 
     protected function setUp(): void

tests/DataCollector/DoctrineDataCollectorTest.php

@@ -32,31 +32,23 @@ public function testCollectEntities(): void
             self::markTestSkipped('This test requires ORM');
         }
 
-        $manager    = $this->createMock(EntityManagerInterface::class);
+        $manager    = $this->createStub(EntityManagerInterface::class);
         $config     = $this->createMock(Configuration::class);
         $factory    = $this->createMock(ClassMetadataFactory::class);
         $collector  = $this->createCollector(['default' => $manager], true, $this->createMock(DebugDataHolder::class));
         $unitOfWork = $this->createMock(UnitOfWork::class);
 
-        $manager->expects($this->any())
-            ->method('getMetadataFactory')
-            ->will($this->returnValue($factory));
-        $manager->expects($this->any())
-            ->method('getConfiguration')
-            ->will($this->returnValue($config));
-        $manager->expects($this->any())
-            ->method('getUnitOfWork')
-            ->will($this->returnValue($unitOfWork));
-        $unitOfWork->expects($this->any())
-            ->method('getIdentityMap')
-            ->will($this->returnValue([
-                self::FIRST_ENTITY => [new stdClass()],
-                self::SECOND_ENTITY => [new stdClass(), new stdClass()],
-            ]));
+        $manager->method('getMetadataFactory')->willReturn($factory);
+        $manager->method('getConfiguration')->willReturn($config);
+        $manager->method('getUnitOfWork')->willReturn($unitOfWork);
+        $unitOfWork->method('getIdentityMap')->willReturn([
+            self::FIRST_ENTITY => [new stdClass()],
+            self::SECOND_ENTITY => [new stdClass(), new stdClass()],
+        ]);
 
         $config->expects($this->once())
             ->method('isSecondLevelCacheEnabled')
-            ->will($this->returnValue(false));
+            ->willReturn(false);
 
         $metadatas = [
             $this->createEntityMetadata(self::FIRST_ENTITY),
@@ -65,7 +57,7 @@ public function testCollectEntities(): void
         ];
         $factory->expects($this->once())
             ->method('getLoadedMetadata')
-            ->will($this->returnValue($metadatas));
+            ->willReturn($metadatas);
 
         $collector->collect(new Request(), new Response());
 
@@ -84,18 +76,12 @@ public function testDoesNotCollectEntities(): void
         $manager    = $this->createMock(EntityManager::class);
         $config     = $this->createMock(Configuration::class);
         $collector  = $this->createCollector(['default' => $manager], false, $this->createMock(DebugDataHolder::class));
-        $unitOfWork = $this->createMock(UnitOfWork::class);
+        $unitOfWork = $this->createStub(UnitOfWork::class);
 
-        $manager->expects($this->never())
-            ->method('getMetadataFactory');
-        $manager->method('getConfiguration')
-            ->will($this->returnValue($config));
-        $manager->expects($this->any())
-            ->method('getUnitOfWork')
-            ->will($this->returnValue($unitOfWork));
-        $unitOfWork->expects($this->any())
-            ->method('getIdentityMap')
-            ->will($this->returnValue([]));
+        $manager->expects($this->never())->method('getMetadataFactory');
+        $manager->method('getConfiguration')->willReturn($config);
+        $manager->method('getUnitOfWork')->willReturn($unitOfWork);
+        $unitOfWork->method('getIdentityMap')->willReturn([]);
 
         $collector->collect(new Request(), new Response());
 
@@ -165,19 +151,12 @@ private function createCollector(
         bool $shouldValidateSchema = true,
         DebugDataHolder|null $debugDataHolder = null,
     ): DoctrineDataCollector {
-        $registry = $this->createMock(ManagerRegistry::class);
-        $registry
-            ->expects($this->any())
-            ->method('getConnectionNames')
-            ->will($this->returnValue(['default' => 'doctrine.dbal.default_connection']));
-        $registry
-            ->expects($this->any())
-            ->method('getManagerNames')
-            ->will($this->returnValue(['default' => 'doctrine.orm.default_entity_manager']));
-        $registry
-            ->expects($this->any())
-            ->method('getManagers')
-            ->will($this->returnValue($managers));
+        $registry = $this->createStub(ManagerRegistry::class);
+        $registry->method('getConnectionNames')
+            ->willReturn(['default' => 'doctrine.dbal.default_connection']);
+        $registry->method('getManagerNames')
+            ->willReturn(['default' => 'doctrine.orm.default_entity_manager']);
+        $registry->method('getManagers')->willReturn($managers);
 
         return new DoctrineDataCollector($registry, $shouldValidateSchema, $debugDataHolder);
     }