├── LICENSE.txt
├── composer.json
└── src
    ├── Constraint
        ├── JsonValueMatches.php
        ├── JsonValueMatchesMany.php
        └── JsonValueMatchesSchema.php
    ├── Functions.php
    └── JsonAssertions.php


/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Martin Helmich <kontakt@martin-helmich.de>
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 
21 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "helmich/phpunit-json-assert",
 3 |     "description": "PHPUnit assertions for JSON documents",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Martin Helmich",
 8 |             "email": "m.helmich@mittwald.de"
 9 |         }
10 |     ],
11 |     "require": {
12 |         "php": "^8.1",
13 |         "softcreatr/jsonpath": "^0.8",
14 |         "justinrainbow/json-schema": "^5.0"
15 |     },
16 |     "conflict": {
17 |         "phpunit/phpunit": "<8.0 || >= 13.0"
18 |     },
19 |     "require-dev": {
20 |         "phpunit/phpunit": "^8.0 || ^9.0 || ^10.0 || ^11.0 || ^12.0"
21 |     },
22 |     "autoload": {
23 |         "psr-4": {
24 |             "Helmich\\JsonAssert\\": "src/"
25 |         }
26 |     },
27 |     "autoload-dev": {
28 |         "files": [
29 |             "src/Functions.php"
30 |         ]
31 |     },
32 |     "config": {
33 |         "sort-packages": true
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Constraint/JsonValueMatches.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Helmich\JsonAssert\Constraint;
  3 | 
  4 | use Flow\JSONPath\JSONPath;
  5 | use PHPUnit\Framework\Constraint\Constraint;
  6 | 
  7 | /**
  8 |  * A simple constraints that asserts that a single value of a JSON document
  9 |  * matches a given constraint.
 10 |  *
 11 |  * @package    Helmich\JsonAssert
 12 |  * @subpackage Constraint
 13 |  */
 14 | class JsonValueMatches extends Constraint
 15 | {
 16 | 
 17 |     /** @var string */
 18 |     private $jsonPath;
 19 | 
 20 |     /** @var Constraint */
 21 |     private $constraint;
 22 | 
 23 |     /** @var bool */
 24 |     private $matchAll;
 25 | 
 26 |     /**
 27 |      * JsonValueMatches constructor.
 28 |      *
 29 |      * @param string     $jsonPath   The JSON path that identifies the value(s)
 30 |      *                               in the JSON document that the constraint
 31 |      *                               should match
 32 |      * @param Constraint $constraint The actual constraint that the selected
 33 |      *                               value(s) must match
 34 |      * @param bool       $matchAll   This flag controls how this constraint
 35 |      *                               handles multiple values. Usually, this
 36 |      *                               constraint will match successfully, when
 37 |      *                               (at least) one found value matches the
 38 |      *                               given constraint. When this flag is set,
 39 |      *                               _all_ found values must match the
 40 |      *                               constraint.
 41 |      */
 42 |     public function __construct(string $jsonPath, Constraint $constraint, bool $matchAll = false)
 43 |     {
 44 |         $this->jsonPath   = $jsonPath;
 45 |         $this->constraint = $constraint;
 46 |         $this->matchAll   = $matchAll;
 47 |     }
 48 | 
 49 |     /**
 50 |      * Returns a string representation of the object.
 51 |      *
 52 |      * @return string
 53 |      */
 54 |     public function toString(): string
 55 |     {
 56 |         return "matches " . $this->constraint->toString() . " at JSON path '{$this->jsonPath}'";
 57 |     }
 58 | 
 59 |     /**
 60 |      * @inheritdoc
 61 |      */
 62 |     protected function matches($other): bool
 63 |     {
 64 |         if (is_string($other)) {
 65 |             $other = json_decode($other, true);
 66 |         }
 67 | 
 68 |         $result = (new JSONPath($other))->find($this->jsonPath);
 69 |         if (!isset($result[0])) {
 70 |             return false;
 71 |         }
 72 | 
 73 |         $combineFunc = $this->buildCombinationFunction();
 74 |         $matches     = null;
 75 | 
 76 |         foreach ($result as $v) {
 77 |             if ($v instanceof JSONPath) {
 78 |                 $v = $v->getData();
 79 |             }
 80 | 
 81 |             $singleMatchResult = $this->constraint->evaluate($v, '', true);
 82 |             $matches           = $combineFunc($matches, $singleMatchResult);
 83 |         }
 84 | 
 85 |         return $matches;
 86 |     }
 87 | 
 88 |     /**
 89 |      * @return callable
 90 |      */
 91 |     protected function buildCombinationFunction(): callable
 92 |     {
 93 |         if ($this->matchAll) {
 94 |             return function ($first, $second) {
 95 |                 return ($first === null) ? $second : $first && $second;
 96 |             };
 97 |         }
 98 | 
 99 |         return function ($first, $second) {
100 |             return ($first === null) ? $second : $first || $second;
101 |         };
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/Constraint/JsonValueMatchesMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Helmich\JsonAssert\Constraint;
 3 | 
 4 | use PHPUnit\Framework\Constraint\Constraint;
 5 | use PHPUnit\Framework\Constraint\IsEqual;
 6 | 
 7 | /**
 8 |  * Constraint that asserts that a JSON document matches an entire set of JSON
 9 |  * value constraints.
10 |  *
11 |  * @package    Helmich\JsonAssert
12 |  * @subpackage Constraint
13 |  */
14 | class JsonValueMatchesMany extends Constraint
15 | {
16 | 
17 |     /** @var JsonValueMatches[] */
18 |     private $constraints = array();
19 | 
20 |     /**
21 |      * JsonValueMatchesMany constructor.
22 |      *
23 |      * @param array $constraints A set of constraints. This is a key-value map
24 |      *                           where each key is a JSON path expression,
25 |      *                           associated with a constraint that all values
26 |      *                           matched by that expression must fulfill.
27 |      */
28 |     public function __construct(array $constraints)
29 |     {
30 |         foreach ($constraints as $key => $constraint) {
31 |             if (!$constraint instanceof Constraint) {
32 |                 $constraint = new IsEqual($constraint);
33 |             }
34 | 
35 |             $this->constraints[] = new JsonValueMatches($key, $constraint);
36 |         }
37 |     }
38 | 
39 |     /**
40 |      * Returns a string representation of the object.
41 |      *
42 |      * @return string
43 |      */
44 |     public function toString(): string
45 |     {
46 |         return implode(
47 |             ' and ',
48 |             array_map(
49 |                 function (Constraint $constraint) {
50 |                     return $constraint->toString();
51 |                 },
52 |                 $this->constraints
53 |             )
54 |         );
55 |     }
56 | 
57 |     /**
58 |      * @inheritdoc
59 |      */
60 |     protected function matches($other): bool
61 |     {
62 |         foreach ($this->constraints as $constraint) {
63 |             if (!$constraint->evaluate($other, '', true)) {
64 |                 return false;
65 |             }
66 |         }
67 |         return true;
68 |     }
69 | 
70 |     /**
71 |      * Returns a string representation of matches that evaluate to false.
72 |      *
73 |      * @return string
74 |      */
75 |     protected function additionalFailureDescription($other): string
76 |     {
77 |         /** @var string[] */
78 |         $failedConstraints = array();
79 | 
80 |         foreach ($this->constraints as $constraint) {
81 |             if (!$constraint->evaluate($other, '', true)) {
82 |                 $failedConstraints[] = $constraint->toString();
83 |             }
84 |         }
85 |         
86 |         return "\n" . implode("\n", $failedConstraints);
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/Constraint/JsonValueMatchesSchema.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Helmich\JsonAssert\Constraint;
 3 | 
 4 | use JsonSchema\Validator;
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | use stdClass;
 7 | 
 8 | /**
 9 |  * A constraint for asserting that a JSON document matches a schema
10 |  *
11 |  * @package    Helmich\JsonAssert
12 |  * @subpackage Constraint
13 |  */
14 | class JsonValueMatchesSchema extends Constraint
15 | {
16 |     /**
17 |      * @var array|stdClass
18 |      */
19 |     private $schema;
20 | 
21 |     /**
22 |      * JsonValueMatchesSchema constructor.
23 |      *
24 |      * @param array|stdClass $schema The JSON schema
25 |      */
26 |     public function __construct($schema)
27 |     {
28 |         $this->schema = $this->forceToObject($schema);
29 |     }
30 | 
31 |     /**
32 |      * VERY dirty hack to force a JSON document into an object.
33 |      *
34 |      * Yell if you can think of something better.
35 |      *
36 |      * @param array|stdClass $jsonDocument
37 |      * @return stdClass
38 |      */
39 |     private function forceToObject($jsonDocument)
40 |     {
41 |         if (is_string($jsonDocument)) {
42 |             return json_decode($jsonDocument);
43 |         }
44 | 
45 |         return json_decode(json_encode($jsonDocument));
46 |     }
47 | 
48 |     /**
49 |      * @inheritdoc
50 |      */
51 |     protected function matches($other): bool
52 |     {
53 |         $other = $this->forceToObject($other);
54 | 
55 |         $validator = new Validator();
56 |         $validator->check($other, $this->schema);
57 | 
58 |         return $validator->isValid();
59 |     }
60 | 
61 |     /**
62 |      * @inheritdoc
63 |      */
64 |     protected function additionalFailureDescription($other): string
65 |     {
66 |         $other = $this->forceToObject($other);
67 | 
68 |         $validator = new Validator();
69 |         $validator->check($other, $this->schema);
70 | 
71 |         return implode("\n", array_map(function ($error) {
72 |             return sprintf("[%s] %s", $error['property'], $error['message']);
73 |         }, $validator->getErrors()));
74 |     }
75 | 
76 |     /**
77 |      * Returns a string representation of the object.
78 |      *
79 |      * @return string
80 |      */
81 |     public function toString(): string
82 |     {
83 |         return 'matches JSON schema';
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Helmich\JsonAssert\Constraint\JsonValueMatches;
 4 | use Helmich\JsonAssert\Constraint\JsonValueMatchesMany;
 5 | use Helmich\JsonAssert\Constraint\JsonValueMatchesSchema;
 6 | use PHPUnit\Framework\Constraint\Constraint;
 7 | use PHPUnit\Framework\Constraint\IsEqual;
 8 | 
 9 | function containsJsonValue(string $path, $constraint): JsonValueMatches
10 | {
11 |     if (!$constraint instanceof Constraint) {
12 |         $constraint = new IsEqual($constraint);
13 |     }
14 | 
15 |     return new JsonValueMatches($path, $constraint);
16 | }
17 | 
18 | function matchesJsonConstraints(array $constraints): JsonValueMatchesMany
19 | {
20 |     return new JsonValueMatchesMany($constraints);
21 | }
22 | 
23 | function matchesJsonSchema(array $schema): JsonValueMatchesSchema
24 | {
25 |     return new JsonValueMatchesSchema($schema);
26 | }
27 | 


--------------------------------------------------------------------------------
/src/JsonAssertions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Helmich\JsonAssert;
  3 | 
  4 | use Helmich\JsonAssert\Constraint\JsonValueMatches;
  5 | use Helmich\JsonAssert\Constraint\JsonValueMatchesMany;
  6 | use Helmich\JsonAssert\Constraint\JsonValueMatchesSchema;
  7 | use PHPUnit\Framework\Assert;
  8 | use PHPUnit\Framework\Constraint\Constraint;
  9 | use PHPUnit\Framework\Constraint\IsEqual;
 10 | 
 11 | /**
 12 |  * A trait that can be used in test classes for easy use of JSON assertions
 13 |  *
 14 |  * @package Helmich\JsonAssert
 15 |  */
 16 | trait JsonAssertions
 17 | {
 18 | 
 19 |     /**
 20 |      * Asserts that at least one of a set of JSON values in a document match a
 21 |      * given constraint
 22 |      *
 23 |      * @param mixed      $jsonDocument A JSON document. If this is a string, it
 24 |      *                                 will be assumed to be an encoded JSON
 25 |      *                                 document
 26 |      * @param string     $jsonPath     The JSON path expression that should be
 27 |      *                                 matched
 28 |      * @param Constraint $constraint   The constraint that the matched value
 29 |      *                                 must match
 30 |      * @return void
 31 |      */
 32 |     public static function assertJsonValueMatches($jsonDocument, string $jsonPath, Constraint $constraint)
 33 |     {
 34 |         Assert::assertThat($jsonDocument, new JsonValueMatches($jsonPath, $constraint));
 35 |     }
 36 | 
 37 |     /**
 38 |      * Asserts that all of a set of JSON values in a document match a given
 39 |      * constraint
 40 |      *
 41 |      * @param mixed      $jsonDocument A JSON document. If this is a string, it
 42 |      *                                 will be assumed to be an encoded JSON
 43 |      *                                 document
 44 |      * @param string     $jsonPath     The JSON path expression that should be
 45 |      *                                 matched
 46 |      * @param Constraint $constraint   The constraint that the matched value
 47 |      *                                 must match
 48 |      * @return void
 49 |      */
 50 |     public static function assertAllJsonValuesMatch($jsonDocument, string $jsonPath, Constraint $constraint)
 51 |     {
 52 |         Assert::assertThat($jsonDocument, new JsonValueMatches($jsonPath, $constraint, true));
 53 |     }
 54 | 
 55 |     /**
 56 |      * Asserts that at least one of a set of JSON values in a document is equal
 57 |      * to a given value
 58 |      *
 59 |      * @param mixed  $jsonDocument  A JSON document. If this is a string, it
 60 |      *                              will be assumed to be an encoded JSON document
 61 |      * @param string $jsonPath      The JSON path expression that should be
 62 |      *                              matched
 63 |      * @param mixed  $expectedValue The value that the matched values should be
 64 |      *                              equal to.
 65 |      * @return void
 66 |      */
 67 |     public static function assertJsonValueEquals($jsonDocument, string $jsonPath, $expectedValue)
 68 |     {
 69 |         static::assertJsonValueMatches(
 70 |             $jsonDocument,
 71 |             $jsonPath,
 72 |             new IsEqual($expectedValue)
 73 |         );
 74 |     }
 75 | 
 76 |     /**
 77 |      * Asserts that all of a set of JSON values in a document are equal to a
 78 |      * given value
 79 |      *
 80 |      * @param mixed  $jsonDocument  A JSON document. If this is a string, it
 81 |      *                              will be assumed to be an encoded JSON
 82 |      *                              document
 83 |      * @param string $jsonPath      The JSON path expression that should be
 84 |      *                              matched
 85 |      * @param mixed  $expectedValue The value that the matched values should be
 86 |      *                              equal to.
 87 |      * @return void
 88 |      */
 89 |     public static function assertAllJsonValuesEqual($jsonDocument, string $jsonPath, $expectedValue)
 90 |     {
 91 |         static::assertAllJsonValuesMatch(
 92 |             $jsonDocument,
 93 |             $jsonPath,
 94 |             new IsEqual($expectedValue)
 95 |         );
 96 |     }
 97 | 
 98 |     /**
 99 |      * Asserts that a JSON document matches an entire set of constraints.
100 |      *
101 |      * @param mixed $jsonDocument A JSON document. If this is a string, it will
102 |      *                            be assumed to be an encoded JSON document
103 |      * @param array $constraints  A set of constraints. This is a key-value map
104 |      *                            where each key is a JSON path expression,
105 |      *                            associated with a constraint that all values
106 |      *                            matched by that expression must fulfill.
107 |      * @return void
108 |      */
109 |     public static function assertJsonDocumentMatches($jsonDocument, array $constraints)
110 |     {
111 |         Assert::assertThat($jsonDocument, new JsonValueMatchesMany($constraints));
112 |     }
113 | 
114 |     /**
115 |      * Assert that a JSON document matches a given JSON schema.
116 |      *
117 |      * @param mixed $jsonDocument A JSON document. If this is a string, it will
118 |      *                            be assumed to be an encoded JSON document
119 |      * @param array $schema       A JSON schema
120 |      * @return void
121 |      */
122 |     public static function assertJsonDocumentMatchesSchema($jsonDocument, $schema)
123 |     {
124 |         Assert::assertThat($jsonDocument, new JsonValueMatchesSchema($schema));
125 |     }
126 | }
127 | 


--------------------------------------------------------------------------------