wip

src/Contracts/Hydratable.php

@@ -4,7 +4,7 @@
 
 interface Hydratable
 {
-    public static function shouldAutoHydrate(bool $shouldAutoHydrate = true): void;
+    public static function setAutoHydrate(bool $shouldAutoHydrate = true): void;
 
     /**
      * @return mixed

src/EndpointCollection/EndpointCollection.php

@@ -16,7 +16,7 @@ public function __construct(Connector $connector)
         /**
          * Default hydration decision to true to maintain legacy compatibility.
          */
-        $connector::shouldAutoHydrate();
+        $connector::setAutoHydrate();
     }
 
     /**

src/Helpers/Arr.php

@@ -26,6 +26,45 @@ public static function get(array $array, string $keys, $default = null)
         return $value;
     }
 
+    /**
+     * Get and remove an item from an array using "dot" notation.
+     *
+     * @param  array  $array
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function pull(array &$array, string $key, $default = null)
+    {
+        $value = static::get($array, $key, $default);
+
+        static::forget($array, $key);
+
+        return $value;
+    }
+
+    /**
+     * Remove an item from an array using "dot" notation.
+     *
+     * @param  array  $array
+     * @param  string  $key
+     */
+    public static function forget(array &$array, string $key): void
+    {
+        $keys = explode('.', $key);
+        $last = array_pop($keys);
+        $array = &$array;
+
+        foreach ($keys as $segment) {
+            if (!is_array($array) || !array_key_exists($segment, $array)) {
+                break;
+            }
+            $array = &$array[$segment];
+        }
+
+        unset($array[$last]);
+    }
+
     /**
      * Checks if the given key/s exist in the provided array.
      *

src/Resources/CursorCollection.php

@@ -4,15 +4,43 @@
 
 use Generator;
 use Mollie\Api\Http\Requests\DynamicGetRequest;
+use Mollie\Api\Http\Requests\ResourceHydratableRequest;
 
 abstract class CursorCollection extends ResourceCollection
 {
+    private bool $autoHydrate = false;
+
+    public function setAutoHydrate(bool $shouldAutoHydrate = true): void
+    {
+        $this->autoHydrate = $shouldAutoHydrate;
+    }
+
+    public function shouldAutoHydrate(): bool
+    {
+        if ($this->response === null) {
+            return $this->autoHydrate;
+        }
+
+        $request = $this->response->getRequest();
+
+        /**
+         * Don't try to hydrate when the request
+         * already has auto-hydration enabled. The
+         * Hydrate Middleware will take care of that.
+         */
+        if ($request instanceof ResourceHydratableRequest && $request->shouldAutoHydrate()) {
+            return false;
+        }
+
+        return $this->autoHydrate;
+    }
+
     /**
      * Return the next set of resources when available
      *
      * @throws \Mollie\Api\Exceptions\ApiException
      */
-    final public function next(): ?CursorCollection
+    public function next(): ?CursorCollection
     {
         if (! $this->hasNext()) {
             return null;
@@ -26,7 +54,7 @@ final public function next(): ?CursorCollection
      *
      * @throws \Mollie\Api\Exceptions\ApiException
      */
-    final public function previous(): ?CursorCollection
+    public function previous(): ?CursorCollection
     {
         if (! $this->hasPrevious()) {
             return null;
@@ -37,9 +65,13 @@ final public function previous(): ?CursorCollection
 
     private function fetchCollection(string $url): CursorCollection
     {
-        return $this
+        $response = $this
             ->connector
             ->send(new DynamicGetRequest($url, static::class));
+
+        return $this->shouldAutoHydrate()
+            ? $response->toResource()
+            : $response;
     }
 
     /**
@@ -66,6 +98,8 @@ public function getAutoIterator(bool $iterateBackwards = false): LazyCollection
         $page = $this;
 
         return new LazyCollection(function () use ($page, $iterateBackwards): Generator {
+            $page->setAutoHydrate();
+
             while (true) {
                 foreach ($page as $item) {
                     yield $item;

src/Traits/HandlesAutoHydration.php

@@ -8,7 +8,7 @@ trait HandlesAutoHydration
 {
     protected static $hydrationSettingResolver = null;
 
-    public static function shouldAutoHydrate(bool $shouldAutoHydrate = true): void
+    public static function setAutoHydrate(bool $shouldAutoHydrate = true): void
     {
         static::$hydrationSettingResolver = static function () use ($shouldAutoHydrate) {
             ResourceHydratableRequest::hydrate($shouldAutoHydrate);

tests/Fixtures/SequenceMockResponse.php

@@ -30,4 +30,9 @@ public function pop(): MockResponse
 
         return $response;
     }
+
+    public function isEmpty(): bool
+    {
+        return count($this->responses) === 0;
+    }
 }

tests/Helpers/ArrTest.php

@@ -17,6 +17,25 @@ public function get(): void
         $this->assertEquals('default', Arr::get($array, 'foo.baz', 'default'));
     }
 
+    /** @test */
+    public function pull(): void
+    {
+        $array = ['foo' => ['bar' => 'baz']];
+
+        $this->assertEquals('baz', Arr::pull($array, 'foo.bar'));
+        $this->assertEquals(['foo' => []], $array);
+    }
+
+    /** @test */
+    public function forget(): void
+    {
+        $array = ['foo' => ['bar' => 'baz']];
+
+        Arr::forget($array, 'foo.bar');
+
+        $this->assertEquals(['foo' => []], $array);
+    }
+
     /** @test */
     public function has(): void
     {

tests/Http/Adapter/MockMollieHttpAdapter.php

@@ -29,15 +29,13 @@ public function __construct(array $expectedResponses = [])
      */
     public function sendRequest(PendingRequest $pendingRequest): Response
     {
-        if (! Arr::has($this->expectedResponses, $requestClass = get_class($pendingRequest->getRequest()))) {
+        $requestClass = get_class($pendingRequest->getRequest());
+
+        if (! Arr::has($this->expectedResponses, $requestClass)) {
             throw new \RuntimeException('The request class '.$requestClass.' is not expected.');
         }
 
-        $mockedResponse = $this->expectedResponses[$requestClass];
-
-        if ($mockedResponse instanceof SequenceMockResponse) {
-            $mockedResponse = $mockedResponse->pop();
-        }
+        $mockedResponse = $this->getResponse($requestClass);
 
         return new Response(
             $mockedResponse->createPsrResponse(),
@@ -46,6 +44,30 @@ public function sendRequest(PendingRequest $pendingRequest): Response
         );
     }
 
+    /**
+     * Get the mocked response and remove it from the expected responses.
+     *
+     * @param string $requestClass
+     * @return MockResponse
+     */
+    private function getResponse(string $requestClass): MockResponse
+    {
+        $mockedResponse = Arr::get($this->expectedResponses, $requestClass);
+
+        if (!($mockedResponse instanceof SequenceMockResponse)) {
+            Arr::forget($this->expectedResponses, $requestClass);
+            return $mockedResponse;
+        }
+
+        $response = $mockedResponse->pop();
+
+        if ($mockedResponse->isEmpty()) {
+            Arr::forget($this->expectedResponses, $requestClass);
+        }
+
+        return $response;
+    }
+
     /**
      * {@inheritDoc}
      */

tests/Http/Requests/CreatePaymentRequestTest.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Tests\Http\Requests;
+
+use Mollie\Api\Http\Payload\CreatePaymentPayload;
+use Mollie\Api\Http\Payload\Money;
+use Mollie\Api\Http\Query\CreatePaymentQuery;
+use Mollie\Api\Http\Requests\CreatePaymentRequest;
+use Mollie\Api\Http\Response;
+use Mollie\Api\Resources\Payment;
+use Tests\Fixtures\MockClient;
+use Tests\Fixtures\MockResponse;
+use Tests\TestCase;
+
+class CreatePaymentRequestTest extends TestCase
+{
+    /** @test */
+    public function it_can_create_payment()
+    {
+        $client = new MockClient([
+            CreatePaymentRequest::class => new MockResponse(201, 'payment'),
+        ]);
+
+        $payload = new CreatePaymentPayload(
+            'Test payment',
+            new Money('EUR', '10.00'),
+            'https://example.org/redirect',
+            'https://example.org/webhook'
+        );
+
+        $request = new CreatePaymentRequest($payload);
+
+        /** @var Response */
+        $response = $client->send($request);
+
+        $this->assertTrue($response->successful());
+        $this->assertInstanceOf(Payment::class, $response->toResource());
+    }
+}

tests/Http/Requests/GetPaginatedPaymentsRequestTest.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Tests\Http\Requests;
+
+use Mollie\Api\Http\Requests\DynamicGetRequest;
+use Mollie\Api\Http\Requests\GetPaginatedPaymentsRequest;
+use Mollie\Api\Http\Response;
+use Mollie\Api\Resources\LazyCollection;
+use Mollie\Api\Resources\Payment;
+use Mollie\Api\Resources\PaymentCollection;
+use Tests\Fixtures\MockClient;
+use Tests\Fixtures\MockResponse;
+use Tests\TestCase;
+
+class GetPaginatedPaymentsRequestTest extends TestCase
+{
+    /** @test */
+    public function it_can_get_paginated_payments()
+    {
+        $client = new MockClient([
+            GetPaginatedPaymentsRequest::class => new MockResponse(200, 'payment-list'),
+        ]);
+
+        $request = new GetPaginatedPaymentsRequest();
+
+        /** @var Response */
+        $response = $client->send($request);
+
+        $this->assertTrue($response->successful());
+
+        /** @var PaymentCollection */
+        $payments = $response->toResource();
+        // Assert response was properly handled
+        $this->assertInstanceOf(PaymentCollection::class, $payments);
+        $this->assertGreaterThan(0, $payments->count());
+
+        foreach ($payments as $payment) {
+            $this->assertInstanceOf(Payment::class, $payment);
+            $this->assertEquals('payment', $payment->resource);
+        }
+    }
+
+    /** @test */
+    public function it_can_iterate_over_payments()
+    {
+        $client = new MockClient([
+            GetPaginatedPaymentsRequest::class => new MockResponse(200, 'payment-list'),
+            DynamicGetRequest::class => new MockResponse(200, 'payment-list'),
+            DynamicGetRequest::class => new MockResponse(200, 'empty-list', 'payments'),
+        ]);
+
+        $request = (new GetPaginatedPaymentsRequest())->useIterator();
+
+        /** @var Response */
+        $response = $client->send($request);
+        $this->assertTrue($response->successful());
+
+        /** @var LazyCollection */
+        $payments = $response->toResource();
+
+        foreach ($payments as $payment) {
+            $this->assertInstanceOf(Payment::class, $payment);
+        }
+    }
+}