Add streamFactory, require factory implementation, lazyload factories

Author: barryvdh

composer.json

@@ -44,6 +44,7 @@
         "psr/http-client": "^1",
         "psr/http-client-implementation": "^1",
         "psr/http-factory": "^1",
+        "psr/http-factory-implementation": "^1",
         "symfony/http-foundation": "^2.1||^3||^4",
         "zendframework/zend-diactoros": "^2.1"
     },

src/Common/Http/Client.php

@@ -8,28 +8,62 @@
 use Omnipay\Common\Http\Exception\RequestException;
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamFactoryInterface;
 use Psr\Http\Message\StreamInterface;
-use Psr\Http\Client\ClientInterface as Psr18ClientInterface;
-use Psr\Http\Message\RequestFactoryInterface as Psr17RequestFactoryInterface;
+use Psr\Http\Client\ClientInterface as HttpClientInterface;
+use Psr\Http\Message\RequestFactoryInterface as RequestFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
 
 final class Client implements ClientInterface
 {
     /**
      * The Http Client which implements `public function sendRequest(RequestInterface $request)`
      *
-     * @var Psr18ClientInterface
+     * @var HttpClientInterface
      */
     private $httpClient;
 
     /**
-     * @var Psr17RequestFactoryInterface
+     * @var RequestFactoryInterface
      */
     private $requestFactory;
 
+    /**
+     * @var StreamFactoryInterface
+     */
+    private $streamFactory;
+
     public function __construct($httpClient = null, $requestFactory = null)
     {
-        $this->httpClient = $httpClient ?: Psr18ClientDiscovery::find();
-        $this->requestFactory = $requestFactory ?: Psr17FactoryDiscovery::findRequestFactory();
+        $this->httpClient = $httpClient;
+        $this->requestFactory = $requestFactory;
+    }
+
+    private function getHttpClient() : HttpClientInterface
+    {
+        if (!$this->httpClient) {
+            $this->httpClient = Psr18ClientDiscovery::find();
+        }
+
+        return $this->httpClient;
+    }
+
+    private function getRequestFactory() : RequestFactoryInterface
+    {
+        if (!$this->requestFactory) {
+            $this->requestFactory = Psr17FactoryDiscovery::findRequestFactory();
+        }
+
+        return $this->requestFactory;
+    }
+
+    private function getStreamFactory() : StreamFactoryInterface
+    {
+        if (!$this->streamFactory) {
+            $this->streamFactory = Psr17FactoryDiscovery::findStreamFactory();
+        }
+
+        return $this->streamFactory;
     }
 
     /**
@@ -48,12 +82,13 @@ public function request(
         $body = null,
         $protocolVersion = '1.1'
     ) {
-        $request = $this->requestFactory
+        $request = $this->getRequestFactory()
             ->createRequest($method, $uri)
             ->withProtocolVersion($protocolVersion);
 
         if ($body) {
-            $request = $request->withBody($body);
+            $stream = $this->getStreamFactory()->createStream($body);
+            $request = $request->withBody($stream);
         }
 
         foreach ($headers as $name => $value) {
@@ -71,7 +106,7 @@ public function request(
     private function sendRequest(RequestInterface $request)
     {
         try {
-            return $this->httpClient->sendRequest($request);
+            return $this->getHttpClient()->sendRequest($request);
         } catch (\Http\Client\Exception\NetworkException $networkException) {
             throw new NetworkException($networkException->getMessage(), $request, $networkException);
         } catch (\Throwable $exception) {

tests/Omnipay/Common/Http/ClientTest.php

@@ -10,18 +10,11 @@
 use Omnipay\Tests\TestCase;
 use Psr\Http\Client\ClientInterface;
 use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
 
 class ClientTest extends TestCase
 {
-    public function testEmptyConstruct()
-    {
-        $client = new Client();
-
-        $this->assertAttributeInstanceOf(ClientInterface::class, 'httpClient', $client);
-        $this->assertAttributeInstanceOf(RequestFactoryInterface::class, 'requestFactory', $client);
-    }
-
-    public function testSend()
+    public function testSendGet()
     {
         $mockClient = m::mock(ClientInterface::class);
         $mockFactory = m::mock(RequestFactoryInterface::class);
@@ -41,7 +34,48 @@ public function testSend()
             ->once();
 
         $this->assertSame($response, $client->request('GET', '/path'));
+    }
 
+    public function testSendPostJson()
+    {
+        $mockClient = m::mock(ClientInterface::class);
+        $mockFactory = m::mock(RequestFactoryInterface::class);
+        $client = new Client($mockClient, $mockFactory);
+
+        $request = new Request('POST', '/path');
+        $response = new Response();
+
+        $mockFactory->shouldReceive('createRequest')->withArgs([
+            'POST',
+            '/path',
+        ])->andReturn($request);
+
+        $mockClient->shouldReceive('sendRequest')
+            ->with(m::on(function (RequestInterface $request) {
+
+                if ($request->getMethod() !== 'POST') {
+                    return false;
+                }
+
+                if ($request->getHeader('Content-Type') !== ['application/json']) {
+                    return false;
+                }
+
+                if ($request->getBody()->getContents() !== '{foo:bar}') {
+                    return false;
+                }
+
+                return true;
+            }))
+            ->andReturn($response)
+            ->once();
+
+        $this->assertSame($response, $client->request(
+            'POST',
+            '/path',
+            ['Content-Type' => 'application/json'],
+            '{foo:bar}'
+        ));
     }
 
     public function testSendException()