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

yann-eugone · web-flow · commit 6c983891ebee · 2022-06-01T14:33:05.000+02:00
* 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
diff --git a/tests/Dummy/DebugEventDispatcher.php b/tests/Dummy/DebugEventDispatcher.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yokai\Batch\Tests\Dummy;
+
+use Psr\EventDispatcher\EventDispatcherInterface;
+
+final class DebugEventDispatcher implements EventDispatcherInterface
+{
+    /**
+     * @var object[]
+     */
+    private array $events = [];
+
+    /**
+     * @var array<string, callable[]>
+     */
+    private array $listeners = [];
+
+    public function dispatch(object $event)
+    {
+        $this->events[] = $event;
+        foreach ($this->listeners[\get_class($event)] ?? [] as $listener) {
+            $listener($event);
+        }
+    }
+
+    public function addListener(string $event, callable $listener): void
+    {
+        $this->listeners[$event] ??= [];
+        $this->listeners[$event][] = $listener;
+    }
+
+    /**
+     * @return object[]
+     */
+    public function getEvents(): array
+    {
+        return $this->events;
+    }
+}
diff --git a/tests/Job/JobExecutorTest.php b/tests/Job/JobExecutorTest.php
@@ -9,7 +9,6 @@
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
 use Prophecy\Prophecy\ObjectProphecy;
-use Psr\EventDispatcher\EventDispatcherInterface;
 use Throwable;
 use Yokai\Batch\BatchStatus;
 use Yokai\Batch\Event\ExceptionEvent;
@@ -20,41 +19,31 @@
 use Yokai\Batch\JobExecution;
 use Yokai\Batch\Registry\JobRegistry;
 use Yokai\Batch\Test\Storage\InMemoryJobExecutionStorage;
+use Yokai\Batch\Tests\Dummy\DebugEventDispatcher;
 use Yokai\Batch\Warning;
 
 class JobExecutorTest extends TestCase
 {
     use ProphecyTrait;
 
-    private const JOB_NAME = 'phpunit';
-
-    /**
-     * @var ObjectProphecy&JobInterface
-     */
-    private ObjectProphecy $job;
-
-    /**
-     * @var ObjectProphecy&EventDispatcherInterface
-     */
-    private ObjectProphecy $dispatcher;
-
+    private JobInterface|ObjectProphecy $job;
+    private DebugEventDispatcher $dispatcher;
     private JobExecutor $executor;
 
     protected function setUp(): void
     {
         $this->job = $this->prophesize(JobInterface::class);
-        $this->dispatcher = $this->prophesize(EventDispatcherInterface::class);
-
+        $this->dispatcher = new DebugEventDispatcher();
         $this->executor = new JobExecutor(
-            JobRegistry::fromJobArray([self::JOB_NAME => $this->job->reveal()]),
+            JobRegistry::fromJobArray(['test.job_executor' => $this->job->reveal()]),
             new InMemoryJobExecutionStorage(),
-            $this->dispatcher->reveal()
+            $this->dispatcher
         );
     }
 
     public function testLaunch(): void
     {
-        $execution = JobExecution::createRoot('123', self::JOB_NAME);
+        $execution = JobExecution::createRoot('123', 'test.job_executor');
         $this->job->execute($execution)
             ->shouldBeCalledTimes(1)
             ->will(function (array $args): void {
@@ -66,11 +55,6 @@ public function testLaunch(): void
 
         $this->executor->execute($execution);
 
-        $this->dispatcher->dispatch(Argument::type(PreExecuteEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-        $this->dispatcher->dispatch(Argument::type(PostExecuteEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-
         self::assertNotNull($execution->getStartTime());
         self::assertNotNull($execution->getEndTime());
         self::assertSame(BatchStatus::COMPLETED, $execution->getStatus()->getValue());
@@ -79,26 +63,23 @@ public function testLaunch(): void
         self::assertStringContainsString('DEBUG: Starting job', $logs);
         self::assertStringContainsString('INFO: Job executed successfully', $logs);
         self::assertStringContainsString('DEBUG: Job produced summary', $logs);
+        $events = $this->dispatcher->getEvents();
+        self::assertCount(2, $events);
+        self::assertInstanceOf(PreExecuteEvent::class, $events[0] ?? null);
+        self::assertInstanceOf(PostExecuteEvent::class, $events[1] ?? null);
     }
 
     /**
      * @dataProvider errors
      */
     public function testLaunchJobCatchErrors(Throwable $error): void
     {
-        $execution = JobExecution::createRoot('123', self::JOB_NAME);
+        $execution = JobExecution::createRoot('123', 'test.job_executor');
         $this->job->execute($execution)
             ->willThrow($error);
 
         $this->executor->execute($execution);
 
-        $this->dispatcher->dispatch(Argument::type(PreExecuteEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-        $this->dispatcher->dispatch(Argument::type(ExceptionEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-        $this->dispatcher->dispatch(Argument::type(PostExecuteEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-
         self::assertNotNull($execution->getStartTime());
         self::assertNotNull($execution->getEndTime());
         self::assertSame(BatchStatus::FAILED, $execution->getStatus()->getValue());
@@ -107,54 +88,55 @@ public function testLaunchJobCatchErrors(Throwable $error): void
         $logs = (string)$execution->getLogs();
         self::assertStringContainsString('DEBUG: Starting job', $logs);
         self::assertStringContainsString('ERROR: Job did not executed successfully', $logs);
+        $events = $this->dispatcher->getEvents();
+        self::assertCount(3, $events);
+        self::assertInstanceOf(PreExecuteEvent::class, $events[0] ?? null);
+        self::assertInstanceOf(ExceptionEvent::class, $events[1] ?? null);
+        self::assertInstanceOf(PostExecuteEvent::class, $events[2] ?? null);
     }
 
     public function testLaunchErrorWithStatusListener(): void
     {
-        $execution = JobExecution::createRoot('123', self::JOB_NAME);
+        $execution = JobExecution::createRoot('123', 'test.job_executor');
         $this->job->execute($execution)
             ->willThrow($exception = new \RuntimeException());
 
-        $this->dispatcher->dispatch(Argument::type(ExceptionEvent::class))
-            ->shouldBeCalledTimes(1)
-            ->will(function (array $args) use ($exception) {
-                /** @var ExceptionEvent $event */
-                $event = $args[0];
+        $this->dispatcher->addListener(
+            ExceptionEvent::class,
+            function (ExceptionEvent $event) use ($exception) {
                 Assert::assertSame($exception, $event->getException());
                 $event->setStatus(BatchStatus::COMPLETED);
-            });
+            }
+        );
 
         $this->executor->execute($execution);
 
-        $this->dispatcher->dispatch(Argument::type(PreExecuteEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-        $this->dispatcher->dispatch(Argument::type(PostExecuteEvent::class))
-            ->shouldHaveBeenCalledTimes(1);
-
         self::assertNotNull($execution->getStartTime());
         self::assertNotNull($execution->getEndTime());
         self::assertSame(BatchStatus::COMPLETED, $execution->getStatus()->getValue());
         $logs = (string)$execution->getLogs();
         self::assertStringContainsString('DEBUG: Starting job', $logs);
         self::assertStringContainsString('INFO: Job executed successfully', $logs);
+        $events = $this->dispatcher->getEvents();
+        self::assertCount(3, $events);
+        self::assertInstanceOf(PreExecuteEvent::class, $events[0] ?? null);
+        self::assertInstanceOf(ExceptionEvent::class, $events[1] ?? null);
+        self::assertInstanceOf(PostExecuteEvent::class, $events[2] ?? null);
     }
 
     public function testLaunchJobNotExecutable(): void
     {
         $this->job->execute(Argument::any())
             ->shouldNotBeCalled();
 
-        $execution = JobExecution::createRoot('123', self::JOB_NAME, new BatchStatus(BatchStatus::COMPLETED));
+        $execution = JobExecution::createRoot('123', 'test.job_executor', new BatchStatus(BatchStatus::COMPLETED));
         $this->executor->execute($execution);
 
-        $this->dispatcher->dispatch(Argument::type(PreExecuteEvent::class))
-            ->shouldNotHaveBeenCalled();
-        $this->dispatcher->dispatch(Argument::type(PostExecuteEvent::class))
-            ->shouldNotHaveBeenCalled();
-
         $logs = (string)$execution->getLogs();
         self::assertStringContainsString('WARNING: Job execution not allowed to be executed', $logs);
         self::assertStringNotContainsString('DEBUG: Starting job', $logs);
+        $events = $this->dispatcher->getEvents();
+        self::assertCount(0, $events);
     }
 
     public function errors(): \Generator
diff --git a/tests/Launcher/SimpleJobLauncherTest.php b/tests/Launcher/SimpleJobLauncherTest.php
@@ -6,7 +6,6 @@
 
 use PHPUnit\Framework\TestCase;
 use Prophecy\PhpUnit\ProphecyTrait;
-use Psr\EventDispatcher\EventDispatcherInterface;
 use Yokai\Batch\BatchStatus;
 use Yokai\Batch\Factory\JobExecutionFactory;
 use Yokai\Batch\Job\JobExecutionAccessor;
@@ -24,7 +23,6 @@ class SimpleJobLauncherTest extends TestCase
     public function test(): void
     {
         $job = $this->prophesize(JobInterface::class);
-        $dispatcher = $this->prophesize(EventDispatcherInterface::class);
 
         $launcher = new SimpleJobLauncher(
             new JobExecutionAccessor(
@@ -34,7 +32,7 @@ public function test(): void
             new JobExecutor(
                 JobRegistry::fromJobArray(['phpunit' => $job->reveal()]),
                 $jobExecutionStorage,
-                $dispatcher->reveal()
+                null
             )
         );
 
