Don't mock what you don't own (#66)

* Do not rely on mock for Doctrine manager nor registry

* Do not rely on mock for event dispatcher

* Do not rely on mock for symfony normalizer nor denormalizer

* Remove phpspec/prophecy-phpunit dev dependency from packages that are no longer using it

Author: yann-eugone

src/batch-doctrine-dbal/tests/DoctrineDBALTestCase.php

@@ -10,6 +10,7 @@
 use Doctrine\DBAL\Schema\Table;
 use Doctrine\Persistence\ConnectionRegistry;
 use PHPUnit\Framework\TestCase;
+use Yokai\Batch\Tests\Bridge\Doctrine\DBAL\Dummy\SingleConnectionRegistry;
 
 abstract class DoctrineDBALTestCase extends TestCase
 {
@@ -19,12 +20,7 @@ abstract class DoctrineDBALTestCase extends TestCase
     protected function setUp(): void
     {
         $this->connection = DriverManager::getConnection(['url' => \getenv('DATABASE_URL')]);
-        $this->doctrine = $this->createMock(ConnectionRegistry::class);
-        $this->doctrine->method('getDefaultConnectionName')
-            ->willReturn('default');
-        $this->doctrine->method('getConnection')
-            ->with('default')
-            ->willReturn($this->connection);
+        $this->doctrine = new SingleConnectionRegistry($this->connection);
     }
 
     protected function createTable(string $table, array $columns): void

src/batch-doctrine-dbal/tests/Dummy/SingleConnectionRegistry.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yokai\Batch\Tests\Bridge\Doctrine\DBAL\Dummy;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\Persistence\ConnectionRegistry;
+use InvalidArgumentException;
+
+final class SingleConnectionRegistry implements ConnectionRegistry
+{
+    public function __construct(
+        private Connection $connection,
+        private string $name = 'default',
+    ) {
+    }
+
+    public function getDefaultConnectionName()
+    {
+        return $this->name;
+    }
+
+    public function getConnection($name = null)
+    {
+        if ($name === $this->name) {
+            return $this->connection;
+        }
+
+        throw new InvalidArgumentException(sprintf('Doctrine Connection named "%s" does not exist.', $name));
+    }
+
+    public function getConnections()
+    {
+        return [$this->connection];
+    }
+
+    public function getConnectionNames()
+    {
+        return [$this->name];
+    }
+}

src/batch-doctrine-orm/composer.json

@@ -21,7 +21,6 @@
         }
     },
     "require-dev": {
-        "phpspec/prophecy-phpunit": "^2.0",
         "phpunit/phpunit": "^9.5"
     },
     "autoload-dev": {

src/batch-doctrine-orm/phpunit.xml

@@ -7,6 +7,10 @@
          colors="true"
          bootstrap="vendor/autoload.php"
 >
+    <php>
+        <env name="DATABASE_URL" value="sqlite:///:memory:"/>
+    </php>
+
     <testsuites>
         <testsuite name="Tests">
             <directory>./tests</directory>

src/batch-doctrine-orm/src/EntityReader.php

@@ -34,12 +34,10 @@ public function read(): iterable
             );
         }
 
-        $query = $manager->createQueryBuilder()
+        yield from $manager->createQueryBuilder()
             ->select('e')
-            ->from($this->class, 'e');
-
-        foreach ($query->getQuery()->toIterable() as [$entity]) {
-            yield $entity;
-        }
+            ->from($this->class, 'e')
+            ->getQuery()
+            ->toIterable();
     }
 }

src/batch-doctrine-orm/tests/Dummy/SingleManagerRegistry.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yokai\Batch\Tests\Bridge\Doctrine\ORM\Dummy;
+
+use Doctrine\ORM\Proxy\Proxy;
+use Doctrine\Persistence\AbstractManagerRegistry;
+use Doctrine\Persistence\ObjectManager;
+
+final class SingleManagerRegistry extends AbstractManagerRegistry
+{
+    public function __construct(
+        private ObjectManager $manager,
+    ) {
+        parent::__construct('ORM', ['default'], ['default'], 'default', 'default', Proxy::class);
+    }
+
+    protected function getService($name)
+    {
+        if ($name !== 'default') {
+            throw new \InvalidArgumentException('Unknown service "' . $name . '".');
+        }
+
+        return $this->manager;
+    }
+
+    protected function resetService($name)
+    {
+    }
+
+    public function getAliasNamespace($alias)
+    {
+        return $alias;
+    }
+}

src/batch-doctrine-orm/tests/Entity/Unknown.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yokai\Batch\Tests\Bridge\Doctrine\ORM\Entity;
+
+final class Unknown
+{
+    public int $id;
+}

src/batch-doctrine-orm/tests/Entity/User.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yokai\Batch\Tests\Bridge\Doctrine\ORM\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: 'user')]
+class User
+{
+    #[ORM\Column(type: 'integer')]
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    public int $id;
+
+    #[ORM\Column(type: 'string')]
+    public string $name;
+
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+}

src/batch-doctrine-orm/tests/EntityReaderTest.php

@@ -4,77 +4,55 @@
 
 namespace Yokai\Batch\Tests\Bridge\Doctrine\ORM;
 
-use Doctrine\ORM\AbstractQuery;
 use Doctrine\ORM\EntityManager;
-use Doctrine\ORM\QueryBuilder;
+use Doctrine\ORM\ORMSetup;
+use Doctrine\ORM\Tools\SchemaTool;
 use Doctrine\Persistence\ManagerRegistry;
+use Generator;
 use PHPUnit\Framework\TestCase;
-use Prophecy\PhpUnit\ProphecyTrait;
-use Prophecy\Prophecy\ObjectProphecy;
 use Yokai\Batch\Bridge\Doctrine\ORM\EntityReader;
 use Yokai\Batch\Exception\UnexpectedValueException;
+use Yokai\Batch\Tests\Bridge\Doctrine\ORM\Dummy\SingleManagerRegistry;
+use Yokai\Batch\Tests\Bridge\Doctrine\ORM\Entity\Unknown;
+use Yokai\Batch\Tests\Bridge\Doctrine\ORM\Entity\User;
 
 class EntityReaderTest extends TestCase
 {
-    use ProphecyTrait;
+    private EntityManager $manager;
+    private ManagerRegistry $doctrine;
 
-    private const ENTITY = 'App\Entity\User';
-
-    public function testRead()
+    protected function setUp(): void
     {
-        /** @var ObjectProphecy|AbstractQuery $query */
-        $query = $this->prophesize(AbstractQuery::class);
-        $query->toIterable()
-            ->shouldBeCalledTimes(1)
-            ->willReturn(
-                new \ArrayIterator([[$user1 = new User('1')], [$user2 = new User('2')], [$user3 = new User('3')]])
-            );
-
-        $queryBuilder = $this->getMockBuilder(QueryBuilder::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-        $queryBuilder->expects($this->once())
-            ->method('select')
-            ->with('e')
-            ->will($this->returnSelf());
-        $queryBuilder->expects($this->once())
-            ->method('from')
-            ->with(self::ENTITY)
-            ->will($this->returnSelf());
-        $queryBuilder->expects($this->once())
-            ->method('getQuery')
-            ->will($this->returnValue($query->reveal()));
+        $config = ORMSetup::createAttributeMetadataConfiguration([__DIR__ . '/Entity'], true);
+        $this->manager = EntityManager::create(['url' => \getenv('DATABASE_URL')], $config);
+        $this->doctrine = new SingleManagerRegistry($this->manager);
 
-        /** @var ObjectProphecy|EntityManager $manager */
-        $manager = $this->prophesize(EntityManager::class);
-        $manager->createQueryBuilder()
-            ->shouldBeCalledTimes(1)
-            ->willReturn($queryBuilder);
+        (new SchemaTool($this->manager))
+            ->createSchema($this->manager->getMetadataFactory()->getAllMetadata());
+    }
 
-        /** @var ObjectProphecy|ManagerRegistry $doctrine */
-        $doctrine = $this->prophesize(ManagerRegistry::class);
-        $doctrine->getManagerForClass(self::ENTITY)
-            ->shouldBeCalledTimes(1)
-            ->willReturn($manager->reveal());
+    public function testRead(): void
+    {
+        $this->manager->persist($forest = new User('Forest'));
+        $this->manager->persist($jenny = new User('Jenny'));
+        $this->manager->persist($bubba = new User('Bubba'));
+        $this->manager->flush();
 
-        $reader = new EntityReader($doctrine->reveal(), self::ENTITY);
+        $reader = new EntityReader($this->doctrine, User::class);
         $entities = $reader->read();
 
-        self::assertInstanceOf(\Generator::class, $entities);
-        self::assertSame([$user1, $user2, $user3], iterator_to_array($entities));
+        self::assertInstanceOf(Generator::class, $entities);
+        self::assertSame([$forest, $jenny, $bubba], \iterator_to_array($entities));
     }
 
-    public function testReadExceptionWithUnknownEntityClass()
+    public function testReadExceptionWithUnknownEntityClass(): void
     {
         $this->expectException(UnexpectedValueException::class);
 
-        /** @var ObjectProphecy|ManagerRegistry $doctrine */
-        $doctrine = $this->prophesize(ManagerRegistry::class);
-        $doctrine->getManagerForClass(self::ENTITY)
-            ->shouldBeCalledTimes(1)
-            ->willReturn(null);
+        $reader = new EntityReader($this->doctrine, Unknown::class);
+        $entities = $reader->read();
 
-        $reader = new EntityReader($doctrine->reveal(), self::ENTITY);
-        iterator_to_array($reader->read()); // the method is using a yield expression
+        self::assertInstanceOf(Generator::class, $entities);
+        \iterator_to_array($entities);
     }
 }