Merge pull request #11 from martin-helmich/feature/uri-assertions

New assertions for URIs and form-encoded request/response bodies

Author: martin-helmich

README.md

@@ -143,7 +143,9 @@ assertThat($request, hasHeaders([
 
 Asserts that the message body matches the constraint `$constraint`. If
 `$constraint` is a primitive value, the assertion will pass when the message
-body is equal to the constraint. If `$constraint` is an instance of the `PHPUnit\Framework\Constraint\Constraint` class, the constraint will be evaluated as-is.
+body is equal to the constraint. If `$constraint` is an instance of the
+`PHPUnit\Framework\Constraint\Constraint` class, the constraint will be evaluated
+as-is.
 
 ##### `assertMessageBodyMatchesJson($message, $jsonConstraints)` / `bodyMatchesJson($jsonConstraints)`
 
@@ -153,7 +155,14 @@ This actually asserts several facts:
    `application/json`
 2. The message body must be a valid JSON string (that means decodeable by
    `json_decode`)
-3. The encoded JSON object must match all constraints specified in the `$jsonConstraints` array. For this, the [helmich/phpunit-json-assert][json-assert] package will be used.
+3. The encoded JSON object must match all constraints specified in the
+   `$jsonConstraints` array. For this, the [helmich/phpunit-json-assert][json-assert]
+   package will be used.
+
+##### `assertMessageBodyMatchesForm($message, $formConstraints)` / `bodyMatchesForm($formConstraints)`
+
+This asserts that the message body contains `application/x-www-form-urlencoded`-encoded
+content, with individual variables matching the `$formConstraints` array.
 
 ##### `assertRequestHasMethod($request, $method)` / `hasMethod($method)`
 
@@ -181,6 +190,22 @@ For the most common checks, some shorthand assertions are available:
 - `assertResponseIsClientError($response)` / `isClientError()` -- Status codes 400 to 499
 - `assertResponseIsServerError($response)` / `isServerError()` -- Status codes 500 to 599
 
+#### `assertStringIsAbsoluteUri($uri)` / `isAbsoluteUri()`
+
+Assert that the string `$uri` contains a valid absolute URL (scheme and hostname are required).
+
+#### `assertHasQueryParameter($uriOrRequest, $name[, $value])` / `hasQueryParameter($name[, $value])`
+
+Asserts that an URI contains a query parameter matching the given constraints.
+`$name` and `$value` may both be string values as well as instances of the
+`PHPUnit\Framework\Constraint\Constraint` interface.
+
+The `$uriOrRequest` value may be
+
+- a string, which will be interpreted as URI
+- an instance of the `Psr\Http\Message\UriInterface` interface
+- an instance of the `Psr\Http\Message\RequestInterface` interface 
+
 [composer-autoload]: https://getcomposer.org/doc/04-schema.md#autoload-dev
 [json-assert]: https://packagist.org/packages/helmich/phpunit-json-assert
 [psr7]: https://packagist.org/packages/psr/http-message

src/Constraint/HasQueryParameterConstraint.php

@@ -0,0 +1,64 @@
+<?php
+declare(strict_types = 1);
+namespace Helmich\Psr7Assert\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\UriInterface;
+
+class HasQueryParameterConstraint extends Constraint
+{
+    /** @var UrlEncodedMatches */
+    private $inner;
+
+    public function __construct($nameMatcher, $valueMatcher = null)
+    {
+        parent::__construct();
+
+        $this->inner = new UrlEncodedMatches($nameMatcher, $valueMatcher);
+    }
+
+    protected function matches($other): bool
+    {
+        if (is_string($other)) {
+            return $this->matchesString($other);
+        }
+
+        if ($other instanceof UriInterface) {
+            return $this->matchesPsr7Uri($other);
+        }
+
+        if ($other instanceof RequestInterface) {
+            return $this->matchesPsr7Uri($other->getUri());
+        }
+
+        return false;
+    }
+
+    private function matchesPsr7Uri(UriInterface $other): bool
+    {
+        $queryString = $other->getQuery();
+        return $this->matchesQueryString($queryString);
+    }
+
+    private function matchesString(string $other): bool
+    {
+        $parsedUrl = parse_url($other);
+        if (!isset($parsedUrl["query"])) {
+            return false;
+        }
+
+        return $this->matchesQueryString($parsedUrl["query"]);
+    }
+
+    private function matchesQueryString(string $query): bool
+    {
+        return $this->inner->evaluate($query, "", true);
+    }
+
+
+    public function toString(): string
+    {
+        return 'query string ' . $this->inner->toString();
+    }
+}

src/Constraint/HasQueryParametersConstraint.php

@@ -0,0 +1,35 @@
+<?php
+namespace Helmich\Psr7Assert\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+
+class HasQueryParametersConstraint extends Constraint
+{
+    /** @var HasQueryParameterConstraint[] */
+    private $constraints = [];
+
+    public function __construct(array $constraints)
+    {
+        foreach ($constraints as $key => $value) {
+            $this->constraints[] = new HasQueryParameterConstraint($key, $value);
+        }
+    }
+
+    public function matches($other): bool
+    {
+        foreach ($this->constraints as $constraint) {
+            if (!$constraint->evaluate($other, "", true)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function toString(): string
+    {
+        return join(" and ", array_map(function(HasQueryParameterConstraint $c) {
+            return $c->toString();
+        }, $this->constraints));
+    }
+}

src/Constraint/IsAbsoluteUriConstraint.php

@@ -0,0 +1,31 @@
+<?php
+declare(strict_types = 1);
+namespace Helmich\Psr7Assert\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+
+class IsAbsoluteUriConstraint extends Constraint
+{
+    public function toString(): string
+    {
+        return "is valid URI";
+    }
+
+    protected function matches($other): bool
+    {
+        $parts = parse_url($other);
+        if ($parts === false) {
+            return false;
+        }
+
+        if (!isset($parts["host"]) || !$parts["host"]) {
+            return false;
+        }
+
+        if (!isset($parts["scheme"]) || !$parts["scheme"]) {
+            return false;
+        }
+
+        return $parts !== false;
+    }
+}

src/Constraint/UrlEncodedMatches.php

@@ -0,0 +1,56 @@
+<?php
+namespace Helmich\Psr7Assert\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+use PHPUnit\Framework\Constraint\IsAnything;
+use PHPUnit\Framework\Constraint\IsEqual;
+
+class UrlEncodedMatches extends Constraint
+{
+    private $nameMatcher;
+    private $valueMatcher;
+
+    public function __construct($nameMatcher, $valueMatcher = null)
+    {
+        parent::__construct();
+
+        if (!($nameMatcher instanceof Constraint)) {
+            $nameMatcher = new IsEqual($nameMatcher);
+        }
+
+        if ($valueMatcher === null) {
+            $valueMatcher = new IsAnything();
+        } else if (!($valueMatcher instanceof Constraint)) {
+            $valueMatcher = new IsEqual($valueMatcher);
+        }
+
+        $this->nameMatcher = $nameMatcher;
+        $this->valueMatcher = $valueMatcher;
+    }
+
+    protected function matches($other): bool
+    {
+        parse_str($other, $parsedQuery);
+
+        foreach ($parsedQuery as $key => $value) {
+            if (!$this->nameMatcher->evaluate($key, "", true)) {
+                continue;
+            }
+
+            if (!$this->valueMatcher->evaluate($value, "", true)) {
+                continue;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public function toString(): string
+    {
+        return 'contains a name matching ' . $this->nameMatcher->toString() . ' and value matching ' . $this->valueMatcher->toString();
+    }
+
+
+}

src/Constraint/UrlEncodedMatchesMany.php

@@ -0,0 +1,38 @@
+<?php
+namespace Helmich\Psr7Assert\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+
+class UrlEncodedMatchesMany extends Constraint
+{
+    /** @var UrlEncodedMatches[] */
+    private $constraints = [];
+
+    public function __construct(array $constraints)
+    {
+        parent::__construct();
+
+        foreach ($constraints as $key => $value) {
+            $this->constraints[] = new UrlEncodedMatches($key, $value);
+        }
+    }
+
+    protected function matches($other): bool
+    {
+        foreach ($this->constraints as $constraint) {
+            if (!$constraint->evaluate($other, "", true)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+
+    public function toString(): string
+    {
+        return join(" and ", array_map(function(HasQueryParameterConstraint $c) {
+            return $c->toString();
+        }, $this->constraints));
+    }
+}

src/Functions.php

@@ -5,6 +5,7 @@
 use Helmich\Psr7Assert\Constraint\BodyMatchesConstraint;
 use Helmich\Psr7Assert\Constraint\HasHeaderConstraint;
 use Helmich\Psr7Assert\Constraint\HasUriConstraint;
+use Helmich\Psr7Assert\Constraint\IsAbsoluteUriConstraint;
 use Helmich\Psr7Assert\Psr7Assertions;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Constraint\Constraint;
@@ -29,6 +30,16 @@ function hasStatus($status): Constraint
     return Psr7Assertions::hasStatus($status);
 }
 
+function hasQueryParameter($name, $value = null): Constraint
+{
+    return Psr7Assertions::hasQueryParameter($name, $value);
+}
+
+function hasQueryParameters(array $constraints): Constraint
+{
+    return Psr7Assertions::hasQueryParameters($constraints);
+}
+
 function isSuccess(): Constraint
 {
     return Psr7Assertions::isSuccess();
@@ -94,3 +105,13 @@ function bodyMatchesJson($constraints): Constraint
         )
     );
 }
+
+function bodyMatchesForm(array $constraints): Constraint
+{
+    return Psr7Assertions::bodyMatchesForm($constraints);
+}
+
+function isAbsoluteUri(): Constraint
+{
+    return new IsAbsoluteUriConstraint();
+}