Allow ItemJob to skip items for any reason (#41)

yann-eugone · web-flow · commit 6cf466beb17c · 2021-09-27T18:44:26.000+02:00
* Replace InvalidItemException with SkipItemException and let developer what to do with these exception

* Handle impact of SkipInvalidItemException on symfony/validator bridge

* Handle impact of SkipInvalidItemException on symfony/serializer bridge

* Enhanced documentation of sources

* Assert skip item exception are updating summary
diff --git a/src/DenormalizeItemProcessor.php b/src/DenormalizeItemProcessor.php
@@ -5,25 +5,18 @@
 namespace Yokai\Batch\Bridge\Symfony\Serializer;
 
 use Symfony\Component\Serializer\Exception\ExceptionInterface;
+use Symfony\Component\Serializer\Exception\UnsupportedException;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
-use Yokai\Batch\Job\Item\InvalidItemException;
+use Yokai\Batch\Job\Item\Exception\SkipItemException;
 use Yokai\Batch\Job\Item\ItemProcessorInterface;
 
+/**
+ * This {@see ItemProcessorInterface} uses Symfony's serializer to denormalize items.
+ */
 final class DenormalizeItemProcessor implements ItemProcessorInterface
 {
-    /**
-     * @var DenormalizerInterface
-     */
     private DenormalizerInterface $denormalizer;
-
-    /**
-     * @var string
-     */
     private string $type;
-
-    /**
-     * @var string|null
-     */
     private ?string $format;
 
     /**
@@ -51,28 +44,17 @@ public function __construct(
      */
     public function process($item)
     {
-        if (!$this->denormalizer->supportsDenormalization($item, $this->type, $this->format)) {
-            throw new InvalidItemException(
-                'Unable to denormalize item. Not supported.',
-                [
-                    'item' => is_object($item) ? get_class($item) : gettype($item),
-                    'format' => $this->format,
-                ]
-            );
-        }
-
         try {
+            if (!$this->denormalizer->supportsDenormalization($item, $this->type, $this->format)) {
+                throw new UnsupportedException('Unable to denormalize item. Not supported.');
+            }
+
             $object = $this->denormalizer->denormalize($item, $this->type, $this->format, $this->context);
         } catch (ExceptionInterface $exception) {
-            throw new InvalidItemException(
-                'Unable to denormalize item. An exception occurred.',
-                [
-                    'item' => is_object($item) ? get_class($item) : gettype($item),
-                    'format' => $this->format,
-                    'context' => $this->context,
-                ],
-                0,
-                $exception
+            throw SkipItemException::onError(
+                $item,
+                $exception,
+                ['format' => $this->format, 'context' => $this->context]
             );
         }
 
diff --git a/src/NormalizeItemProcessor.php b/src/NormalizeItemProcessor.php
@@ -5,20 +5,17 @@
 namespace Yokai\Batch\Bridge\Symfony\Serializer;
 
 use Symfony\Component\Serializer\Exception\ExceptionInterface;
+use Symfony\Component\Serializer\Exception\UnsupportedException;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
-use Yokai\Batch\Job\Item\InvalidItemException;
+use Yokai\Batch\Job\Item\Exception\SkipItemException;
 use Yokai\Batch\Job\Item\ItemProcessorInterface;
 
+/**
+ * This {@see ItemProcessorInterface} uses Symfony's serializer to normalize items.
+ */
 final class NormalizeItemProcessor implements ItemProcessorInterface
 {
-    /**
-     * @var NormalizerInterface
-     */
     private NormalizerInterface $normalizer;
-
-    /**
-     * @var string|null
-     */
     private ?string $format;
 
     /**
@@ -41,28 +38,17 @@ public function __construct(NormalizerInterface $normalizer, string $format = nu
      */
     public function process($item)
     {
-        if (!$this->normalizer->supportsNormalization($item, $this->format)) {
-            throw new InvalidItemException(
-                'Unable to normalize item. Not supported.',
-                [
-                    'item' => is_object($item) ? get_class($item) : gettype($item),
-                    'format' => $this->format,
-                ]
-            );
-        }
-
         try {
+            if (!$this->normalizer->supportsNormalization($item, $this->format)) {
+                throw new UnsupportedException('Unable to normalize item. Not supported.');
+            }
+
             return $this->normalizer->normalize($item, $this->format, $this->context);
         } catch (ExceptionInterface $exception) {
-            throw new InvalidItemException(
-                'Unable to normalize item. An exception occurred.',
-                [
-                    'item' => is_object($item) ? get_class($item) : gettype($item),
-                    'format' => $this->format,
-                    'context' => $this->context,
-                ],
-                0,
-                $exception
+            throw SkipItemException::onError(
+                $item,
+                $exception,
+                ['format' => $this->format, 'context' => $this->context]
             );
         }
     }
diff --git a/tests/DenormalizeItemProcessorTest.php b/tests/DenormalizeItemProcessorTest.php
@@ -14,7 +14,7 @@
 use Symfony\Component\Serializer\Exception\ExceptionInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Yokai\Batch\Bridge\Symfony\Serializer\DenormalizeItemProcessor;
-use Yokai\Batch\Job\Item\InvalidItemException;
+use Yokai\Batch\Job\Item\Exception\SkipItemException;
 
 final class DenormalizeItemProcessorTest extends TestCase
 {
@@ -52,7 +52,7 @@ public function testProcess(string $type, ?string $format, array $context, $item
      */
     public function testUnsupported(string $type, ?string $format, array $context, $item): void
     {
-        $this->expectException(InvalidItemException::class);
+        $this->expectException(SkipItemException::class);
 
         $this->denormalizer->supportsDenormalization($item, $type, $format)
             ->shouldBeCalled()
@@ -70,7 +70,7 @@ public function testUnsupported(string $type, ?string $format, array $context, $
      */
     public function testException(string $type, ?string $format, array $context, $item): void
     {
-        $this->expectException(InvalidItemException::class);
+        $this->expectException(SkipItemException::class);
 
         $this->denormalizer->supportsDenormalization($item, $type, $format)
             ->shouldBeCalled()
diff --git a/tests/Job/Item/Exception/SkipItemWithWarningTest.php b/tests/Job/Item/Exception/SkipItemWithWarningTest.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yokai\Batch\Tests\Bridge\Symfony\Serializer\Job\Item\Exception;
+
+use PHPUnit\Framework\TestCase;
+use Yokai\Batch\Job\Item\Exception\SkipItemWithWarning;
+use Yokai\Batch\JobExecution;
+
+class SkipItemWithWarningTest extends TestCase
+{
+    public function test(): void
+    {
+        $execution = JobExecution::createRoot('123', 'testing');
+        $cause = new SkipItemWithWarning('An arbitrary message...');
+        $cause->report($execution, 'itemIndex', 'item');
+
+        self::assertCount(1, $execution->getWarnings());
+        self::assertSame('An arbitrary message...', $execution->getWarnings()[0]->getMessage());
+        self::assertSame([], $execution->getWarnings()[0]->getParameters());
+        self::assertSame(['itemIndex' => 'itemIndex', 'item' => 'item'], $execution->getWarnings()[0]->getContext());
+    }
+}
diff --git a/tests/NormalizeItemProcessorTest.php b/tests/NormalizeItemProcessorTest.php
@@ -11,10 +11,11 @@
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
 use Prophecy\Prophecy\ObjectProphecy;
-use Symfony\Component\Serializer\Exception\ExceptionInterface;
+use Symfony\Component\Serializer\Exception\BadMethodCallException;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 use Yokai\Batch\Bridge\Symfony\Serializer\NormalizeItemProcessor;
-use Yokai\Batch\Job\Item\InvalidItemException;
+use Yokai\Batch\Job\Item\Exception\SkipItemException;
+use Yokai\Batch\Job\Item\Exception\SkipItemOnError;
 
 final class NormalizeItemProcessorTest extends TestCase
 {
@@ -52,8 +53,6 @@ public function testProcess(?string $format, array $context, $item, $expected):
      */
     public function testUnsupported(?string $format, array $context, $item): void
     {
-        $this->expectException(InvalidItemException::class);
-
         $this->normalizer->supportsNormalization($item, $format)
             ->shouldBeCalled()
             ->willReturn(false);
@@ -62,29 +61,46 @@ public function testUnsupported(?string $format, array $context, $item): void
 
         $processor = new NormalizeItemProcessor($this->normalizer->reveal(), $format, $context);
 
-        $processor->process($item);
+        $exception = null;
+        try {
+            $processor->process($item);
+        } catch (SkipItemException $exception) {
+            // just capture the exception
+        }
+
+        self::assertNotNull($exception, 'Processor has thrown an exception');
+        $cause = $exception->getCause();
+        self::assertInstanceOf(SkipItemOnError::class, $cause);
+        /** @var SkipItemOnError $cause */
+        self::assertSame('Unable to normalize item. Not supported.', $cause->getError()->getMessage());
     }
 
     /**
      * @dataProvider sets
      */
     public function testException(?string $format, array $context, $item): void
     {
-        $this->expectException(InvalidItemException::class);
-
         $this->normalizer->supportsNormalization($item, $format)
             ->shouldBeCalled()
             ->willReturn(true);
         $this->normalizer->normalize($item, $format, $context)
             ->shouldBeCalled()
-            ->willThrow(
-                new class extends \Exception implements ExceptionInterface {
-                }
-            );
+            ->willThrow($exceptionThrown = new BadMethodCallException());
 
         $processor = new NormalizeItemProcessor($this->normalizer->reveal(), $format, $context);
 
-        $processor->process($item);
+        $exception = null;
+        try {
+            $processor->process($item);
+        } catch (SkipItemException $exception) {
+            // just capture the exception
+        }
+
+        self::assertNotNull($exception, 'Processor has thrown an exception');
+        $cause = $exception->getCause();
+        self::assertInstanceOf(SkipItemOnError::class, $cause);
+        /** @var SkipItemOnError $cause */
+        self::assertSame($exceptionThrown, $cause->getError());
     }
 
     public function sets(): Generator
