#11977 added test coverage verifying that persisters are being used to batch INSERTs

Author: Ocramius

src/UnitOfWork.php

@@ -1038,11 +1038,9 @@ public function recomputeSingleEntityChangeSet(ClassMetadata $class, object $ent
      */
     private function executeInserts(): void
     {
-        $eventsToDispatch = [];
-        // @TODO #11977 test this by verifying the number of executed SQL queries in a flush operation?
-        // @TODO #11977 could this be applied also to batch updates? If so, let's raise a new issue.
         /** @var list<InsertBatch<object>> $batchedByType */
-        $batchedByType = InsertBatch::batchByEntityType($this->em, $this->computeInsertExecutionOrder());
+        $batchedByType    = InsertBatch::batchByEntityType($this->em, $this->computeInsertExecutionOrder());
+        $eventsToDispatch = [];
 
         foreach ($batchedByType as $batch) {
             $class     = $batch->class;

tests/Tests/Mocks/EntityPersisterMock.php

@@ -13,6 +13,8 @@
  */
 class EntityPersisterMock extends BasicEntityPersister
 {
+    /** @var int<0, max> */
+    private int $countOfExecuteInsertCalls  = 0;
     private array $inserts                  = [];
     private array $updates                  = [];
     private array $deletes                  = [];
@@ -40,6 +42,8 @@ public function addInsert(object $entity): void
 
     public function executeInserts(): void
     {
+        $this->countOfExecuteInsertCalls += 1;
+
         foreach ($this->postInsertIds as $item) {
             $this->em->getUnitOfWork()->assignPostInsertId($item['entity'], $item['generatedId']);
         }
@@ -86,6 +90,7 @@ public function getDeletes(): array
 
     public function reset(): void
     {
+        $this->countOfExecuteInsertCalls  = 0;
         $this->existsCalled               = false;
         $this->identityColumnValueCounter = 0;
         $this->inserts                    = [];
@@ -97,4 +102,10 @@ public function isExistsCalled(): bool
     {
         return $this->existsCalled;
     }
+
+    /** @return int<0, max> */
+    public function countOfExecuteInsertCalls(): int
+    {
+        return $this->countOfExecuteInsertCalls;
+    }
 }

tests/Tests/ORM/Internal/UnitOfWork/InsertBatchTest.php

@@ -10,10 +10,12 @@
 use Doctrine\ORM\Internal\UnitOfWork\InsertBatch;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\MockObject\Stub;
 use PHPUnit\Framework\TestCase;
 
 #[CoversClass(InsertBatch::class)]
+#[Group('#11977')]
 final class InsertBatchTest extends TestCase
 {
     private EntityManagerInterface&Stub $entityManager;

tests/Tests/ORM/UnitOfWorkTest.php

@@ -32,6 +32,7 @@
 use Doctrine\Tests\Models\CMS\CmsUser;
 use Doctrine\Tests\Models\Forum\ForumAvatar;
 use Doctrine\Tests\Models\Forum\ForumUser;
+use Doctrine\Tests\Models\MixedToOneIdentity\Country;
 use Doctrine\Tests\OrmTestCase;
 use Exception as BaseException;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -141,6 +142,25 @@ public function testSavingSingleEntityWithIdentityColumnForcesInsert(): void
         self::assertIsNumeric($user->id);
     }
 
+    #[Group('#11977')]
+    public function testMultipleInsertsAreBatchedInThePersister(): void
+    {
+        $userPersister = new EntityPersisterMock($this->_emMock, $this->_emMock->getClassMetadata(Country::class));
+        $this->_unitOfWork->setEntityPersister(Country::class, $userPersister);
+
+        $country1          = new Country();
+        $country1->country = 'Italy';
+        $country2          = new Country();
+        $country2->country = 'Germany';
+
+        $this->_unitOfWork->persist($country1);
+        $this->_unitOfWork->persist($country2);
+        $this->_unitOfWork->commit();
+
+        self::assertCount(2, $userPersister->getInserts());
+        self::assertSame(1, $userPersister->countOfExecuteInsertCalls());
+    }
+
     /**
      * Tests a scenario where a save() operation is cascaded from a ForumUser
      * to its associated ForumAvatar, both entities using IDENTITY id generation.