update deps

.github/workflows/tests.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        php-version: ['7.2', '7.3', '7.4', '8.0']
+        php-version: ['7.2', '7.3', '7.4', '8.0', '8.1', '8.2']
     steps:
       - name: Check out code into the workspace
         uses: actions/checkout@v2

README.md

@@ -1,4 +1,4 @@
-![Build Status](https://img.shields.io/github/workflow/status/Neur0toxine/pock/Tests?style=flat-square)
+![Build Status](https://img.shields.io/github/actions/workflow/status/Neur0toxine/pock/tests.yml?branch=master&style=flat-square)
 [![Coverage](https://img.shields.io/codecov/c/gh/Neur0toxine/pock/master.svg?logo=codecov&logoColor=white&style=flat-square)](https://codecov.io/gh/Neur0toxine/pock)
 [![Latest stable](https://img.shields.io/packagist/v/neur0toxine/pock.svg?style=flat-square)](https://packagist.org/packages/neur0toxine/pock)
 [![PHP from Packagist](https://img.shields.io/packagist/php-v/neur0toxine/pock.svg?logo=php&logoColor=white&style=flat-square)](https://packagist.org/packages/neur0toxine/pock)
@@ -97,7 +97,7 @@ if you want to override default behavior.
 ```php
 use Pock\Factory\JsonSerializerFactory;
 use Pock\Factory\XmlSerializerFactory;
-use Pock\Serializer\SymfonySerializerDecorator;
+use Pock\Serializer\SymfonySerializerAdapter;
 use Symfony\Component\Serializer\Encoder\JsonEncoder;
 use Symfony\Component\Serializer\Encoder\XmlEncoder;
 use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
@@ -105,13 +105,13 @@ use Symfony\Component\Serializer\Serializer;
 
 $encoders = [new XmlEncoder(), new JsonEncoder()];
 $normalizers = [new ObjectNormalizer()];
-$serializer = new SymfonySerializerDecorator(new Serializer($normalizers, $encoders));
+$serializer = new SymfonySerializerAdapter(new Serializer($normalizers, $encoders));
 
 JsonSerializerFactory::setSerializer($serializer);
 XmlSerializerFactory::setSerializer($serializer);
 ```
 
-In order to use unsupported serializer you should create a decorator which implements `Pock\Serializer\SerializerInterface`.
+In order to use unsupported serializer you should create an adapter which implements `Pock\Serializer\SerializerInterface`.
 
 # Roadmap to stable
 
@@ -122,6 +122,10 @@ In order to use unsupported serializer you should create a decorator which imple
 - [x] `replyWithCallback` - reply using specified callback.  
 - [x] `replyWithFactory` - reply using specified response factory (provide corresponding interface).  
 - [x] Compare XML bodies using `DOMDocument`, fallback to text comparison in case of problems.  
-- [ ] Regexp matchers for body, query and path.  
-- [ ] `symfony/http-client` support.  
+- [x] Regexp matchers for body, query, URI and path.  
+- [x] Form Data body matcher (partial & exact)
+- [x] Multipart form body matcher (just like callback matcher but parses the body as a multipart form data)  
+- [x] **BREAKING CHANGE:** Rename serializer decorators to serializer adapters.  
+- [x] Real network response for mocked requests.
+- [ ] `symfony/http-client` support.
 - [ ] Document everything (with examples if it’s feasible).

composer.json

@@ -34,20 +34,23 @@
         "php": ">=7.2.0",
         "ext-json": "*",
         "psr/http-client": "^1.0",
-        "psr/http-message": "^1.0",
+        "psr/http-message": "^1.0 || ^2.0",
         "php-http/httplug": "^1.0 || ^2.0",
-        "nyholm/psr7": "^1.4"
+        "nyholm/psr7": "^1.4",
+        "riverline/multipart-parser": "^2.0"
     },
     "require-dev": {
         "squizlabs/php_codesniffer": "^3.6",
-        "phpmd/phpmd": "^2.10",
+        "phpmd/phpmd": "^2.12",
         "dealerdirect/phpcodesniffer-composer-installer": "^0.7.1",
         "phpcompatibility/php-compatibility": "^9.3",
-        "phpstan/phpstan": "^0.12.87",
-        "jms/serializer": "^2 | ^3.12",
+        "phpstan/phpstan": "^1.5",
+        "jms/serializer": "^2 | ^3.17",
         "symfony/phpunit-bridge": "^5.2",
         "symfony/serializer": "^5.2",
-        "symfony/property-access": "^5.2"
+        "symfony/property-access": "^5.2",
+        "php-http/multipart-stream-builder": "^1.2",
+        "symfony/http-client": "^5.3"
     },
     "provide": {
         "psr/http-client-implementation": "1.0",
@@ -70,5 +73,11 @@
             "@lint",
             "@phpunit"
         ]
+    },
+    "config": {
+        "allow-plugins": {
+            "dealerdirect/phpcodesniffer-composer-installer": true,
+            "php-http/discovery": true
+        }
     }
 }

phpstan-baseline.neon

@@ -0,0 +1,111 @@
+parameters:
+	ignoreErrors:
+		-
+			message: "#^Method Pock\\\\Client\\:\\:doSendRequest\\(\\) should return Psr\\\\Http\\\\Message\\\\ResponseInterface but returns mixed\\.$#"
+			count: 1
+			path: src/Client.php
+
+		-
+			message: "#^Static property Pock\\\\Comparator\\\\ComparatorLocator\\:\\:\\$comparators \\(array\\<Pock\\\\Comparator\\\\ComparatorInterface\\>\\) does not accept array\\<object\\>\\.$#"
+			count: 1
+			path: src/Comparator/ComparatorLocator.php
+
+		-
+			message: "#^Unsafe access to private property Pock\\\\Comparator\\\\ComparatorLocator\\:\\:\\$comparators through static\\:\\:\\.$#"
+			count: 3
+			path: src/Comparator/ComparatorLocator.php
+
+		-
+			message: "#^Unsafe access to private property Pock\\\\Factory\\\\JsonSerializerFactory\\:\\:\\$mainSerializer through static\\:\\:\\.$#"
+			count: 2
+			path: src/Factory/JsonSerializerFactory.php
+
+		-
+			message: "#^Unsafe access to private property Pock\\\\Factory\\\\XmlSerializerFactory\\:\\:\\$mainSerializer through static\\:\\:\\.$#"
+			count: 2
+			path: src/Factory/XmlSerializerFactory.php
+
+		-
+			message: "#^Parameter \\#4 \\$flags of function preg_match expects TFlags of 0\\|256\\|512\\|768, int given\\.$#"
+			count: 1
+			path: src/Matchers/AbstractRegExpMatcher.php
+
+		-
+			message: "#^Unsafe call to private method Pock\\\\Matchers\\\\ExactHeadersMatcher\\:\\:headerValuesEqual\\(\\) through static\\:\\:\\.$#"
+			count: 2
+			path: src/Matchers/ExactHeadersMatcher.php
+
+		-
+			message: "#^Method Pock\\\\Matchers\\\\JsonBodyMatcher\\:\\:deserialize\\(\\) should return array\\|null but returns mixed\\.$#"
+			count: 1
+			path: src/Matchers/JsonBodyMatcher.php
+
+		-
+			message: "#^Parameter \\#3 \\$depth of function json_decode expects int\\<1, max\\>, int given\\.$#"
+			count: 1
+			path: src/Matchers/JsonBodyMatcher.php
+
+		-
+			message: "#^Method Pock\\\\Matchers\\\\QueryMatcher\\:\\:parseQuery\\(\\) should return array\\<string, mixed\\> but returns array\\<int\\|string, array\\|string\\>\\.$#"
+			count: 1
+			path: src/Matchers/QueryMatcher.php
+
+		-
+			message: "#^Method Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:sortXmlTags\\(\\) should return string but returns string\\|null\\.$#"
+			count: 1
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe access to private constant Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:TAG_SORT_XSLT through static\\:\\:\\.$#"
+			count: 1
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe access to private property Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:\\$sorter through static\\:\\:\\.$#"
+			count: 4
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe call to private method Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:createDOMDocument\\(\\) through static\\:\\:\\.$#"
+			count: 2
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe call to private method Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:getDOMString\\(\\) through static\\:\\:\\.$#"
+			count: 1
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe call to private method Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:getSorter\\(\\) through static\\:\\:\\.$#"
+			count: 1
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe call to private method Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:hasExtension\\(\\) through static\\:\\:\\.$#"
+			count: 4
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Unsafe call to private method Pock\\\\Matchers\\\\XmlBodyMatcher\\:\\:sortXmlTags\\(\\) through static\\:\\:\\.$#"
+			count: 2
+			path: src/Matchers/XmlBodyMatcher.php
+
+		-
+			message: "#^Parameter \\#1 \\$data of class Pock\\\\Matchers\\\\JsonBodyMatcher constructor expects array, mixed given\\.$#"
+			count: 2
+			path: src/PockBuilder.php
+
+		-
+			message: "#^Parameter \\#3 \\$depth of function json_decode expects int\\<1, max\\>, int given\\.$#"
+			count: 1
+			path: src/PockBuilder.php
+
+		-
+			message: "#^Parameter \\#3 \\$depth of function json_encode expects int\\<1, max\\>, int given\\.$#"
+			count: 1
+			path: src/PockBuilder.php
+
+		-
+			message: "#^Parameter \\#3 \\$depth of function json_encode expects int\\<1, max\\>, int given\\.$#"
+			count: 1
+			path: src/PockResponseBuilder.php

phpstan.neon

@@ -1,3 +1,6 @@
+includes:
+	- phpstan-baseline.neon # TODO: Configure new phpstan
+
 parameters:
     level: max
     paths:

src/Comparator/RecursiveArrayComparator.php

@@ -50,8 +50,12 @@ class RecursiveArrayComparator implements ComparatorInterface
         }
 
         foreach ($first as $key => $value) {
-            if (is_array($value) && !self::recursiveCompareArrays($value, $second[$key])) {
-                return false;
+            if (is_array($value)) {
+                if (!is_array($second[$key]) || !self::recursiveCompareArrays($value, $second[$key])) {
+                    return false;
+                }
+
+                continue;
             }
 
             if ($value !== $second[$key]) {

src/Comparator/RecursiveLtrArrayComparator.php

@@ -47,11 +47,12 @@ class RecursiveLtrArrayComparator extends RecursiveArrayComparator
         }
 
         foreach ($needle as $key => $value) {
-            if (
-                is_array($value) &&
-                (!is_array($haystack[$key]) || !self::recursiveCompareArrays($value, $haystack[$key]))
-            ) {
-                return false;
+            if (is_array($value)) {
+                if (!is_array($haystack[$key]) || !self::recursiveCompareArrays($value, $haystack[$key])) {
+                    return false;
+                }
+
+                continue;
             }
 
             if ($value !== $haystack[$key]) {

src/Creator/AbstractJmsSerializerCreator.php

@@ -10,7 +10,7 @@
 namespace Pock\Creator;
 
 use Throwable;
-use Pock\Serializer\JmsSerializerDecorator;
+use Pock\Serializer\JmsSerializerAdapter;
 use Pock\Serializer\SerializerInterface;
 
 /**
@@ -30,13 +30,13 @@ abstract class AbstractJmsSerializerCreator implements SerializerCreatorInterfac
     {
         if (
             class_exists(self::BUILDER_CLASS) &&
-            method_exists(self::BUILDER_CLASS, 'create')
+            method_exists(self::BUILDER_CLASS, 'create') // @phpstan-ignore-line
         ) {
             try {
-                $builder = call_user_func([self::BUILDER_CLASS, 'create']);
+                $builder = call_user_func([self::BUILDER_CLASS, 'create']); // @phpstan-ignore-line
 
-                if (null !== $builder && method_exists($builder, 'build')) {
-                    return new JmsSerializerDecorator($builder->build(), static::getFormat()); // @phpstan-ignore-line
+                if (null !== $builder && method_exists($builder, 'build')) { // @phpstan-ignore-line
+                    return new JmsSerializerAdapter($builder->build(), static::getFormat()); // @phpstan-ignore-line
                 }
             } catch (Throwable $throwable) {
                 return null;

src/Creator/AbstractSymfonySerializerCreator.php

@@ -10,7 +10,7 @@
 namespace Pock\Creator;
 
 use Pock\Serializer\SerializerInterface;
-use Pock\Serializer\SymfonySerializerDecorator;
+use Pock\Serializer\SymfonySerializerAdapter;
 
 /**
  * Class AbstractSymfonySerializerCreator
@@ -33,8 +33,8 @@ abstract class AbstractSymfonySerializerCreator implements SerializerCreatorInte
             $normalizer = self::OBJECT_NORMALIZER_CLASS;
             $encoder = static::getEncoderClass();
 
-            return new SymfonySerializerDecorator(
-                new $serializer([new $normalizer()], [new $encoder()]),
+            return new SymfonySerializerAdapter(
+                new $serializer([new $normalizer()], [new $encoder()]), // @phpstan-ignore-line
                 static::getFormat()
             );
         }

src/Matchers/AbstractRegExpMatcher.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category AbstractRegExpMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+/**
+ * Class AbstractRegExpMatcher
+ *
+ * @category AbstractRegExpMatcher
+ * @package  Pock\Matchers
+ */
+abstract class AbstractRegExpMatcher implements RequestMatcherInterface
+{
+    /** @var string */
+    protected $expression;
+
+    /** @var int */
+    protected $flags = 0;
+
+    /**
+     * @param string $expression
+     * @param int    $flags
+     */
+    public function __construct(string $expression, int $flags = 0)
+    {
+        $this->expression = $expression;
+        $this->flags = $flags;
+    }
+
+    protected function matchRegExp(string $content): bool
+    {
+        $matches = [];
+        return 1 === preg_match($this->expression, $content, $matches, $this->flags);
+    }
+}

src/Matchers/BodyMatcher.php

@@ -79,5 +79,7 @@ class BodyMatcher implements RequestMatcherInterface
         if (is_resource($contents)) {
             return static::readAllResource($contents);
         }
+
+        return '';
     }
 }

src/Matchers/ExactFormDataMatcher.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category ExactFormDataMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Pock\Comparator\ComparatorLocator;
+use Pock\Comparator\RecursiveArrayComparator;
+use Pock\Traits\SeekableStreamDataExtractor;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class ExactFormDataMatcher
+ *
+ * @category ExactFormDataMatcher
+ * @package  Pock\Matchers
+ */
+class ExactFormDataMatcher extends QueryMatcher
+{
+    use SeekableStreamDataExtractor;
+
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        $query = static::parseQuery(static::getStreamData($request->getBody()));
+
+        if (empty($query)) {
+            return false;
+        }
+
+        return ComparatorLocator::get(RecursiveArrayComparator::class)->compare($this->query, $query);
+    }
+}

src/Matchers/FormDataMatcher.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category FormDataMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Pock\Comparator\ComparatorLocator;
+use Pock\Comparator\RecursiveArrayComparator;
+use Pock\Traits\SeekableStreamDataExtractor;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class FormDataMatcher
+ *
+ * @category FormDataMatcher
+ * @package  Pock\Matchers
+ */
+class FormDataMatcher extends QueryMatcher
+{
+    use SeekableStreamDataExtractor;
+
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        $query = static::parseQuery(static::getStreamData($request->getBody()));
+
+        if (empty($query)) {
+            return false;
+        }
+
+        return ComparatorLocator::get(RecursiveArrayComparator::class)->compare($this->query, $query);
+    }
+}

src/Matchers/MultipartFormDataMatcher.php

@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * PHP version 7.1
+ *
+ * @category MultipartFormDataMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use InvalidArgumentException;
+use Pock\Traits\SeekableStreamDataExtractor;
+use Psr\Http\Message\RequestInterface;
+use Riverline\MultiPartParser\StreamedPart;
+use Riverline\MultiPartParser\Converters\PSR7;
+use RuntimeException;
+
+/**
+ * Class MultipartFormDataMatcher
+ *
+ * @category MultipartFormDataMatcher
+ * @package  Pock\Matchers
+ */
+class MultipartFormDataMatcher implements RequestMatcherInterface
+{
+    use SeekableStreamDataExtractor;
+
+    /** @var callable */
+    private $callback;
+
+    /**
+     * MultipartFormDataMatcher constructor.
+     *
+     * @param callable $callback Accepts Riverline\MultiPartParser\StreamedPart as an argument, returns true if matched.
+     */
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+
+    /**
+     * @inheritDoc
+     * @SuppressWarnings(PHPMD.StaticAccess)
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        try {
+            $part = PSR7::convert($request);
+            $request->getBody()->rewind();
+        } catch (InvalidArgumentException $exception) {
+            return false;
+        }
+
+        return call_user_func($this->callback, $part);
+    }
+}

src/Matchers/PortMatcher.php

@@ -0,0 +1,56 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category PortMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Pock\Enum\RequestScheme;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class PortMatcher
+ *
+ * @category PortMatcher
+ * @package  Pock\Matchers
+ */
+class PortMatcher implements RequestMatcherInterface
+{
+    /** @var int */
+    protected $port;
+
+    /**
+     * PortMatcher constructor.
+     *
+     * @param int $port
+     */
+    public function __construct(int $port)
+    {
+        $this->port = $port;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        $port = $request->getUri()->getPort();
+
+        if (null === $port) {
+            switch ($request->getUri()->getScheme()) {
+                case RequestScheme::HTTP:
+                    return 80 === $this->port;
+                case RequestScheme::HTTPS:
+                    return 443 === $this->port;
+                default:
+                    return false;
+            }
+        }
+
+        return $port === $this->port;
+    }
+}

src/Matchers/RegExpBodyMatcher.php

@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpBodyMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Pock\Traits\SeekableStreamDataExtractor;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class RegExpBodyMatcher
+ *
+ * @category RegExpBodyMatcher
+ * @package  Pock\Matchers
+ */
+class RegExpBodyMatcher extends AbstractRegExpMatcher
+{
+    use SeekableStreamDataExtractor;
+
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        return $this->matchRegExp(static::getStreamData($request->getBody()));
+    }
+}

src/Matchers/RegExpPathMatcher.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpPathMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class RegExpPathMatcher
+ *
+ * @category RegExpPathMatcher
+ * @package  Pock\Matchers
+ */
+class RegExpPathMatcher extends AbstractRegExpMatcher
+{
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        return $this->matchRegExp($request->getUri()->getPath());
+    }
+}

src/Matchers/RegExpQueryMatcher.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpQueryMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class RegExpQueryMatcher
+ *
+ * @category RegExpQueryMatcher
+ * @package  Pock\Matchers
+ */
+class RegExpQueryMatcher extends AbstractRegExpMatcher
+{
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        return $this->matchRegExp($request->getUri()->getQuery());
+    }
+}

src/Matchers/RegExpUriMatcher.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpUriMatcher
+ * @package  Pock\Matchers
+ */
+
+namespace Pock\Matchers;
+
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Class RegExpUriMatcher
+ *
+ * @category RegExpUriMatcher
+ * @package  Pock\Matchers
+ */
+class RegExpUriMatcher extends AbstractRegExpMatcher
+{
+    /**
+     * @inheritDoc
+     */
+    public function matches(RequestInterface $request): bool
+    {
+        return $this->matchRegExp((string) $request->getUri());
+    }
+}

src/PockBuilder.php

@@ -9,22 +9,20 @@
 
 namespace Pock;
 
-use Diff\ArrayComparer\StrictArrayComparer;
 use DOMDocument;
-use Pock\Enum\RequestMethod;
-use Pock\Enum\RequestScheme;
 use Pock\Exception\PockClientException;
 use Pock\Exception\PockNetworkException;
 use Pock\Exception\PockRequestException;
-use Pock\Exception\XmlException;
 use Pock\Factory\CallbackReplyFactory;
 use Pock\Factory\ReplyFactoryInterface;
 use Pock\Matchers\AnyRequestMatcher;
 use Pock\Matchers\BodyMatcher;
 use Pock\Matchers\CallbackRequestMatcher;
+use Pock\Matchers\ExactFormDataMatcher;
 use Pock\Matchers\ExactHeaderMatcher;
 use Pock\Matchers\ExactHeadersMatcher;
 use Pock\Matchers\ExactQueryMatcher;
+use Pock\Matchers\FormDataMatcher;
 use Pock\Matchers\HeaderLineMatcher;
 use Pock\Matchers\HeaderLineRegexpMatcher;
 use Pock\Matchers\HeaderMatcher;
@@ -32,9 +30,15 @@ use Pock\Matchers\HeadersMatcher;
 use Pock\Matchers\HostMatcher;
 use Pock\Matchers\JsonBodyMatcher;
 use Pock\Matchers\MethodMatcher;
+use Pock\Matchers\MultipartFormDataMatcher;
 use Pock\Matchers\MultipleMatcher;
 use Pock\Matchers\PathMatcher;
+use Pock\Matchers\PortMatcher;
 use Pock\Matchers\QueryMatcher;
+use Pock\Matchers\RegExpBodyMatcher;
+use Pock\Matchers\RegExpPathMatcher;
+use Pock\Matchers\RegExpQueryMatcher;
+use Pock\Matchers\RegExpUriMatcher;
 use Pock\Matchers\RequestMatcherInterface;
 use Pock\Matchers\SchemeMatcher;
 use Pock\Matchers\UriMatcher;
@@ -43,7 +47,11 @@ use Pock\Traits\JsonDecoderTrait;
 use Pock\Traits\JsonSerializerAwareTrait;
 use Pock\Traits\XmlSerializerAwareTrait;
 use Psr\Http\Client\ClientInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
 use RuntimeException;
+use Symfony\Component\HttpClient\Psr18Client;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Throwable;
 
 /**
@@ -55,6 +63,8 @@ use Throwable;
  * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
  * @SuppressWarnings(PHPMD.TooManyPublicMethods)
  * @SuppressWarnings(PHPMD.TooManyMethods)
+ * @SuppressWarnings(PHPMD.ExcessivePublicCount)
+ * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
  */
 class PockBuilder
 {
@@ -130,6 +140,18 @@ class PockBuilder
         return $this->addMatcher(new HostMatcher($host));
     }
 
+    /**
+     * Matches request by the port.
+     *
+     * @param int $port
+     *
+     * @return self
+     */
+    public function matchPort(int $port): self
+    {
+        return $this->addMatcher(new PortMatcher($port));
+    }
+
     /**
      * Matches request by origin.
      *
@@ -154,6 +176,10 @@ class PockBuilder
             $this->matchHost($parsed['host']);
         }
 
+        if (array_key_exists('port', $parsed) && is_int($parsed['port']) && $parsed['port'] > 0) {
+            $this->matchPort($parsed['port']);
+        }
+
         return $this;
     }
 
@@ -169,6 +195,19 @@ class PockBuilder
         return $this->addMatcher(new UriMatcher($uri));
     }
 
+    /**
+     * Matches request by the whole URI using regular expression.
+     *
+     * @param string $expression
+     * @param int    $flags
+     *
+     * @return self
+     */
+    public function matchUriRegExp(string $expression, int $flags = 0): self
+    {
+        return $this->addMatcher(new RegExpUriMatcher($expression, $flags));
+    }
+
     /**
      * Matches request by header value or several values. Header can have other values which are not specified here.
      * @see PockBuilder::matchExactHeader() if you want to match exact header values.
@@ -262,6 +301,20 @@ class PockBuilder
         return $this->addMatcher(new PathMatcher($path));
     }
 
+    /**
+     * Match request by its path using regular expression. This matcher doesn't care about prefix slash
+     * since it's pretty easy to do it using regular expression.
+     *
+     * @param string $expression
+     * @param int    $flags
+     *
+     * @return self
+     */
+    public function matchPathRegExp(string $expression, int $flags = 0): self
+    {
+        return $this->addMatcher(new RegExpPathMatcher($expression, $flags));
+    }
+
     /**
      * Match request by its query. Request can contain other query variables.
      * @see PockBuilder::matchExactQuery() if you want to match an entire query string.
@@ -275,6 +328,19 @@ class PockBuilder
         return $this->addMatcher(new QueryMatcher($query));
     }
 
+    /**
+     * Match request by its query using regular expression.
+     *
+     * @param string $expression
+     * @param int    $flags
+     *
+     * @return self
+     */
+    public function matchQueryRegExp(string $expression, int $flags = 0): self
+    {
+        return $this->addMatcher(new RegExpQueryMatcher($expression, $flags));
+    }
+
     /**
      * Match request by its query. Additional query parameters aren't allowed.
      *
@@ -287,6 +353,44 @@ class PockBuilder
         return $this->addMatcher(new ExactQueryMatcher($query));
     }
 
+    /**
+     * Match request with form-data.
+     *
+     * @param array<string, mixed> $formFields
+     *
+     * @return self
+     */
+    public function matchFormData(array $formFields): self
+    {
+        return $this->addMatcher(new FormDataMatcher($formFields));
+    }
+
+    /**
+     * Match request with form-data. Additional fields aren't allowed.
+     *
+     * @param array<string, mixed> $formFields
+     *
+     * @return self
+     */
+    public function matchExactFormData(array $formFields): self
+    {
+        return $this->addMatcher(new ExactFormDataMatcher($formFields));
+    }
+
+    /**
+     * Match request multipart form data. Will not match the request if body is not multipart.
+     * Uses third-party library to parse the data.
+     *
+     * @param callable $callback Accepts Riverline\MultiPartParser\StreamedPart as an argument, returns true if matched.
+     *
+     * @return self
+     * @see https://github.com/Riverline/multipart-parser#usage
+     */
+    public function matchMultipartFormData(callable $callback): self
+    {
+        return $this->addMatcher(new MultipartFormDataMatcher($callback));
+    }
+
     /**
      * Match entire request body.
      *
@@ -299,6 +403,19 @@ class PockBuilder
         return $this->addMatcher(new BodyMatcher($data));
     }
 
+    /**
+     * Match entire request body using provided regular expression.
+     *
+     * @param string $expression
+     * @param int    $flags
+     *
+     * @return self
+     */
+    public function matchBodyRegExp(string $expression, int $flags = 0): self
+    {
+        return $this->addMatcher(new RegExpBodyMatcher($expression, $flags));
+    }
+
     /**
      * Match JSON request body.
      *
@@ -317,6 +434,23 @@ class PockBuilder
         ));
     }
 
+    /**
+     * Match JSON request body against JSON string or array with data.
+     *
+     * @param array<int|string, mixed>|string $data
+     *
+     * @return self
+     * @throws \Pock\Exception\JsonException
+     */
+    public function matchSerializedJsonBody($data): self
+    {
+        if (is_string($data)) {
+            $data = self::jsonDecode($data, true);
+        }
+
+        return $this->addMatcher(new JsonBodyMatcher($data));
+    }
+
     /**
      * Match XML request body using raw XML data.
      *
@@ -324,11 +458,12 @@ class PockBuilder
      * It also doesn't serializer values with available XML serializer.
      * Use PockBuilder::matchSerializedXmlBody if you want to execute available serializer.
      *
-     * @see \Pock\PockBuilder::matchSerializedXmlBody()
-     *
      * @param DOMDocument|\Psr\Http\Message\StreamInterface|resource|string $data
      *
      * @return self
+     * @throws \Pock\Exception\XmlException
+     * @see \Pock\PockBuilder::matchSerializedXmlBody()
+     *
      */
     public function matchXmlBody($data): self
     {
@@ -355,7 +490,7 @@ class PockBuilder
      * Match request using provided callback. Callback should receive RequestInterface and return boolean.
      * If returned value is true then request is matched.
      *
-     * @param callable $callback
+     * @param callable $callback Callable that accepts PSR-7 RequestInterface as it's first argument.
      *
      * @return self
      */
@@ -532,6 +667,22 @@ class PockBuilder
         $this->replyWithFactory(new CallbackReplyFactory($callback));
     }
 
+    /**
+     * Reply to the request using provided client. Can be used to send real network request.
+     *
+     * @param \Psr\Http\Client\ClientInterface $client
+     * @SuppressWarnings(unused)
+     */
+    public function replyWithClient(ClientInterface $client): void
+    {
+        $this->replyWithCallback(function (
+            RequestInterface $request,
+            PockResponseBuilder $responseBuilder
+        ) use ($client): ResponseInterface {
+            return $client->sendRequest($request);
+        });
+    }
+
     /**
      * Resets the builder.
      *

src/Serializer/CallbackSerializerAdapter.php

@@ -3,7 +3,7 @@
 /**
  * PHP 7.1
  *
- * @category CallbackSerializerDecorator
+ * @category CallbackSerializerAdapter
  * @package  Pock\Serializer
  */
 
@@ -12,18 +12,18 @@ namespace Pock\Serializer;
 use RuntimeException;
 
 /**
- * Class CallbackSerializerDecorator
+ * Class CallbackSerializerAdapter
  *
- * @category CallbackSerializerDecorator
+ * @category CallbackSerializerAdapter
  * @package  Pock\Serializer
  */
-class CallbackSerializerDecorator implements SerializerInterface
+class CallbackSerializerAdapter implements SerializerInterface
 {
     /** @var callable */
     private $callback;
 
     /**
-     * CallbackSerializerDecorator constructor.
+     * CallbackSerializerAdapter constructor.
      *
      * @param callable $callback
      */

src/Serializer/JmsSerializerAdapter.php

@@ -3,19 +3,19 @@
 /**
  * PHP 7.2
  *
- * @category JmsSerializerDecorator
+ * @category JmsSerializerAdapter
  * @package  Pock\Serializer
  */
 
 namespace Pock\Serializer;
 
 /**
- * Class JmsSerializerDecorator
+ * Class JmsSerializerAdapter
  *
- * @category JmsSerializerDecorator
+ * @category JmsSerializerAdapter
  * @package  Pock\Serializer
  */
-class JmsSerializerDecorator implements SerializerInterface
+class JmsSerializerAdapter implements SerializerInterface
 {
     /** @var object */
     private $serializer;
@@ -24,7 +24,7 @@ class JmsSerializerDecorator implements SerializerInterface
     private $format;
 
     /**
-     * JmsSerializerDecorator constructor.
+     * JmsSerializerAdapter constructor.
      *
      * @param object $serializer
      */

src/Serializer/SymfonySerializerAdapter.php

@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * PHP 7.1
+ *
+ * @category SymfonySerializerAdapter
+ * @package  Pock\Serializer
+ */
+
+namespace Pock\Serializer;
+
+/**
+ * Class SymfonySerializerAdapter
+ *
+ * @category SymfonySerializerAdapter
+ * @package  Pock\Serializer
+ */
+class SymfonySerializerAdapter extends JmsSerializerAdapter
+{
+}

src/Serializer/SymfonySerializerDecorator.php

@@ -1,20 +0,0 @@
-<?php
-
-/**
- * PHP 7.1
- *
- * @category SymfonySerializerDecorator
- * @package  Pock\Serializer
- */
-
-namespace Pock\Serializer;
-
-/**
- * Class SymfonySerializerDecorator
- *
- * @category SymfonySerializerDecorator
- * @package  Pock\Serializer
- */
-class SymfonySerializerDecorator extends JmsSerializerDecorator
-{
-}

tests/src/Comparator/RecursiveArrayComparatorTest.php

@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RecursiveArrayComparatorTest
+ * @package  Pock\Tests\Comparator
+ */
+
+namespace Pock\Tests\Comparator;
+
+use PHPUnit\Framework\TestCase;
+use Pock\Comparator\ComparatorLocator;
+use Pock\Comparator\RecursiveArrayComparator;
+
+/**
+ * Class RecursiveArrayComparatorTest
+ *
+ * @category RecursiveArrayComparatorTest
+ * @package  Pock\Tests\Comparator
+ */
+class RecursiveArrayComparatorTest extends TestCase
+{
+    public function testMatches(): void
+    {
+        $needle = [
+            'filter' => [
+                'createdAtFrom' => '2020-01-01 00:00:00',
+                'createdAtTo' => '2021-08-01 00:00:00',
+            ],
+            'test' => ''
+        ];
+        $haystack = [
+            'filter' => [
+                'createdAtFrom' => '2020-01-01 00:00:00',
+                'createdAtTo' => '2021-08-01 00:00:00',
+            ],
+            'test' => ''
+        ];
+
+        self::assertTrue(ComparatorLocator::get(RecursiveArrayComparator::class)->compare($needle, $haystack));
+    }
+
+    public function testNotMatches(): void
+    {
+        $needle = [
+            'filter' => [
+                'createdAtFrom' => '2020-01-01 00:00:00',
+                'createdAtTo' => '2021-08-01 00:00:00',
+            ],
+            'test2' => [1]
+        ];
+        $haystack = [
+            'filter' => [
+                'createdAtFrom' => '2020-01-01 00:00:00',
+                'createdAtTo' => '2021-08-01 00:00:00',
+            ],
+            'test2' => 1
+        ];
+
+        self::assertFalse(ComparatorLocator::get(RecursiveArrayComparator::class)->compare($needle, $haystack));
+    }
+
+    public function testNotMatchesKeyPositions(): void
+    {
+        $needle = [
+            'source' => json_decode('{"medium":"tiktok","source":"Test Ad","campaign":"Test Campaign"}', true)
+        ];
+        $haystack = [
+            'source' => json_decode('{"source":"Test Ad","medium":"tiktok","campaign":"Test Campaign"}', true)
+        ];
+
+        self::assertTrue(ComparatorLocator::get(RecursiveArrayComparator::class)->compare($needle, $haystack));
+    }
+}

tests/src/Comparator/RecursiveArrayLtrComparatorTest.php

@@ -39,4 +39,37 @@ class RecursiveArrayLtrComparatorTest extends TestCase
 
         self::assertTrue(ComparatorLocator::get(RecursiveLtrArrayComparator::class)->compare($needle, $haystack));
     }
+
+    public function testNotMatches(): void
+    {
+        $needle = [
+            'filter' => [
+                'createdAtFrom' => '2020-01-01 00:00:00',
+                'createdAtTo' => '2021-08-01 00:00:00',
+            ],
+            'test2' => [1]
+        ];
+        $haystack = [
+            'filter' => [
+                'createdAtFrom' => '2020-01-01 00:00:00',
+                'createdAtTo' => '2021-08-01 00:00:00',
+            ],
+            'test2' => 1,
+            'test' => ''
+        ];
+
+        self::assertFalse(ComparatorLocator::get(RecursiveLtrArrayComparator::class)->compare($needle, $haystack));
+    }
+
+    public function testNotMatchesKeyPositions(): void
+    {
+        $needle = [
+            'source' => json_decode('{"medium":"tiktok","source":"Test Ad","campaign":"Test Campaign"}', true)
+        ];
+        $haystack = [
+            'source' => json_decode('{"source":"Test Ad","medium":"tiktok","campaign":"Test Campaign"}', true)
+        ];
+
+        self::assertTrue(ComparatorLocator::get(RecursiveLtrArrayComparator::class)->compare($needle, $haystack));
+    }
 }

tests/src/Decorator/CallbackSerializerDecoratorTest.php

@@ -1,29 +0,0 @@
-<?php
-
-/**
- * PHP 7.1
- *
- * @category CallbackSerializerDecoratorTest
- * @package  Pock\Tests\Decorator
- */
-
-namespace Pock\Tests\Decorator;
-
-use PHPUnit\Framework\TestCase;
-use Pock\Serializer\CallbackSerializerDecorator;
-
-/**
- * Class CallbackSerializerDecoratorTest
- *
- * @category CallbackSerializerDecoratorTest
- * @package  Pock\Tests\Decorator
- */
-class CallbackSerializerDecoratorTest extends TestCase
-{
-    public function testSerialize(): void
-    {
-        self::assertEquals('{}', (new CallbackSerializerDecorator(function ($data) {
-            return $data;
-        }))->serialize('{}'));
-    }
-}

tests/src/Factory/AbstractSerializerFactoryTest.php

@@ -12,7 +12,7 @@ namespace Pock\Tests\Factory;
 use PHPUnit\Framework\TestCase;
 use Pock\Factory\JsonSerializerFactory;
 use Pock\Factory\XmlSerializerFactory;
-use Pock\Serializer\CallbackSerializerDecorator;
+use Pock\Serializer\CallbackSerializerAdapter;
 use Pock\Serializer\SerializerInterface;
 use Pock\TestUtils\EmptyJsonSerializerDecorator;
 use Pock\TestUtils\EmptyXmlSerializerDecorator;

tests/src/Matchers/ExactFormDataMatcherTest.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category ExactFormDataMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Pock\Matchers\ExactFormDataMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class ExactFormDataMatcherTest
+ *
+ * @category ExactFormDataMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class ExactFormDataMatcherTest extends PockTestCase
+{
+    public function testInvalidData(): void
+    {
+        $matcher = new ExactFormDataMatcher(['field3' => 'value3']);
+        $request = self::getRequestWithBody('doesn\'t look like form-data at all');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testNoMatches(): void
+    {
+        $matcher = new ExactFormDataMatcher(['field3' => 'value3']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testNoMatchesByValue(): void
+    {
+        $matcher = new ExactFormDataMatcher(['field1' => 'value2']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testNoMatchesRedundantParam(): void
+    {
+        $matcher = new ExactFormDataMatcher(['field2' => 'value2']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new ExactFormDataMatcher(['field1' => 'value1', 'field2' => 'value2']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertTrue($matcher->matches($request));
+    }
+}

tests/src/Matchers/FormDataMatcherTest.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category FormDataMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Pock\Matchers\FormDataMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class FormDataMatcherTest
+ *
+ * @category FormDataMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class FormDataMatcherTest extends PockTestCase
+{
+    public function testInvalidData(): void
+    {
+        $matcher = new FormDataMatcher(['field3' => 'value3']);
+        $request = self::getRequestWithBody('doesn\'t look like form-data at all');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testNoMatches(): void
+    {
+        $matcher = new FormDataMatcher(['field3' => 'value3']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testNoMatchesByValue(): void
+    {
+        $matcher = new FormDataMatcher(['field1' => 'value2']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testNoMatchesExtraValues(): void
+    {
+        $matcher = new FormDataMatcher(['field2' => 'value2']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new FormDataMatcher(['field1' => 'value1', 'field2' => 'value2']);
+        $request = self::getRequestWithBody('field1=value1&field2=value2');
+
+        self::assertTrue($matcher->matches($request));
+    }
+}

tests/src/Matchers/MultipartFormDataMatcherTest.php

@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category MultipartFormDataMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Http\Message\MultipartStream\MultipartStreamBuilder;
+use Pock\Matchers\MultipartFormDataMatcher;
+use Pock\TestUtils\PockTestCase;
+use Psr\Http\Message\RequestInterface;
+use Riverline\MultiPartParser\StreamedPart;
+
+/**
+ * Class MultipartFormDataMatcherTest
+ *
+ * @category MultipartFormDataMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class MultipartFormDataMatcherTest extends PockTestCase
+{
+    public function testNoMatchesNotMultipart(): void
+    {
+        $matcher = new MultipartFormDataMatcher(function (StreamedPart $part) {
+            return $part->isMultiPart();
+        });
+
+        self::assertFalse($matcher->matches(self::getTestRequest()));
+        self::assertFalse($matcher->matches(self::getRequestWithBody('param=value&param2=value')));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new MultipartFormDataMatcher(function (StreamedPart $part) {
+            return $part->isMultiPart() &&
+                1 === count($part->getPartsByName('param1')) &&
+                1 === count($part->getPartsByName('param2')) &&
+                'value1' === $part->getPartsByName('param1')[0]->getBody() &&
+                'value2' === $part->getPartsByName('param2')[0]->getBody() &&
+                'text/plain' === $part->getPartsByName('param1')[0]->getHeader('Content-Type');
+        });
+        $builder = new MultipartStreamBuilder(self::getPsr17Factory());
+        $builder->addResource('param1', 'value1', ['headers' => ['Content-Type' => 'text/plain']])
+            ->addResource('param2', 'value2');
+
+        self::assertTrue($matcher->matches(self::getMultipartRequest($builder)));
+    }
+
+    private static function getMultipartRequest(MultipartStreamBuilder $builder): RequestInterface
+    {
+        return self::getPsr17Factory()->createRequest('POST', 'https://example.com')
+            ->withHeader('Content-Type', 'multipart/form-data; boundary="' . $builder->getBoundary() .  '"')
+            ->withBody($builder->build());
+    }
+}

tests/src/Matchers/PortMatcherTest.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category PortMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Nyholm\Psr7\Uri;
+use Pock\Enum\RequestScheme;
+use Pock\Matchers\PortMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class PortMatcherTest
+ *
+ * @category PortMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class PortMatcherTest extends PockTestCase
+{
+    public function testNotMatches(): void
+    {
+        self::assertFalse((new PortMatcher(80))->matches(static::getTestRequest()));
+    }
+
+    public function testMatches(): void
+    {
+        self::assertTrue((new PortMatcher(443))->matches(static::getTestRequest()));
+    }
+
+    public function testMatchesWithoutProto(): void
+    {
+        self::assertTrue((new PortMatcher(80))->matches(static::getTestRequest()->withUri(new class extends Uri {
+            public function getScheme(): string
+            {
+                return RequestScheme::HTTP;
+            }
+
+            public function getPort(): ?int
+            {
+                return null;
+            }
+        })));
+        self::assertTrue((new PortMatcher(443))->matches(static::getTestRequest()->withUri(new class extends Uri {
+            public function getScheme(): string
+            {
+                return RequestScheme::HTTPS;
+            }
+
+            public function getPort(): ?int
+            {
+                return null;
+            }
+        })));
+    }
+}

tests/src/Matchers/RegExpBodyMatcherTest.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpBodyMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Pock\Matchers\RegExpBodyMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class RegExpBodyMatcherTest
+ *
+ * @category RegExpBodyMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class RegExpBodyMatcherTest extends PockTestCase
+{
+    public function testNoMatches(): void
+    {
+        $matcher = new RegExpBodyMatcher('/\d+-\d+/m');
+        $request = static::getRequestWithBody('test unmatchable request');
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new RegExpBodyMatcher('/\d+-\d+/m', PREG_UNMATCHED_AS_NULL);
+        $request = static::getRequestWithBody('23-900');
+
+        self::assertTrue($matcher->matches($request));
+    }
+}

tests/src/Matchers/RegExpPathMatcherTest.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpPathMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Pock\Matchers\RegExpPathMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class RegExpPathMatcherTest
+ *
+ * @category RegExpPathMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class RegExpPathMatcherTest extends PockTestCase
+{
+    public function testNoMatches(): void
+    {
+        $matcher = new RegExpPathMatcher('/\/?\d+-\d+/m');
+        $request = static::getTestRequest()->withUri(static::getPsr17Factory()->createUri('https://test.com/test'));
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new RegExpPathMatcher('/\d+-\d+/m', PREG_UNMATCHED_AS_NULL);
+        $request = static::getTestRequest()->withUri(static::getPsr17Factory()->createUri('https://test.com/23-900'));
+
+        self::assertTrue($matcher->matches($request));
+    }
+}

tests/src/Matchers/RegExpQueryMatcherTest.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpQueryMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Pock\Matchers\RegExpQueryMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class RegExpQueryMatcherTest
+ *
+ * @category RegExpQueryMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+class RegExpQueryMatcherTest extends PockTestCase
+{
+    public function testNoMatches(): void
+    {
+        $matcher = new RegExpQueryMatcher('/\d+-\d+/m');
+        $request = static::getTestRequest()->withUri(
+            static::getPsr17Factory()->createUri('https://test.com')
+                ->withQuery('param=value')
+        );
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new RegExpQueryMatcher('/\d+-\d+/m', PREG_UNMATCHED_AS_NULL);
+        $request = static::getTestRequest()->withUri(
+            static::getPsr17Factory()->createUri('https://test.com')
+                ->withQuery('param=23-900')
+        );
+
+        self::assertTrue($matcher->matches($request));
+    }
+}

tests/src/Matchers/RegExpUriMatcherTest.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * PHP version 7.3
+ *
+ * @category RegExpUriMatcherTest
+ * @package  Pock\Tests\Matchers
+ */
+
+namespace Pock\Tests\Matchers;
+
+use Pock\Matchers\RegExpUriMatcher;
+use Pock\TestUtils\PockTestCase;
+
+/**
+ * Class RegExpUriMatcherTest
+ *
+ * @category RegExpUriMatcher
+ * @package  Pock\Tests\Matchers
+ */
+class RegExpUriMatcherTest extends PockTestCase
+{
+    public function testNoMatches(): void
+    {
+        $matcher = new RegExpUriMatcher('/https\:\/\/\w+\.com\/\d+-\d+\?param=\d+-\d+/m');
+        $request = static::getTestRequest();
+
+        self::assertFalse($matcher->matches($request));
+    }
+
+    public function testMatches(): void
+    {
+        $matcher = new RegExpUriMatcher('/https\:\/\/\w+\.com\/\d+-\d+\?param=\d+-\d+/m', PREG_UNMATCHED_AS_NULL);
+        $request = static::getTestRequest()->withUri(
+            static::getPsr17Factory()->createUri('https://example.com/23-900')
+                ->withQuery('param=23-900')
+        );
+
+        self::assertTrue($matcher->matches($request));
+    }
+}

tests/src/PockBuilderTest.php

@@ -10,6 +10,7 @@
 namespace Pock\Tests;
 
 use DOMDocument;
+use Http\Message\MultipartStream\MultipartStreamBuilder;
 use Pock\Enum\RequestMethod;
 use Pock\Enum\RequestScheme;
 use Pock\Exception\UnsupportedRequestException;
@@ -23,6 +24,7 @@ use Psr\Http\Client\ClientExceptionInterface;
 use Psr\Http\Client\NetworkExceptionInterface;
 use Psr\Http\Client\RequestExceptionInterface;
 use Psr\Http\Message\RequestInterface;
+use Riverline\MultiPartParser\StreamedPart;
 use RuntimeException;
 
 /**
@@ -172,7 +174,7 @@ class PockBuilderTest extends PockTestCase
 
     public function testMatchOrigin(): void
     {
-        $origin = RequestScheme::HTTPS . '://' . self::TEST_HOST;
+        $origin = RequestScheme::HTTPS . '://' . self::TEST_HOST . ':443';
         $builder = new PockBuilder();
 
         $builder->matchMethod(RequestMethod::GET)
@@ -579,6 +581,127 @@ EOF;
         self::assertEquals($xml, $response->getBody()->getContents());
     }
 
+    public function testMultipartFormDataMock(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::POST)
+            ->matchScheme(RequestScheme::HTTPS)
+            ->matchHost(self::TEST_HOST)
+            ->matchMultipartFormData(function (StreamedPart $part) {
+                return $part->isMultiPart() &&
+                    1 === count($part->getPartsByName('param1')) &&
+                    1 === count($part->getPartsByName('param2')) &&
+                    'value1' === $part->getPartsByName('param1')[0]->getBody() &&
+                    'value2' === $part->getPartsByName('param2')[0]->getBody() &&
+                    'text/plain' === $part->getPartsByName('param1')[0]->getHeader('Content-Type');
+            })->reply(200)
+            ->withHeader('Content-Type', 'text/plain')
+            ->withBody('ok');
+
+        $streamBuilder = (new MultipartStreamBuilder(self::getPsr17Factory()))
+            ->addResource('param1', 'value1', ['headers' => ['Content-Type' => 'text/plain']])
+            ->addResource('param2', 'value2');
+        $response = $builder->getClient()->sendRequest(
+            self::getPsr17Factory()
+                ->createRequest(RequestMethod::POST, self::TEST_URI)
+                ->withHeader('Content-Type', 'multipart/form-data; boundary="' . $streamBuilder->getBoundary() .  '"')
+                ->withBody($streamBuilder->build())
+        );
+
+        self::assertEquals(200, $response->getStatusCode());
+        self::assertEquals(['Content-Type' => ['text/plain']], $response->getHeaders());
+        self::assertEquals('ok', $response->getBody()->getContents());
+    }
+
+    public function testMatchBodyRegExp(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchUri(self::TEST_URI)
+            ->matchBodyRegExp('/\d+-\d+/')
+            ->reply(200);
+
+        $response = $builder->getClient()->sendRequest(static::getRequestWithBody('test matchable 23-900'));
+
+        self::assertEquals(200, $response->getStatusCode());
+    }
+
+    public function testMatchPathRegExp(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchOrigin(self::TEST_HOST)
+            ->matchPathRegExp('/^\/?test$/')
+            ->reply(200);
+
+        $response = $builder->getClient()->sendRequest(
+            static::getTestRequest()->withUri(static::getPsr17Factory()->createUri('https://test.com/test'))
+        );
+
+        self::assertEquals(200, $response->getStatusCode());
+    }
+
+    public function testMatchQueryRegExp(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchOrigin(self::TEST_HOST)
+            ->matchQueryRegExp('/\d+-\d+/')
+            ->reply(200);
+
+        $response = $builder->getClient()->sendRequest(
+            static::getTestRequest()->withUri(
+                static::getPsr17Factory()->createUri(self::TEST_URI)
+                    ->withQuery('param=23-900')
+            )
+        );
+
+        self::assertEquals(200, $response->getStatusCode());
+    }
+
+    public function testMatchUriRegExp(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchUriRegExp('/https\:\/\/\w+\.com\/\d+-\d+\?param=\d+-\d+/')
+            ->reply(200);
+
+        $response = $builder->getClient()->sendRequest(
+            static::getTestRequest()->withUri(
+                static::getPsr17Factory()->createUri('https://example.com/23-900')
+                    ->withQuery('param=23-900')
+            )
+        );
+
+        self::assertEquals(200, $response->getStatusCode());
+    }
+
+    public function testMatchFormData(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchUri(self::TEST_URI)
+            ->matchFormData(['field1' => 'value1', 'field2' => 'value2'])
+            ->reply(200);
+
+        $response = $builder->getClient()->sendRequest(self::getRequestWithBody('field1=value1&field2=value2'));
+
+        self::assertEquals(200, $response->getStatusCode());
+    }
+
+    public function testMatchExactFormData(): void
+    {
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchUri(self::TEST_URI)
+            ->matchExactFormData(['field2' => 'value2'])
+            ->reply(200);
+
+        $response = $builder->getClient()->sendRequest(self::getRequestWithBody('field2=value2'));
+
+        self::assertEquals(200, $response->getStatusCode());
+    }
+
     public function testFirstExampleApiMock(): void
     {
         $data = [
@@ -711,6 +834,19 @@ EOF;
             ->withHeader('Content-Type', 'text/plain')
             ->withBody('Second token (post json)');
 
+        $builder->matchMethod(RequestMethod::POST)
+            ->matchScheme(RequestScheme::HTTPS)
+            ->matchHost(self::TEST_HOST)
+            ->matchPath('/ping')
+            ->matchHeaders([
+                'Authorization' => 'Token token_3',
+                'Content-Type' => 'application/json'
+            ])
+            ->matchSerializedJsonBody('{"field": "value3"}')
+            ->reply(200)
+            ->withHeader('Content-Type', 'text/plain')
+            ->withBody('Third token (post json with match against serialized data)');
+
         $builder->matchMethod(RequestMethod::POST)
             ->matchScheme(RequestScheme::HTTPS)
             ->matchHost(self::TEST_HOST)
@@ -779,6 +915,19 @@ EOF;
         );
         self::assertEquals('Second token (post json)', $response->getBody()->getContents());
 
+        $response = $client->sendRequest(
+            self::getPsr17Factory()
+                ->createRequest(RequestMethod::POST, self::TEST_URI)
+                ->withHeader('Authorization', 'Token token_3')
+                ->withHeader('Content-Type', 'application/json')
+                ->withUri(self::getPsr17Factory()->createUri(self::TEST_URI . 'ping'))
+                ->withBody(self::getPsr17Factory()->createStream('{"field": "value3"}'))
+        );
+        self::assertEquals(
+            'Third token (post json with match against serialized data)',
+            $response->getBody()->getContents()
+        );
+
         $response = $client->sendRequest(
             self::getPsr17Factory()
                 ->createRequest(RequestMethod::POST, self::TEST_URI)
@@ -886,10 +1035,29 @@ EOF;
                 throw new RuntimeException('Exception from the callback');
             });
 
-         $builder->getClient()->sendRequest(self::getPsr17Factory()->createRequest(
-             RequestMethod::GET,
-             self::TEST_URI
-         ));
+        $builder->getClient()->sendRequest(self::getPsr17Factory()->createRequest(
+            RequestMethod::GET,
+            self::TEST_URI
+        ));
+    }
+
+    public function testReplyWithClient(): void
+    {
+        $inlined = new PockBuilder();
+        $inlined->reply(429);
+
+        $builder = new PockBuilder();
+        $builder->matchMethod(RequestMethod::GET)
+            ->matchUri(self::TEST_URI)
+            ->always()
+            ->replyWithClient($inlined->getClient());
+
+        $response = $builder->getClient()->sendRequest(self::getPsr17Factory()->createRequest(
+            RequestMethod::GET,
+            self::TEST_URI
+        ));
+
+        self::assertEquals(429, $response->getStatusCode());
     }
 
     public function matchXmlNoXslProvider(): array

tests/src/Serializer/CallbackSerializerAdapterTest.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * PHP 7.1
+ *
+ * @category CallbackSerializerAdapterTest
+ * @package  Pock\Tests\Serializer
+ */
+
+namespace Pock\Tests\Serializer;
+
+use PHPUnit\Framework\TestCase;
+use Pock\Serializer\CallbackSerializerAdapter;
+
+/**
+ * Class CallbackSerializerAdapterTest
+ *
+ * @category CallbackSerializerAdapterTest
+ * @package  Pock\Tests\Serializer
+ */
+class CallbackSerializerAdapterTest extends TestCase
+{
+    public function testSerialize(): void
+    {
+        self::assertEquals('{}', (new CallbackSerializerAdapter(function ($data) {
+            return $data;
+        }))->serialize('{}'));
+    }
+}