├── LICENSE.txt
├── composer.json
└── src
    ├── Constraint
        ├── BodyMatchesConstraint.php
        ├── HasHeaderConstraint.php
        ├── HasMethodConstraint.php
        ├── HasQueryParameterConstraint.php
        ├── HasQueryParametersConstraint.php
        ├── HasStatusConstraint.php
        ├── HasUriConstraint.php
        ├── IsAbsoluteUriConstraint.php
        ├── UrlEncodedMatches.php
        └── UrlEncodedMatchesMany.php
    ├── Functions.php
    ├── Psr7Assertions.php
    └── Psr7AssertionsClass.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-psr7-assert",
 3 |     "description": "PHPUnit assertions for testing PSR7-compliant applications",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Martin Helmich",
 8 |             "email": "m.helmich@mittwald.de"
 9 |         }
10 |     ],
11 |     "require": {
12 |         "php": "^8.0",
13 |         "helmich/phpunit-json-assert": "^3.4",
14 |         "psr/http-message": "^1.1 || ^2.0"
15 |     },
16 |     "require-dev": {
17 |         "guzzlehttp/psr7": "^2.4",
18 |         "mockery/mockery": "^1.4.1",
19 |         "phpunit/phpunit": "^8.0 || ^9.0 || ^10.0"
20 |     },
21 |     "conflict": {
22 |         "phpunit/phpunit": "<8.0 || >= 11.0"
23 |     },
24 |     "autoload": {
25 |         "psr-4": {
26 |             "Helmich\\Psr7Assert\\": "src/"
27 |         }
28 |     },
29 |     "autoload-dev": {
30 |         "files": [
31 |             "vendor/helmich/phpunit-json-assert/src/Functions.php",
32 |             "src/Functions.php"
33 |         ]
34 |     },
35 |     "config": {
36 |         "sort-packages": true
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Constraint/BodyMatchesConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | use Psr\Http\Message\MessageInterface;
 7 | 
 8 | class BodyMatchesConstraint extends Constraint
 9 | {
10 | 
11 |     /** @var Constraint */
12 |     private $constraint;
13 | 
14 |     public function __construct(Constraint $constraint)
15 |     {
16 |         $this->constraint = $constraint;
17 |     }
18 | 
19 |     /**
20 |      * Returns a string representation of the object.
21 |      *
22 |      * @return string
23 |      */
24 |     public function toString(): string
25 |     {
26 |         return 'message body matches ' . $this->constraint->toString();
27 |     }
28 | 
29 |     protected function matches($other): bool
30 |     {
31 |         if (!$other instanceof MessageInterface) {
32 |             return false;
33 |         }
34 | 
35 |         $other->getBody()->rewind();
36 |         $body = $other->getBody()->getContents();
37 |         return $this->constraint->evaluate($body, '', true);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Constraint/HasHeaderConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Assert;
 6 | use PHPUnit\Framework\Constraint\Constraint;
 7 | use Psr\Http\Message\MessageInterface;
 8 | 
 9 | class HasHeaderConstraint extends Constraint
10 | {
11 | 
12 |     /** @var string */
13 |     private $name;
14 | 
15 |     /** @var Constraint */
16 |     private $constraint;
17 | 
18 |     public function __construct(string $name, $constraint = null)
19 |     {
20 |         if ($constraint === null) {
21 |             $constraint = Assert::logicalNot(Assert::isEmpty());
22 |         } elseif (!$constraint instanceof Constraint) {
23 |             $constraint = Assert::equalTo($constraint);
24 |         }
25 | 
26 |         $this->name       = strtolower($name);
27 |         $this->constraint = $constraint;
28 |     }
29 | 
30 |     /**
31 |      * Returns a string representation of the object.
32 |      *
33 |      * @return string
34 |      */
35 |     public function toString(): string
36 |     {
37 |         return "has header '{$this->name}' that {$this->constraint->toString()}";
38 |     }
39 | 
40 |     protected function matches($other): bool
41 |     {
42 |         if (!$other instanceof MessageInterface) {
43 |             return false;
44 |         }
45 | 
46 |         if (!$other->hasHeader($this->name)) {
47 |             return false;
48 |         }
49 | 
50 |         foreach ($other->getHeader($this->name) as $value) {
51 |             if ($this->constraint->evaluate($value, '', true)) {
52 |                 return true;
53 |             }
54 |         }
55 | 
56 |         return false;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Constraint/HasMethodConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | use Psr\Http\Message\RequestInterface;
 7 | 
 8 | class HasMethodConstraint extends Constraint
 9 | {
10 | 
11 |     /** @var string */
12 |     private $method;
13 | 
14 |     public function __construct(string $method)
15 |     {
16 |         $this->method = $method;
17 |     }
18 | 
19 |     /**
20 |      * Returns a string representation of the object.
21 |      *
22 |      * @return string
23 |      */
24 |     public function toString(): string
25 |     {
26 |         return "has request method {$this->method}";
27 |     }
28 | 
29 |     protected function matches($other): bool
30 |     {
31 |         if (!$other instanceof RequestInterface) {
32 |             return false;
33 |         }
34 | 
35 |         return $other->getMethod() === $this->method;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Constraint/HasQueryParameterConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | use Psr\Http\Message\RequestInterface;
 7 | use Psr\Http\Message\UriInterface;
 8 | 
 9 | class HasQueryParameterConstraint extends Constraint
10 | {
11 |     /** @var UrlEncodedMatches */
12 |     private $inner;
13 | 
14 |     public function __construct($nameMatcher, $valueMatcher = null)
15 |     {
16 |         $this->inner = new UrlEncodedMatches($nameMatcher, $valueMatcher);
17 |     }
18 | 
19 |     protected function matches($other): bool
20 |     {
21 |         if (is_string($other)) {
22 |             return $this->matchesString($other);
23 |         }
24 | 
25 |         if ($other instanceof UriInterface) {
26 |             return $this->matchesPsr7Uri($other);
27 |         }
28 | 
29 |         if ($other instanceof RequestInterface) {
30 |             return $this->matchesPsr7Uri($other->getUri());
31 |         }
32 | 
33 |         return false;
34 |     }
35 | 
36 |     private function matchesPsr7Uri(UriInterface $other): bool
37 |     {
38 |         $queryString = $other->getQuery();
39 |         return $this->matchesQueryString($queryString);
40 |     }
41 | 
42 |     private function matchesString(string $other): bool
43 |     {
44 |         $parsedUrl = parse_url($other);
45 |         if (!isset($parsedUrl["query"])) {
46 |             return false;
47 |         }
48 | 
49 |         return $this->matchesQueryString($parsedUrl["query"]);
50 |     }
51 | 
52 |     private function matchesQueryString(string $query): bool
53 |     {
54 |         return $this->inner->evaluate($query, "", true);
55 |     }
56 | 
57 | 
58 |     public function toString(): string
59 |     {
60 |         return 'query string ' . $this->inner->toString();
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Constraint/HasQueryParametersConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Helmich\Psr7Assert\Constraint;
 3 | 
 4 | use PHPUnit\Framework\Constraint\Constraint;
 5 | 
 6 | class HasQueryParametersConstraint extends Constraint
 7 | {
 8 |     /** @var HasQueryParameterConstraint[] */
 9 |     private $constraints = [];
10 | 
11 |     public function __construct(array $constraints)
12 |     {
13 |         foreach ($constraints as $key => $value) {
14 |             $this->constraints[] = new HasQueryParameterConstraint($key, $value);
15 |         }
16 |     }
17 | 
18 |     public function matches($other): bool
19 |     {
20 |         foreach ($this->constraints as $constraint) {
21 |             if (!$constraint->evaluate($other, "", true)) {
22 |                 return false;
23 |             }
24 |         }
25 | 
26 |         return true;
27 |     }
28 | 
29 |     public function toString(): string
30 |     {
31 |         return join(" and ", array_map(function(HasQueryParameterConstraint $c) {
32 |             return $c->toString();
33 |         }, $this->constraints));
34 |     }
35 | }


--------------------------------------------------------------------------------
/src/Constraint/HasStatusConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Assert;
 6 | use PHPUnit\Framework\Constraint\Constraint;
 7 | use Psr\Http\Message\ResponseInterface;
 8 | 
 9 | class HasStatusConstraint extends Constraint
10 | {
11 | 
12 |     /** @var Constraint */
13 |     private $status;
14 | 
15 |     public function __construct($status)
16 |     {
17 |         if (!$status instanceof Constraint) {
18 |             $status = Assert::equalTo($status);
19 |         }
20 | 
21 |         $this->status = $status;
22 |     }
23 | 
24 |     /**
25 |      * Returns a string representation of the object.
26 |      *
27 |      * @return string
28 |      */
29 |     public function toString(): string
30 |     {
31 |         return "response status {$this->status->toString()}";
32 |     }
33 | 
34 |     protected function matches($other): bool
35 |     {
36 |         if (!$other instanceof ResponseInterface) {
37 |             return false;
38 |         }
39 | 
40 |         return $this->status->evaluate($other->getStatusCode(), '', true);
41 |     }
42 | 
43 |     protected function additionalFailureDescription($other): string
44 |     {
45 |         if ($other instanceof ResponseInterface) {
46 |             return 'Actual status is ' . $other->getStatusCode() . ' and the body contains: ' . $other->getBody();
47 |         }
48 |         return '';
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Constraint/HasUriConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | use Psr\Http\Message\RequestInterface;
 7 | 
 8 | class HasUriConstraint extends Constraint
 9 | {
10 | 
11 |     /** @var string */
12 |     private $uri;
13 | 
14 |     public function __construct(string $uri)
15 |     {
16 |         $this->uri = $uri;
17 |     }
18 | 
19 |     /**
20 |      * Returns a string representation of the object.
21 |      *
22 |      * @return string
23 |      */
24 |     public function toString(): string
25 |     {
26 |         return "has request URI '{$this->uri}'";
27 |     }
28 | 
29 |     protected function matches($other): bool
30 |     {
31 |         if (!$other instanceof RequestInterface) {
32 |             return false;
33 |         }
34 | 
35 |         return $this->uri === (string) $other->getUri();
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Constraint/IsAbsoluteUriConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | namespace Helmich\Psr7Assert\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | 
 7 | class IsAbsoluteUriConstraint extends Constraint
 8 | {
 9 |     public function toString(): string
10 |     {
11 |         return "is valid URI";
12 |     }
13 | 
14 |     protected function matches($other): bool
15 |     {
16 |         $parts = parse_url($other);
17 |         if ($parts === false) {
18 |             return false;
19 |         }
20 | 
21 |         if (!isset($parts["host"]) || !$parts["host"]) {
22 |             return false;
23 |         }
24 | 
25 |         if (!isset($parts["scheme"]) || !$parts["scheme"]) {
26 |             return false;
27 |         }
28 | 
29 |         return $parts !== false;
30 |     }
31 | }


--------------------------------------------------------------------------------
/src/Constraint/UrlEncodedMatches.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Helmich\Psr7Assert\Constraint;
 3 | 
 4 | use PHPUnit\Framework\Constraint\Constraint;
 5 | use PHPUnit\Framework\Constraint\IsAnything;
 6 | use PHPUnit\Framework\Constraint\IsEqual;
 7 | 
 8 | class UrlEncodedMatches extends Constraint
 9 | {
10 |     private $nameMatcher;
11 |     private $valueMatcher;
12 | 
13 |     public function __construct($nameMatcher, $valueMatcher = null)
14 |     {
15 |         if (!($nameMatcher instanceof Constraint)) {
16 |             $nameMatcher = new IsEqual($nameMatcher);
17 |         }
18 | 
19 |         if ($valueMatcher === null) {
20 |             $valueMatcher = new IsAnything();
21 |         } elseif (!($valueMatcher instanceof Constraint)) {
22 |             $valueMatcher = new IsEqual($valueMatcher);
23 |         }
24 | 
25 |         $this->nameMatcher = $nameMatcher;
26 |         $this->valueMatcher = $valueMatcher;
27 |     }
28 | 
29 |     protected function matches($other): bool
30 |     {
31 |         parse_str($other, $parsedQuery);
32 | 
33 |         foreach ($parsedQuery as $key => $value) {
34 |             $nameMatches = $this->nameMatcher->evaluate($key, "", true);
35 |             $valueMatches = $this->valueMatcher->evaluate($value, "", true);
36 | 
37 |             if ($nameMatches && $valueMatches) {
38 |                 return true;
39 |             }
40 |         }
41 | 
42 |         return false;
43 |     }
44 | 
45 |     public function toString(): string
46 |     {
47 |         return 'contains a name matching ' . $this->nameMatcher->toString() . ' and value matching ' . $this->valueMatcher->toString();
48 |     }
49 | 
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Constraint/UrlEncodedMatchesMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Helmich\Psr7Assert\Constraint;
 3 | 
 4 | use PHPUnit\Framework\Constraint\Constraint;
 5 | 
 6 | class UrlEncodedMatchesMany extends Constraint
 7 | {
 8 |     /** @var UrlEncodedMatches[] */
 9 |     private $constraints = [];
10 | 
11 |     public function __construct(array $constraints)
12 |     {
13 |         foreach ($constraints as $key => $value) {
14 |             $this->constraints[] = new UrlEncodedMatches($key, $value);
15 |         }
16 |     }
17 | 
18 |     protected function matches($other): bool
19 |     {
20 |         foreach ($this->constraints as $constraint) {
21 |             if (!$constraint->evaluate($other, "", true)) {
22 |                 return false;
23 |             }
24 |         }
25 | 
26 |         return true;
27 |     }
28 | 
29 | 
30 |     public function toString(): string
31 |     {
32 |         return join(" and ", array_map(function(HasQueryParameterConstraint $c) {
33 |             return $c->toString();
34 |         }, $this->constraints));
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | use Helmich\JsonAssert\Constraint\JsonValueMatchesMany;
  5 | use Helmich\Psr7Assert\Constraint\BodyMatchesConstraint;
  6 | use Helmich\Psr7Assert\Constraint\HasHeaderConstraint;
  7 | use Helmich\Psr7Assert\Constraint\HasUriConstraint;
  8 | use Helmich\Psr7Assert\Constraint\IsAbsoluteUriConstraint;
  9 | use Helmich\Psr7Assert\Psr7AssertionsClass;
 10 | use PHPUnit\Framework\Assert;
 11 | use PHPUnit\Framework\Constraint\Constraint;
 12 | 
 13 | function hasUri(string $uri): HasUriConstraint
 14 | {
 15 |     return new HasUriConstraint($uri);
 16 | }
 17 | 
 18 | function hasHeader(string $name, $constraint = null): HasHeaderConstraint
 19 | {
 20 |     return new HasHeaderConstraint($name, $constraint);
 21 | }
 22 | 
 23 | function hasHeaders(array $constraints): Constraint
 24 | {
 25 |     return Psr7AssertionsClass::hasHeaders($constraints);
 26 | }
 27 | 
 28 | function hasStatus($status): Constraint
 29 | {
 30 |     return Psr7AssertionsClass::hasStatus($status);
 31 | }
 32 | 
 33 | function hasQueryParameter($name, $value = null): Constraint
 34 | {
 35 |     return Psr7AssertionsClass::hasQueryParameter($name, $value);
 36 | }
 37 | 
 38 | function hasQueryParameters(array $constraints): Constraint
 39 | {
 40 |     return Psr7AssertionsClass::hasQueryParameters($constraints);
 41 | }
 42 | 
 43 | function isSuccess(): Constraint
 44 | {
 45 |     return Psr7AssertionsClass::isSuccess();
 46 | }
 47 | 
 48 | function isRedirect(): Constraint
 49 | {
 50 |     return Psr7AssertionsClass::isRedirect();
 51 | }
 52 | 
 53 | function isClientError(): Constraint
 54 | {
 55 |     return Psr7AssertionsClass::isClientError();
 56 | }
 57 | 
 58 | function isServerError(): Constraint
 59 | {
 60 |     return Psr7AssertionsClass::isServerError();
 61 | }
 62 | 
 63 | function hasContentType(string $contentType): Constraint
 64 | {
 65 |     return new HasHeaderConstraint(
 66 |         'Content-Type',
 67 |         Assert::matchesRegularExpression(',^' . preg_quote($contentType, '/') . '(;.+)?$,')
 68 |     );
 69 | }
 70 | 
 71 | function hasMethod(string $method): Constraint
 72 | {
 73 |     return Psr7AssertionsClass::hasMethod($method);
 74 | }
 75 | 
 76 | function isGet(): Constraint
 77 | {
 78 |     return Psr7AssertionsClass::isGet();
 79 | }
 80 | 
 81 | function isPost(): Constraint
 82 | {
 83 |     return Psr7AssertionsClass::isPost();
 84 | }
 85 | 
 86 | function isPut(): Constraint
 87 | {
 88 |     return Psr7AssertionsClass::isPut();
 89 | }
 90 | 
 91 | function isDelete(): Constraint
 92 | {
 93 |     return Psr7AssertionsClass::isDelete();
 94 | }
 95 | 
 96 | function bodyMatches($constraint): Constraint
 97 | {
 98 |     return new BodyMatchesConstraint($constraint);
 99 | }
100 | 
101 | function bodyMatchesJson($constraints): Constraint
102 | {
103 |     return Assert::logicalAnd(
104 |         hasContentType('application/json'),
105 |         bodyMatches(
106 |             Assert::logicalAnd(
107 |                 Assert::isJson(),
108 |                 new JsonValueMatchesMany($constraints)
109 |             )
110 |         )
111 |     );
112 | }
113 | 
114 | function bodyMatchesForm(array $constraints): Constraint
115 | {
116 |     return Psr7AssertionsClass::bodyMatchesForm($constraints);
117 | }
118 | 
119 | function isAbsoluteUri(): Constraint
120 | {
121 |     return new IsAbsoluteUriConstraint();
122 | }
123 | 


--------------------------------------------------------------------------------
/src/Psr7Assertions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | namespace Helmich\Psr7Assert;
  4 | 
  5 | use Helmich\JsonAssert\Constraint\JsonValueMatchesMany;
  6 | use Helmich\Psr7Assert\Constraint\BodyMatchesConstraint;
  7 | use Helmich\Psr7Assert\Constraint\HasHeaderConstraint;
  8 | use Helmich\Psr7Assert\Constraint\HasMethodConstraint;
  9 | use Helmich\Psr7Assert\Constraint\HasQueryParameterConstraint;
 10 | use Helmich\Psr7Assert\Constraint\HasQueryParametersConstraint;
 11 | use Helmich\Psr7Assert\Constraint\HasStatusConstraint;
 12 | use Helmich\Psr7Assert\Constraint\HasUriConstraint;
 13 | use Helmich\Psr7Assert\Constraint\IsAbsoluteUriConstraint;
 14 | use Helmich\Psr7Assert\Constraint\UrlEncodedMatchesMany;
 15 | use PHPUnit\Framework\Assert;
 16 | use PHPUnit\Framework\Constraint\Constraint;
 17 | use PHPUnit\Framework\Constraint\IsEqual;
 18 | use Psr\Http\Message\MessageInterface;
 19 | use Psr\Http\Message\RequestInterface;
 20 | use Psr\Http\Message\ResponseInterface;
 21 | use Psr\Http\Message\UriInterface;
 22 | 
 23 | trait Psr7Assertions
 24 | {
 25 | 
 26 |     public static function assertRequestHasUri(RequestInterface $request, string $uri): void
 27 |     {
 28 |         Assert::assertThat($request, static::hasUri($uri));
 29 |     }
 30 | 
 31 |     public static function assertMessageHasHeader(MessageInterface $message, string $headerName, $headerValue = null): void
 32 |     {
 33 |         Assert::assertThat($message, static::hasHeader($headerName, $headerValue));
 34 |     }
 35 | 
 36 |     public static function assertMessageHasHeaders(MessageInterface $message, array $constraints): void
 37 |     {
 38 |         Assert::assertThat($message, static::hasHeaders($constraints));
 39 |     }
 40 | 
 41 |     public static function assertMessageBodyMatches(MessageInterface $message, $constraint): void
 42 |     {
 43 |         Assert::assertThat($message, static::bodyMatches($constraint));
 44 |     }
 45 | 
 46 |     public static function assertMessageBodyMatchesJson(MessageInterface $message, array $jsonConstraints): void
 47 |     {
 48 |         Assert::assertThat($message, static::bodyMatchesJson($jsonConstraints));
 49 |     }
 50 | 
 51 |     public static function assertMessageBodyMatchesForm(MessageInterface $message, array $formConstraints): void
 52 |     {
 53 |         Assert::assertThat($message, static::bodyMatchesForm($formConstraints));
 54 |     }
 55 | 
 56 |     public static function assertResponseHasStatus(ResponseInterface $response, int $status): void
 57 |     {
 58 |         Assert::assertThat($response, static::hasStatus($status));
 59 |     }
 60 | 
 61 |     public static function assertResponseIsSuccess(ResponseInterface $response): void
 62 |     {
 63 |         Assert::assertThat($response, static::isSuccess());
 64 |     }
 65 | 
 66 |     public static function assertResponseIsRedirect(ResponseInterface $response): void
 67 |     {
 68 |         Assert::assertThat($response, static::isRedirect());
 69 |     }
 70 | 
 71 |     public static function assertResponseIsClientError(ResponseInterface $response): void
 72 |     {
 73 |         Assert::assertThat($response, static::isClientError());
 74 |     }
 75 | 
 76 |     public static function assertResponseIsServerError(ResponseInterface $response): void
 77 |     {
 78 |         Assert::assertThat($response, static::isServerError());
 79 |     }
 80 | 
 81 |     public static function assertRequestHasMethod(RequestInterface $request, string $method): void
 82 |     {
 83 |         Assert::assertThat($request, static::hasMethod($method));
 84 |     }
 85 | 
 86 |     public static function assertRequestIsGet(RequestInterface $request): void
 87 |     {
 88 |         Assert::assertThat($request, static::isGet());
 89 |     }
 90 | 
 91 |     public static function assertRequestIsPost(RequestInterface $request): void
 92 |     {
 93 |         Assert::assertThat($request, static::isPost());
 94 |     }
 95 | 
 96 |     public static function assertRequestIsPut(RequestInterface $request): void
 97 |     {
 98 |         Assert::assertThat($request, static::isPut());
 99 |     }
100 | 
101 |     public static function assertRequestIsDelete(RequestInterface $request): void
102 |     {
103 |         Assert::assertThat($request, static::isDelete());
104 |     }
105 | 
106 |     /**
107 |      * @param string $uri
108 |      */
109 |     public static function assertStringIsAbsoluteUri(string $uri): void
110 |     {
111 |         Assert::assertThat($uri, static::isAbsoluteUri());
112 |     }
113 | 
114 |     /**
115 |      * @param string|UriInterface|RequestInterface $uriOrRequest
116 |      * @param string|Constraint                    $name
117 |      * @param string|Constraint|null               $value
118 |      */
119 |     public static function assertHasQueryParameter($uriOrRequest, $name, $value = null): void
120 |     {
121 |         Assert::assertThat($uriOrRequest, static::hasQueryParameter($name, $value));
122 |     }
123 | 
124 |     public static function assertHasQueryParameters($uriOrRequest, array $parameters): void
125 |     {
126 |         Assert::assertThat($uriOrRequest, static::hasQueryParameters($parameters));
127 |     }
128 | 
129 |     public static function hasUri(string $uri): Constraint
130 |     {
131 |         return new HasUriConstraint($uri);
132 |     }
133 | 
134 |     public static function hasMethod(string $method): Constraint
135 |     {
136 |         return new HasMethodConstraint($method);
137 |     }
138 | 
139 |     public static function hasStatus($status): Constraint
140 |     {
141 |         return new HasStatusConstraint($status);
142 |     }
143 | 
144 |     public static function isSuccess(): Constraint
145 |     {
146 |         return new HasStatusConstraint(Assert::logicalAnd(Assert::greaterThanOrEqual(200), Assert::lessThan(300)));
147 |     }
148 | 
149 |     public static function isRedirect(): Constraint
150 |     {
151 |         return new HasStatusConstraint(Assert::logicalAnd(Assert::greaterThanOrEqual(300), Assert::lessThan(400)));
152 |     }
153 | 
154 |     public static function isClientError(): Constraint
155 |     {
156 |         return new HasStatusConstraint(Assert::logicalAnd(Assert::greaterThanOrEqual(400), Assert::lessThan(500)));
157 |     }
158 | 
159 |     public static function isServerError(): Constraint
160 |     {
161 |         return new HasStatusConstraint(Assert::logicalAnd(Assert::greaterThanOrEqual(500), Assert::lessThan(600)));
162 |     }
163 | 
164 |     public static function isGet(): Constraint
165 |     {
166 |         return static::hasMethod('GET');
167 |     }
168 | 
169 |     public static function isPost(): Constraint
170 |     {
171 |         return static::hasMethod('POST');
172 |     }
173 | 
174 |     public static function isPut(): Constraint
175 |     {
176 |         return static::hasMethod('PUT');
177 |     }
178 | 
179 |     public static function isDelete(): Constraint
180 |     {
181 |         return static::hasMethod('DELETE');
182 |     }
183 | 
184 |     public static function hasHeader(string $name, $constraint = null): Constraint
185 |     {
186 |         return new HasHeaderConstraint($name, $constraint);
187 |     }
188 | 
189 |     public static function hasHeaders(array $constraints): Constraint
190 |     {
191 |         $headerConstraints = [];
192 |         foreach ($constraints as $name => $constraint) {
193 |             $headerConstraints[] = new HasHeaderConstraint($name, $constraint);
194 |         }
195 | 
196 |         return Assert::logicalAnd(...$headerConstraints);
197 |     }
198 | 
199 |     public static function hasHeaderEqualTo(string $name, string $expected): Constraint
200 |     {
201 |         return new HasHeaderConstraint($name, new IsEqual($expected));
202 |     }
203 | 
204 |     public static function bodyMatches(Constraint $constraint): Constraint
205 |     {
206 |         return new BodyMatchesConstraint($constraint);
207 |     }
208 | 
209 |     /**
210 |      * @param string|Constraint      $name
211 |      * @param string|Constraint|null $value
212 |      * @return Constraint
213 |      */
214 |     public static function hasQueryParameter($name, $value = null): Constraint
215 |     {
216 |         return new HasQueryParameterConstraint($name, $value);
217 |     }
218 | 
219 |     public static function hasQueryParameters(array $parameters): Constraint
220 |     {
221 |         return new HasQueryParametersConstraint($parameters);
222 |     }
223 | 
224 |     public static function bodyMatchesJson(array $constraints): Constraint
225 |     {
226 |         return Assert::logicalAnd(
227 |             self::hasHeader('content-type', Assert::matchesRegularExpression(',^application/json(;.+)?$,')),
228 |             self::bodyMatches(
229 |                 Assert::logicalAnd(
230 |                     Assert::isJson(),
231 |                     new JsonValueMatchesMany($constraints)
232 |                 )
233 |             )
234 |         );
235 |     }
236 | 
237 |     public static function bodyMatchesForm(array $constraints): Constraint
238 |     {
239 |         return Assert::logicalAnd(
240 |             self::hasHeader('content-type', Assert::matchesRegularExpression(',^application/x-www-form-urlencoded(;.+)?$,')),
241 |             self::bodyMatches(new UrlEncodedMatchesMany($constraints))
242 |         );
243 |     }
244 | 
245 |     /**
246 |      * @return Constraint
247 |      */
248 |     public static function isAbsoluteUri(): Constraint
249 |     {
250 |         return new IsAbsoluteUriConstraint();
251 |     }
252 | }
253 | 


--------------------------------------------------------------------------------
/src/Psr7AssertionsClass.php:
--------------------------------------------------------------------------------
1 | <?php
2 | declare(strict_types=1);
3 | namespace Helmich\Psr7Assert;
4 | 
5 | class Psr7AssertionsClass
6 | {
7 |     use Psr7Assertions;
8 | }
9 | 


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