Merge pull request #4 from carsdotcom/hotfix/error-disappears-during-reporting

fix:this->error can be reset in the middle of validateOrThrow

Author: bbene

app/SchemaValidatorService.php

@@ -15,6 +15,7 @@
 use Opis\JsonSchema\Errors\ErrorFormatter;
 use Opis\JsonSchema\Errors\ValidationError;
 use Opis\JsonSchema\Uri;
+use Opis\JsonSchema\ValidationResult;
 use Opis\JsonSchema\Validator;
 use Symfony\Component\HttpFoundation\Response;
 
@@ -23,12 +24,6 @@ class SchemaValidatorService
     /** @var Validator */
     protected $validator = null;
 
-    /**
-     * error from the most recent ->validate() call
-     * @var ValidationError
-     */
-    protected $error = null;
-
     /**
      * As needed, build a validator in memory that knows how to load schema from local disk.
      * @return Validator
@@ -59,12 +54,25 @@ protected function getValidator(): Validator
      * @return bool
      */
     public function validate($data, $schema): bool
+    {
+        $result = $this->validationResult($data, $schema);
+        return $result->isValid();
+    }
+
+    /**
+     * Given data (could be a JsonModel, associative-array style JSON, primitive)
+     * and a schema (could be a URI, an object literal, a JSON-encoded string)
+     * return the ValidationResult of the upstream Opis library.
+     * This is a good approach for methods that want to do their own error formatting through a deeper relationship with Opis
+     * @param mixed $data
+     * @param mixed $schema
+     * @return ValidationResult
+     */
+    public function validationResult($data, $schema): ValidationResult
     {
         $validator = $this->getValidator();
         $data = $this->normalizeData($data);
-        $result = $validator->validate($data, $schema);
-        $this->error = $result->error();
-        return $result->isValid();
+        return $validator->validate($data, $schema);
     }
 
     /**
@@ -80,28 +88,6 @@ private function normalizeData($data)
         return json_decode(json_encode($data, JSON_THROW_ON_ERROR));
     }
 
-    /**
-     * Return an array of errors from the last *Validation call
-     * @return ValidationError|null
-     */
-    public function getError(): ?ValidationError
-    {
-        return $this->error;
-    }
-
-    /**
-     * Return an array of human readable errors from the last *Validation call
-     * @return array
-     */
-    public function getFormattedError(): array
-    {
-        if (!$this->error) {
-            return [];
-        }
-
-        return (new ErrorFormatter())->formatFlat($this->error);
-    }
-
     /**
      * This method will attempt to validate the provided data against the provided schema.  If the data is found to be
      * invalid, then a `JsonSchemaValidationException` exception is thrown with a default message of "Request body
@@ -122,23 +108,24 @@ public function validateOrThrow(
         bool $appendValidationDescriptions = false,
         int $failureHttpStatusCode = Response::HTTP_BAD_REQUEST,
     ): bool {
-        if ($this->validate($data, $schema) === false) {
+        $results = $this->validationResult($data, $schema);
+        if ($results->isValid() === false) {
             $message = $exceptionMessage ?: 'Request body contains invalid data!';
 
             if ($appendValidationDescriptions) {
                 $prepend = "\r\n* ";
-                $message .= $prepend . implode($prepend, $this->getFormattedError());
+                $message .= $prepend . implode($prepend, (new ErrorFormatter())->formatFlat($results->error()));
             }
 
             Log::debug(
                 "Json Schema Validation Error",
                 [
-                    'error' => (new ErrorFormatter())->format($this->error, true, null, null),
+                    'error' => (new ErrorFormatter())->format($results->error(), true, null, null),
                     'data' => $data
                 ]
             );
 
-            throw new JsonSchemaValidationException($message, $this->getError(), null, $failureHttpStatusCode);
+            throw new JsonSchemaValidationException($message, $results->error(), null, $failureHttpStatusCode);
         }
 
         return true;

app/Traits/JsonSchemaAssertions.php

@@ -22,23 +22,18 @@ trait JsonSchemaAssertions
      * @param string $schemaUri
      * @param mixed $object
      * @param string $message
-     * @param bool $addFormattedErrorToMessage
      * @return void
      */
     public static function assertValidForSchema(
         string $schemaUri,
                $object,
         string $message = '',
-        bool $addFormattedErrorToMessage = true,
     ): void {
-        $validates = SchemaValidator::validate($object, $schemaUri);
-
-        if ($addFormattedErrorToMessage) {
-            $prepend = "\r\n* ";
-            $message .= "\r\n" . $prepend . implode($prepend, SchemaValidator::getFormattedError());
+        try {
+            self::assertTrue(SchemaValidator::validate($object, $schemaUri), $message);
+        } catch (JsonSchemaValidationException $e) {
+            self::assertCanonicallySame([], $e->errors(), $message);
         }
-
-        static::assertThat($validates, static::isTrue(), $message);
     }
 
     /**
@@ -65,6 +60,4 @@ public static function assertValid(CanValidate $model): void
             self::assertCanonicallySame([], $e->errors(), 'Validation failed with errors.');
         }
     }
-
-
 }