add unit tests for ProcessingResul

src/Processor/ProcessingResult.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Contract\Processor;
+
+/**
+ * Interface ProcessingResult.
+ *
+ * Defines the contract for handling processing results, including errors and processed data management.
+ *
+ * @category  Processor
+ *
+ * @author    Walmir Silva <walmir.silva@kariricode.org>
+ * @license   MIT
+ *
+ * @see       https://kariricode.org/
+ */
+interface ProcessingResult
+{
+    /**
+     * Adds an error associated with a specific property.
+     *
+     * @param string $property The property where the error occurred
+     * @param string $errorKey A unique identifier for the type of error
+     * @param string $message A human-readable error message
+     */
+    public function addError(string $property, string $errorKey, string $message): void;
+
+    /**
+     * Stores processed data for a specific property.
+     *
+     * @param string $property The property associated with the processed data
+     * @param mixed $value The processed value to be stored
+     */
+    public function setProcessedData(string $property, mixed $value): void;
+
+    /**
+     * Checks if there are any errors in the processing result.
+     *
+     * @return bool True if there are errors, false otherwise
+     */
+    public function hasErrors(): bool;
+
+    /**
+     * Retrieves all errors that occurred during processing.
+     *
+     * @return array<string, array<int, array{errorKey: string, message: string}>>
+     *                                                                             A map of property names to their associated errors
+     */
+    public function getErrors(): array;
+
+    /**
+     * Retrieves all processed data.
+     *
+     * @return array<string, mixed> A map of property names to their processed values
+     */
+    public function getProcessedData(): array;
+
+    /**
+     * Converts the processing result into an array representation.
+     *
+     * @return array{
+     *     isValid: bool,
+     *     errors: array<string, array<int, array{errorKey: string, message: string}>>,
+     *     processedData: array<string, mixed>
+     * }
+     */
+    public function toArray(): array;
+
+    /**
+     * Clears all stored errors and processed data.
+     */
+    public function clear(): void;
+}

src/Processor/ValidatableProcessor.php

@@ -23,6 +23,16 @@
  */
 interface ValidatableProcessor extends Processor
 {
+    /**
+     * Resets the processor's state to its initial values.
+     *
+     * This method should be called before reusing the processor instance to ensure
+     * that any previous validation state is cleared and the processor is ready for
+     * new validation. This is particularly important when processors are reused
+     * across multiple validation cycles.
+     */
+    public function reset(): void;
+
     /**
      * Checks if the processor is in a valid state.
      *

tests/Processor/ProcessingResultTest.php

@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Contract\Tests\Processor;
+
+use KaririCode\Contract\Processor\ProcessingResult;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+final class ProcessingResultTest extends TestCase
+{
+    private ProcessingResult|MockObject $processingResultMock;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->processingResultMock = $this->createMock(ProcessingResult::class);
+    }
+
+    public function testAddError(): void
+    {
+        $this->processingResultMock->expects($this->once())
+            ->method('addError')
+            ->with('property', 'error_key', 'error message');
+
+        $this->processingResultMock->addError('property', 'error_key', 'error message');
+    }
+
+    public function testSetProcessedData(): void
+    {
+        $this->processingResultMock->expects($this->once())
+            ->method('setProcessedData')
+            ->with('property', 'value');
+
+        $this->processingResultMock->setProcessedData('property', 'value');
+    }
+
+    public function testHasErrors(): void
+    {
+        $this->processingResultMock->expects($this->once())
+            ->method('hasErrors')
+            ->willReturn(true);
+
+        $this->assertTrue($this->processingResultMock->hasErrors());
+    }
+
+    public function testGetErrors(): void
+    {
+        $expectedErrors = [
+            'property' => [
+                [
+                    'errorKey' => 'error_key',
+                    'message' => 'error message',
+                ],
+            ],
+        ];
+
+        $this->processingResultMock->expects($this->once())
+            ->method('getErrors')
+            ->willReturn($expectedErrors);
+
+        $this->assertSame($expectedErrors, $this->processingResultMock->getErrors());
+    }
+
+    public function testGetProcessedData(): void
+    {
+        $expectedData = [
+            'property' => 'processed value',
+        ];
+
+        $this->processingResultMock->expects($this->once())
+            ->method('getProcessedData')
+            ->willReturn($expectedData);
+
+        $this->assertSame($expectedData, $this->processingResultMock->getProcessedData());
+    }
+
+    public function testToArray(): void
+    {
+        $expectedArray = [
+            'isValid' => false,
+            'errors' => [
+                'property' => [
+                    [
+                        'errorKey' => 'error_key',
+                        'message' => 'error message',
+                    ],
+                ],
+            ],
+            'processedData' => [
+                'property' => 'processed value',
+            ],
+        ];
+
+        $this->processingResultMock->expects($this->once())
+            ->method('toArray')
+            ->willReturn($expectedArray);
+
+        $this->assertSame($expectedArray, $this->processingResultMock->toArray());
+    }
+
+    public function testClear(): void
+    {
+        $this->processingResultMock->expects($this->once())
+            ->method('clear');
+
+        $this->processingResultMock->clear();
+    }
+}