Add more unit tests

tests/Unit/AuthTest.php

@@ -0,0 +1,158 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit;
+
+use CodeMash\Auth;
+use CodeMash\Exceptions\RequestValidationException;
+use Generator;
+
+final class AuthTest extends CodeMashTestCase
+{
+    /** @var Auth */
+    private $auth;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->auth = new Auth($this->client);
+    }
+
+    /**
+     * @dataProvider provideTestAuthenticateFail
+     */
+    public function testAuthenticateFail(
+        array $params,
+        string $expectedException,
+        string $expectedExceptionMessage
+    ): void {
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->auth->authenticate($params);
+    }
+
+    public static function provideTestAuthenticateFail(): Generator
+    {
+        yield 'Empty params' => [
+            '$params' => [],
+            '$expectedException' => RequestValidationException::class,
+            '$expectedExceptionMessage' => '"password" is required!',
+        ];
+
+        yield 'Missing userName' => [
+            '$params' => ['password' => 'fooBar'],
+            '$expectedException' => RequestValidationException::class,
+            '$expectedExceptionMessage' => '"userName" is required!',
+        ];
+    }
+
+    public function testAuthenticate(): void
+    {
+        $params = [
+            'password' => 'testPassword',
+            'userName' => 'testUserName',
+        ];
+
+        $expectedResult = ['foo' => 'bar'];
+
+        $this->client
+            ->expects($this->once())
+            ->method('request')
+            ->with(
+                'POST',
+                'v2/auth/credentials',
+                [
+                    'headers' => [
+                        'Accept' => 'application/json',
+                        'Content-Type' => 'application/json',
+                    ],
+                    'body' => '{"password":"testPassword","userName":"testUserName"}',
+                ]
+            )->willReturn(['result' => $expectedResult]);
+
+        $actualResult = $this->auth->authenticate($params);
+
+        $this->assertSame($expectedResult, $actualResult);
+    }
+
+    public function testCheckAuth(): void
+    {
+        $expectedResult = ['foo' => 'bar'];
+
+        $this->client
+            ->expects($this->once())
+            ->method('request')
+            ->with(
+                'POST',
+                'v2/auth/',
+                [
+                    'headers' => [
+                        'Accept' => 'application/json',
+                        'Content-Type' => 'application/json',
+                    ],
+                ]
+            )->willReturn(['result' => $expectedResult]);
+
+        $actualResult = $this->auth->checkAuth();
+
+        $this->assertSame($expectedResult, $actualResult);
+    }
+
+    /**
+     * @dataProvider provideTestLogoutFail
+     */
+    public function testLogoutFail(
+        array $params,
+        string $expectedException,
+        string $expectedExceptionMessage
+    ): void {
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->auth->logout($params);
+    }
+
+    public static function provideTestLogoutFail(): Generator
+    {
+        yield 'Empty params' => [
+            '$params' => [],
+            '$expectedException' => RequestValidationException::class,
+            '$expectedExceptionMessage' => '"bearerToken" is required!',
+        ];
+    }
+
+    public function testLogout(): void
+    {
+        $params = [
+            'bearerToken' => 'testBearerToken',
+        ];
+
+        $expectedResult = [
+            'result' => [
+                'foo' => 'bar'
+            ],
+        ];
+
+        $this->client
+            ->expects($this->once())
+            ->method('request')
+            ->with(
+                'POST',
+                'auth/logout',
+                [
+                    'headers' => [
+                        'Accept' => 'application/json',
+                        'Content-Type' => 'application/json',
+                        'Authorization' => 'Bearer testBearerToken',
+                    ],
+                ]
+            )->willReturn($expectedResult);
+
+        $actualResult = $this->auth->logout($params);
+
+        $this->assertSame($expectedResult, $actualResult);
+    }
+}

tests/Unit/CodeMashTestCase.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit;
+
+use CodeMash\Client;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+class CodeMashTestCase extends TestCase
+{
+    /** @var Client|MockObject */
+    protected $client;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->client = $this->getMockBuilder(Client::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods(['request'])
+            ->getMock();
+    }
+}

tests/Unit/CodeTest.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit;
+
+use CodeMash\Code;
+use CodeMash\Exceptions\RequestValidationException;
+use Generator;
+
+final class CodeTest extends CodeMashTestCase
+{
+    /** @var Code */
+    private $code;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->code = new Code($this->client);
+    }
+
+    /** @dataProvider provideTestExecuteFunctionFail */
+    public function testExecuteFunctionFail(
+        array $params,
+        string $expectedException,
+        string $expectedExceptionMessage
+    ): void {
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->code->executeFunction($params);
+    }
+
+    public static function provideTestExecuteFunctionFail(): Generator
+    {
+        yield 'Empty params' => [
+            '$params' => [],
+            '$expectedException' => RequestValidationException::class,
+            '$expectedExceptionMessage' => '"id" is required!',
+        ];
+    }
+
+    /**
+     * @dataProvider provideTestExecuteFunction
+     */
+    public function testExecuteFunction(
+        array $params,
+        string $expectedBody,
+        array $expectedResponse,
+        array $expectedResult
+    ): void {
+        $this->client
+            ->expects($this->once())
+            ->method('request')
+            ->with(
+                'POST',
+                'v2/serverless/functions/testId/execute',
+                [
+                    'headers' => [
+                        'Accept' => 'application/json',
+                        'Content-Type' => 'application/json',
+                    ],
+                    'body' => $expectedBody,
+                ]
+            )->willReturn($expectedResponse);
+
+        $actualResult = $this->code->executeFunction($params);
+
+        $this->assertSame($expectedResult, $actualResult);
+    }
+
+    public static function provideTestExecuteFunction(): Generator
+    {
+        yield 'All parameters are set' => [
+            '$params' => [
+                'id' => 'testId',
+                'template' => 'testTemplate',
+                'qualifier' => 'testQualifier',
+            ],
+            '$expectedBody' => '{"id":"testId","template":"testTemplate","qualifier":"testQualifier"}',
+            '$expectedResponse' => ['result' => '{"foo":"bar"}'],
+            '$expectedResult' => [
+                'foo' => 'bar',
+            ],
+        ];
+
+        yield 'Only id is set' => [
+            '$params' => [
+                'id' => 'testId',
+            ],
+            '$expectedBody' => '{"id":"testId","template":null,"qualifier":null}',
+            '$expectedResponse' => ['result' => '{"foo":"bar"}'],
+            '$expectedResult' => [
+                'foo' => 'bar',
+            ],
+        ];
+    }
+}

tests/Unit/DbTest.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit;
+
+use CodeMash\Db;
+use CodeMash\Exceptions\RequestValidationException;
+use Generator;
+
+final class DbTest extends CodeMashTestCase
+{
+    /** @var Db */
+    private $db;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->db = new Db($this->client);
+    }
+
+    /**
+     * @dataProvider provideTestInsertOneFail
+     */
+    public function testInsertOneFail(
+        array $params,
+        string $expectedException,
+        string $expectedExceptionMessage
+    ): void {
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->db->insertOne($params);
+    }
+
+    public static function provideTestInsertOneFail(): Generator
+    {
+        yield 'Empty params' => [
+            '$params' => [],
+            '$expectedException' => RequestValidationException::class,
+            '$expectedExceptionMessage' => '"collectionName" is required!',
+        ];
+
+        yield 'Missing document' => [
+            '$params' => ['collectionName' => 'testCollection'],
+            '$expectedException' => RequestValidationException::class,
+            '$expectedExceptionMessage' => '"document" is required!',
+        ];
+    }
+
+    public function testInsertOne(): void
+    {
+        $params = [
+            'collectionName' => 'testCollection',
+            'document' => 'testDocument',
+        ];
+
+        $expectedParams = [
+            'collectionName' => 'testCollection',
+            'document' => toJson('testDocument'),
+            'bypassDocumentValidation' => false,
+            'waitForFileUpload' => false,
+            'ignoreTriggers' => false,
+        ];
+
+        $result = ['result' => '{}'];
+
+        $expectedResult = [];
+
+        $this->client
+            ->expects($this->once())
+            ->method('request')
+            ->with(
+                'POST',
+                'v2/db/testCollection',
+                [
+                    'headers' => [
+                        'Accept' => 'application/json',
+                        'Content-Type' => 'application/json',
+                    ],
+                    'body' => toJson($expectedParams),
+                ]
+            )->willReturn($result);
+
+        $actualResult = $this->db->insertOne($params);
+
+        $this->assertSame($expectedResult, $actualResult);
+    }
+}