test: cover codex compatibility helpers

Author: abdusfauzi

phpstan-baseline.neon

@@ -570,18 +570,6 @@ parameters:
 			count: 1
 			path: src/Internal/Codex/Testing/Assert.php
 
-		-
-			message: '#^Call to an undefined static method PHPUnit\\Framework\\InvalidArgumentException\:\:create\(\)\.$#'
-			identifier: staticMethod.notFound
-			count: 2
-			path: src/Internal/Codex/Testing/Assert.php
-
-		-
-			message: '#^Call to static method factory\(\) on an unknown class PHPUnit\\Util\\InvalidArgumentHelper\.$#'
-			identifier: class.notFound
-			count: 2
-			path: src/Internal/Codex/Testing/Assert.php
-
 		-
 			message: '#^Method Laravie\\Codex\\Testing\\Assert\:\:assertArraySubset\(\) has parameter \$array with generic interface ArrayAccess but does not specify its types\: TKey, TValue$#'
 			identifier: missingType.generics

src/Internal/Codex/Testing/Assert.php

@@ -4,11 +4,9 @@
 
 use ArrayAccess;
 use PHPUnit\Framework\Assert as PHPUnit;
-use PHPUnit\Framework\InvalidArgumentException;
 use PHPUnit\Runner\Version;
-use PHPUnit\Util\InvalidArgumentHelper;
 
-if (class_exists(Version::class) && (int) Version::series()[0] >= 8) {
+if (class_exists(Version::class) && version_compare(Version::series(), '8.0', '>=')) {
     /**
      * @internal this class is not meant to be used or overwritten outside the framework itself
      */
@@ -23,19 +21,11 @@ abstract class Assert extends PHPUnit
         public static function assertArraySubset($subset, $array, bool $checkForIdentity = false, string $msg = ''): void
         {
             if (! (\is_array($subset) || $subset instanceof ArrayAccess)) {
-                if (class_exists(InvalidArgumentException::class)) {
-                    throw InvalidArgumentException::create(1, 'array or ArrayAccess');
-                } else {
-                    throw InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
-                }
+                throw new \InvalidArgumentException('Argument #1 must be of type array or ArrayAccess');
             }
 
             if (! (\is_array($array) || $array instanceof ArrayAccess)) {
-                if (class_exists(InvalidArgumentException::class)) {
-                    throw InvalidArgumentException::create(2, 'array or ArrayAccess');
-                } else {
-                    throw InvalidArgumentHelper::factory(2, 'array or ArrayAccess');
-                }
+                throw new \InvalidArgumentException('Argument #2 must be of type array or ArrayAccess');
             }
 
             $constraint = new ArraySubset($subset, $checkForIdentity);

tests/CodexCoverageTest.php

@@ -0,0 +1,176 @@
+<?php
+
+use Http\Client\Common\HttpMethodsClient;
+use Laravie\Codex\Common\Discovery as CommonDiscovery;
+use Laravie\Codex\Concerns\Passport;
+use Laravie\Codex\Concerns\Request\Json;
+use Laravie\Codex\Contracts\Response as ResponseContract;
+use Laravie\Codex\Testing\Assert as CodexAssert;
+use Laravie\Codex\Testing\Faker;
+
+final class TestDiscovery extends CommonDiscovery
+{
+    public static int $makeCalls = 0;
+
+    public static ?HttpMethodsClient $nextClient = null;
+
+    public static function make(): HttpMethodsClient
+    {
+        self::$makeCalls++;
+
+        return self::$nextClient ?? Faker::create()->http();
+    }
+}
+
+it('adds the json content type header before sending requests', function (): void {
+    $response = Mockery::mock(ResponseContract::class);
+
+    $request = new class($response)
+    {
+        use Json;
+
+        public array $sent = [];
+
+        public function __construct(private ResponseContract $response) {}
+
+        public function sendJsonRequest(string $method, $path, array $headers = [], $body = []): ResponseContract
+        {
+            return $this->sendJson($method, $path, $headers, $body);
+        }
+
+        protected function send(string $method, $path, array $headers = [], $body = []): ResponseContract
+        {
+            $this->sent = compact('method', 'path', 'headers', 'body');
+
+            return $this->response;
+        }
+    };
+
+    $result = $request->sendJsonRequest('POST', '/bills', ['Accept' => 'application/json'], ['name' => 'Test']);
+
+    expect($result)->toBe($response);
+    expect($request->sent)->toBe([
+        'method' => 'POST',
+        'path' => '/bills',
+        'headers' => [
+            'Accept' => 'application/json',
+            'Content-Type' => 'application/json',
+        ],
+        'body' => ['name' => 'Test'],
+    ]);
+});
+
+it('stores passport credentials fluently', function (): void {
+    $passport = new class
+    {
+        use Passport;
+    };
+
+    expect($passport->getClientId())->toBeNull();
+    expect($passport->getClientSecret())->toBeNull();
+    expect($passport->getAccessToken())->toBeNull();
+
+    $result = $passport
+        ->setClientId('client-id')
+        ->setClientSecret('client-secret')
+        ->setAccessToken('access-token');
+
+    expect($result)->toBe($passport);
+    expect($passport->getClientId())->toBe('client-id');
+    expect($passport->getClientSecret())->toBe('client-secret');
+    expect($passport->getAccessToken())->toBe('access-token');
+});
+
+it('caches refreshed and overridden discovery clients', function (): void {
+    $first = Faker::create()->http();
+    $second = Faker::create()->http();
+    $override = Faker::create()->http();
+
+    TestDiscovery::flush();
+    TestDiscovery::$makeCalls = 0;
+    TestDiscovery::$nextClient = $first;
+
+    expect(TestDiscovery::client())->toBe($first);
+    expect(TestDiscovery::client())->toBe($first);
+    expect(TestDiscovery::$makeCalls)->toBe(1);
+
+    TestDiscovery::$nextClient = $second;
+
+    expect(TestDiscovery::refreshClient())->toBe($second);
+    expect(TestDiscovery::$makeCalls)->toBe(2);
+
+    expect(TestDiscovery::override($override))->toBe($override);
+    expect(TestDiscovery::client())->toBe($override);
+
+    TestDiscovery::flush();
+    TestDiscovery::$nextClient = null;
+});
+
+it('asserts array subsets for arrays and array access values', function (): void {
+    CodexAssert::assertArraySubset(['foo' => 'bar'], ['foo' => 'bar', 'baz' => 'qux']);
+    CodexAssert::assertArraySubset(['foo' => 'bar'], new \ArrayObject(['foo' => 'bar', 'baz' => 'qux']));
+
+    expect(true)->toBeTrue();
+});
+
+it('rejects invalid values when asserting array subsets', function (): void {
+    try {
+        CodexAssert::assertArraySubset('invalid', []);
+        $this->fail('Expected invalid subset assertion to throw.');
+    } catch (\InvalidArgumentException $e) {
+        expect($e->getMessage())->toContain('array or ArrayAccess');
+    }
+
+    try {
+        CodexAssert::assertArraySubset([], 'invalid');
+        $this->fail('Expected invalid array assertion to throw.');
+    } catch (\InvalidArgumentException $e) {
+        expect($e->getMessage())->toContain('array or ArrayAccess');
+    }
+});
+
+it('filters request bodies and preserves endpoint queries', function (): void {
+    $this->apiVersion = 'v5';
+
+    $faker = $this->expectRequest(
+        'POST',
+        'payments?foo=bar',
+        ['Accept' => 'application/json', 'X-Test' => '1'],
+        ['amount' => 200, 'description' => 'Example']
+    )->shouldResponseWithJson(200, '{}');
+
+    $request = new class extends \Billplz\Request
+    {
+        public function __construct()
+        {
+            parent::__construct();
+
+            $this->version = 'v5';
+        }
+
+        public function createPayment(array $payload): \Laravie\Codex\Contracts\Response
+        {
+            return $this->send(
+                'POST',
+                self::to('/payments', [], ['foo' => 'bar']),
+                $this->mergeApiHeaders(['X-Test' => '1']),
+                $this->mergeApiBody($payload)
+            );
+        }
+
+        protected function getApiHeaders(): array
+        {
+            return ['Accept' => 'application/json'];
+        }
+
+        protected function getApiBody(): array
+        {
+            return ['amount' => \Money\Money::MYR(200)];
+        }
+    };
+
+    $request->setClient($this->makeClient($faker));
+
+    expect($request->hasFilterable())->toBeTrue();
+    expect($request->createPayment(['description' => 'Example']))->toBeInstanceOf(\Billplz\Response::class);
+});