EndpointTest.php$0 ➔ testServeCatchesApiMethodException() - Code Metrics - Inspection of "Drop tests from scrutinizer analysis" - usox/json-schema-api - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1e427b...ae9ba8 )

by Daniel

created 2021-03-02 19:54 UTC

EndpointTest.php$0 ➔ testServeCatchesApiMethodException() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
dl	0
loc	49
rs	9.1127

<?php

declare(strict_types=1);

namespace Usox\JsonSchemaApi;

use Exception;
use Mockery;
use Mockery\Adapter\Phpunit\MockeryTestCase;
use Mockery\MockInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\LoggerInterface;
use Ramsey\Uuid\UuidFactoryInterface;
use Ramsey\Uuid\UuidInterface;
use stdClass;
use Teapot\StatusCode;
use Usox\JsonSchemaApi\Contract\MethodProviderInterface;
use Usox\JsonSchemaApi\Dispatch\MethodDispatcherInterface;
use Usox\JsonSchemaApi\Dispatch\RequestValidatorInterface;
use Usox\JsonSchemaApi\Exception\ApiException;
use Usox\JsonSchemaApi\Exception\ApiMethodException;
use Usox\JsonSchemaApi\Exception\ResponseMalformedException;
use Usox\JsonSchemaApi\Response\ResponseBuilderInterface;

class EndpointTest extends MockeryTestCase
{
    /** @var RequestValidatorInterface|MockInterface */
    private MockInterface $requestValidator;

    /** @var MethodDispatcherInterface|MockInterface */
    private MockInterface $methodDispatcher;

    /** @var ResponseBuilderInterface|MockInterface */
    private MockInterface $responseBuilder;

    /** @var UuidFactoryInterface|MockInterface */
    private MockInterface $uuidFactory;

    /** @var StreamFactoryInterface|MockInterface */
    private MockInterface $streamFactory;

    /** @var LoggerInterface|MockInterface */
    private MockInterface $logger;
    
    private Endpoint $subject;
    
    public function setUp(): void
    {
        $this->requestValidator = Mockery::mock(RequestValidatorInterface::class);
        $this->methodDispatcher = Mockery::mock(MethodDispatcherInterface::class);
        $this->responseBuilder = Mockery::mock(ResponseBuilderInterface::class);
        $this->uuidFactory = Mockery::mock(UuidFactoryInterface::class);
        $this->streamFactory = Mockery::mock(StreamFactoryInterface::class);
        $this->logger = Mockery::mock(LoggerInterface::class);
        
        $this->subject = new Endpoint(
            $this->requestValidator,
            $this->methodDispatcher,
            $this->responseBuilder,
            $this->uuidFactory,
            $this->streamFactory,
            $this->logger
        );
    }
    
    public function testServeReturnsHandlerOutput(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        $response = Mockery::mock(ResponseInterface::class);
        
        $parameter = new stdClass();
        $decodedInput = new stdClass();
        $decodedInput->parameter = $parameter;
        $responseData = ['some-response'];
        $processedResponse = ['some-processed-response'];
        
        $this->requestValidator->shouldReceive('validate')
            ->with($request)
            ->once()
            ->andReturn($decodedInput);
        
        $this->methodDispatcher->shouldReceive('dispatch')
            ->with($request, $decodedInput)
            ->once()
            ->andReturn($responseData);
        
        $this->responseBuilder->shouldReceive('buildResponse')
            ->with($responseData)
            ->once()
            ->andReturn($processedResponse);
        
        $this->createResponseExpectations(
            $response,
            $processedResponse,
            StatusCode::OK
        );
        
        static::assertSame(
            $response,
            $this->subject->serve($request, $response)
        );
    }

    public function testServeCatchesApiMethodException(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        $response = Mockery::mock(ResponseInterface::class);
        $uuid = Mockery::mock(UuidInterface::class);
        
        $errorMessage = 'some-error';
        $errorCode = 666;
        $processedResponse = ['some-processed-response'];
        $uuidValue = 'some-uuid';

        $error = new class($errorMessage, $errorCode) extends ApiMethodException {};

        $this->requestValidator->shouldReceive('validate')
            ->with($request)
            ->once()
            ->andThrow($error);

        $this->responseBuilder->shouldReceive('buildErrorResponse')
            ->with($error, $uuid)
            ->once()
            ->andReturn($processedResponse);
        
        $this->uuidFactory->shouldReceive('uuid4')
            ->withNoArgs()
            ->once()
            ->andReturn($uuid);
        
        $uuid->shouldReceive('toString')
            ->withNoArgs()
            ->once()
            ->andReturn($uuidValue);

        $this->createResponseExpectations(
            $response,
            $processedResponse,
            StatusCode::BAD_REQUEST
        );
        
        $this->logger->shouldReceive('error')
            ->with(
                sprintf('%s (%d)', $errorMessage, $errorCode),
                Mockery::type('array')
            )
            ->once();

        static::assertSame(
            $response,
            $this->subject->serve($request, $response)
        );
    }

    public function testServeCatchesApiException(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        $response = Mockery::mock(ResponseInterface::class);
        $uuid = Mockery::mock(UuidInterface::class);

        $errorMessage = 'some-error';
        $errorCode = 666;
        $processedResponse = ['some-processed-response'];
        $uuidValue = 'some-uuid';

        $error = new class($errorMessage, $errorCode) extends ApiException {};

        $this->requestValidator->shouldReceive('validate')
            ->with($request)
            ->once()
            ->andThrow($error);

        $this->responseBuilder->shouldReceive('buildErrorResponse')
            ->with($error, $uuid)
            ->once()
            ->andReturn($processedResponse);

        $this->uuidFactory->shouldReceive('uuid4')
            ->withNoArgs()
            ->once()
            ->andReturn($uuid);

        $uuid->shouldReceive('toString')
            ->withNoArgs()
            ->once()
            ->andReturn($uuidValue);

        $this->createResponseExpectations(
            $response,
            $processedResponse,
            StatusCode::BAD_REQUEST
        );

        $this->logger->shouldReceive('error')
            ->with(
                sprintf('%s (%d)', $errorMessage, $errorCode),
                Mockery::type('array')
            )
            ->once();

        static::assertSame(
            $response,
            $this->subject->serve($request, $response)
        );
    }

    public function testServeCatchesGenericException(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        $response = Mockery::mock(ResponseInterface::class);
        $uuid = Mockery::mock(UuidInterface::class);

        $errorMessage = 'some-error';
        $errorCode = 666;
        $uuidValue = 'some-uuid';

        $error = new Exception($errorMessage, $errorCode);

        $this->requestValidator->shouldReceive('validate')
            ->with($request)
            ->once()
            ->andThrow($error);

        $this->uuidFactory->shouldReceive('uuid4')
            ->withNoArgs()
            ->once()
            ->andReturn($uuid);

        $uuid->shouldReceive('toString')
            ->withNoArgs()
            ->once()
            ->andReturn($uuidValue);

        $this->createResponseExpectations(
            $response,
            '',
            StatusCode::INTERNAL_SERVER_ERROR
        );

        $this->logger->shouldReceive('error')
            ->with(
                sprintf('%s (%d)', $errorMessage, $errorCode),
                Mockery::type('array')
            )
            ->once();

        static::assertSame(
            $response,
            $this->subject->serve($request, $response)
        );
    }

    public function testServeCatchesInternalException(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        $response = Mockery::mock(ResponseInterface::class);
        $uuid = Mockery::mock(UuidInterface::class);

        $errorMessage = 'some-error';
        $errorCode = 666;
        $uuidValue = 'some-uuid';
        $context = ['some' => 'context'];

        $error = new ResponseMalformedException($errorMessage, $errorCode, null, $context);

        $this->requestValidator->shouldReceive('validate')
            ->with($request)
            ->once()
            ->andThrow($error);

        $this->uuidFactory->shouldReceive('uuid4')
            ->withNoArgs()
            ->once()
            ->andReturn($uuid);

        $uuid->shouldReceive('toString')
            ->withNoArgs()
            ->once()
            ->andReturn($uuidValue);

        $this->createResponseExpectations(
            $response,
            '',
            StatusCode::INTERNAL_SERVER_ERROR
        );

        $this->logger->shouldReceive('error')
            ->with(
                sprintf('%s (%d)', $errorMessage, $errorCode),
                Mockery::type('array')
            )
            ->once();

        static::assertSame(
            $response,
            $this->subject->serve($request, $response)
        );
    }
    
    public function testFactoryReturnsInstance(): void
    {
        static::assertInstanceOf(
            Endpoint::class,
            Endpoint::factory(
                Mockery::mock(MethodProviderInterface::class),
                Mockery::mock(StreamFactoryInterface::class)
            )
        );
    }

    public function testProcessWorksWithMiddleware(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        $response = Mockery::mock(ResponseInterface::class);
        $requestHandler = Mockery::mock(RequestHandlerInterface::class);

        $parameter = new stdClass();
        $decodedInput = new stdClass();
        $decodedInput->parameter = $parameter;
        $responseData = ['some-response'];
        $processedResponse = ['some-processed-response'];

        $this->requestValidator->shouldReceive('validate')
            ->with($request)
            ->once()
            ->andReturn($decodedInput);

        $this->methodDispatcher->shouldReceive('dispatch')
            ->with($request, $decodedInput)
            ->once()
            ->andReturn($responseData);

        $this->responseBuilder->shouldReceive('buildResponse')
            ->with($responseData)
            ->once()
            ->andReturn($processedResponse);

        $this->createResponseExpectations(
            $response,
            $processedResponse,
            StatusCode::OK
        );
        
        $requestHandler->shouldReceive('handle')
            ->with($request)
            ->once()
            ->andReturn($response);

        static::assertSame(
            $response,
            $this->subject->process($request, $requestHandler)
        );
    }

    /**
     * @param MockInterface $response
     * @param string|array<mixed, mixed> $responseData
     * @param int $statusCode
     */
    private function createResponseExpectations(
        MockInterface $response,
        $responseData,
        int $statusCode
    ): void {
        $stream = Mockery::mock(StreamInterface::class);
        
        $this->streamFactory->shouldReceive('createStream')
            ->with(json_encode($responseData))
            ->once()
            ->andReturn($stream);
        
        $response->shouldReceive('withHeader')
            ->with('Content-Type', 'application/json')
            ->once()
            ->andReturnSelf();
        $response->shouldReceive('withStatus')
            ->with($statusCode)
            ->once()
            ->andReturnSelf();
        $response->shouldReceive('withBody')
            ->with($stream)
            ->once()
            ->andReturnSelf();
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Usox\JsonSchemaApi;
6
7			use Exception;
8			use Mockery;
9			use Mockery\Adapter\Phpunit\MockeryTestCase;
10			use Mockery\MockInterface;
11			use Psr\Http\Message\ResponseInterface;
12			use Psr\Http\Message\ServerRequestInterface;
13			use Psr\Http\Message\StreamFactoryInterface;
14			use Psr\Http\Message\StreamInterface;
15			use Psr\Http\Server\RequestHandlerInterface;
16			use Psr\Log\LoggerInterface;
17			use Ramsey\Uuid\UuidFactoryInterface;
18			use Ramsey\Uuid\UuidInterface;
19			use stdClass;
20			use Teapot\StatusCode;
21			use Usox\JsonSchemaApi\Contract\MethodProviderInterface;
22			use Usox\JsonSchemaApi\Dispatch\MethodDispatcherInterface;
23			use Usox\JsonSchemaApi\Dispatch\RequestValidatorInterface;
24			use Usox\JsonSchemaApi\Exception\ApiException;
25			use Usox\JsonSchemaApi\Exception\ApiMethodException;
26			use Usox\JsonSchemaApi\Exception\ResponseMalformedException;
27			use Usox\JsonSchemaApi\Response\ResponseBuilderInterface;
28
29			class EndpointTest extends MockeryTestCase
30			{
31			/** @var RequestValidatorInterface\|MockInterface */
32			private MockInterface $requestValidator;
33
34			/** @var MethodDispatcherInterface\|MockInterface */
35			private MockInterface $methodDispatcher;
36
37			/** @var ResponseBuilderInterface\|MockInterface */
38			private MockInterface $responseBuilder;
39
40			/** @var UuidFactoryInterface\|MockInterface */
41			private MockInterface $uuidFactory;
42
43			/** @var StreamFactoryInterface\|MockInterface */
44			private MockInterface $streamFactory;
45
46			/** @var LoggerInterface\|MockInterface */
47			private MockInterface $logger;
48
49			private Endpoint $subject;
50
51			public function setUp(): void
52			{
53			$this->requestValidator = Mockery::mock(RequestValidatorInterface::class);
54			$this->methodDispatcher = Mockery::mock(MethodDispatcherInterface::class);
55			$this->responseBuilder = Mockery::mock(ResponseBuilderInterface::class);
56			$this->uuidFactory = Mockery::mock(UuidFactoryInterface::class);
57			$this->streamFactory = Mockery::mock(StreamFactoryInterface::class);
58			$this->logger = Mockery::mock(LoggerInterface::class);
59
60			$this->subject = new Endpoint(
61			$this->requestValidator,
62			$this->methodDispatcher,
63			$this->responseBuilder,
64			$this->uuidFactory,
65			$this->streamFactory,
66			$this->logger
67			);
68			}
69
70			public function testServeReturnsHandlerOutput(): void
71			{
72			$request = Mockery::mock(ServerRequestInterface::class);
73			$response = Mockery::mock(ResponseInterface::class);
74
75			$parameter = new stdClass();
76			$decodedInput = new stdClass();
77			$decodedInput->parameter = $parameter;
78			$responseData = ['some-response'];
79			$processedResponse = ['some-processed-response'];
80
81			$this->requestValidator->shouldReceive('validate')
82			->with($request)
83			->once()
84			->andReturn($decodedInput);
85
86			$this->methodDispatcher->shouldReceive('dispatch')
87			->with($request, $decodedInput)
88			->once()
89			->andReturn($responseData);
90
91			$this->responseBuilder->shouldReceive('buildResponse')
92			->with($responseData)
93			->once()
94			->andReturn($processedResponse);
95
96			$this->createResponseExpectations(
97			$response,
98			$processedResponse,
99			StatusCode::OK
100			);
101
102			static::assertSame(
103			$response,
104			$this->subject->serve($request, $response)
105			);
106			}
107
108			public function testServeCatchesApiMethodException(): void
109			{
110			$request = Mockery::mock(ServerRequestInterface::class);
111			$response = Mockery::mock(ResponseInterface::class);
112			$uuid = Mockery::mock(UuidInterface::class);
113
114			$errorMessage = 'some-error';
115			$errorCode = 666;
116			$processedResponse = ['some-processed-response'];
117			$uuidValue = 'some-uuid';
118
119			$error = new class($errorMessage, $errorCode) extends ApiMethodException {};
120
121			$this->requestValidator->shouldReceive('validate')
122			->with($request)
123			->once()
124			->andThrow($error);
125
126			$this->responseBuilder->shouldReceive('buildErrorResponse')
127			->with($error, $uuid)
128			->once()
129			->andReturn($processedResponse);
130
131			$this->uuidFactory->shouldReceive('uuid4')
132			->withNoArgs()
133			->once()
134			->andReturn($uuid);
135
136			$uuid->shouldReceive('toString')
137			->withNoArgs()
138			->once()
139			->andReturn($uuidValue);
140
141			$this->createResponseExpectations(
142			$response,
143			$processedResponse,
144			StatusCode::BAD_REQUEST
145			);
146
147			$this->logger->shouldReceive('error')
148			->with(
149			sprintf('%s (%d)', $errorMessage, $errorCode),
150			Mockery::type('array')
151			)
152			->once();
153
154			static::assertSame(
155			$response,
156			$this->subject->serve($request, $response)
157			);
158			}
159
160			public function testServeCatchesApiException(): void
161			{
162			$request = Mockery::mock(ServerRequestInterface::class);
163			$response = Mockery::mock(ResponseInterface::class);
164			$uuid = Mockery::mock(UuidInterface::class);
165
166			$errorMessage = 'some-error';
167			$errorCode = 666;
168			$processedResponse = ['some-processed-response'];
169			$uuidValue = 'some-uuid';
170
171			$error = new class($errorMessage, $errorCode) extends ApiException {};
172
173			$this->requestValidator->shouldReceive('validate')
174			->with($request)
175			->once()
176			->andThrow($error);
177
178			$this->responseBuilder->shouldReceive('buildErrorResponse')
179			->with($error, $uuid)
180			->once()
181			->andReturn($processedResponse);
182
183			$this->uuidFactory->shouldReceive('uuid4')
184			->withNoArgs()
185			->once()
186			->andReturn($uuid);
187
188			$uuid->shouldReceive('toString')
189			->withNoArgs()
190			->once()
191			->andReturn($uuidValue);
192
193			$this->createResponseExpectations(
194			$response,
195			$processedResponse,
196			StatusCode::BAD_REQUEST
197			);
198
199			$this->logger->shouldReceive('error')
200			->with(
201			sprintf('%s (%d)', $errorMessage, $errorCode),
202			Mockery::type('array')
203			)
204			->once();
205
206			static::assertSame(
207			$response,
208			$this->subject->serve($request, $response)
209			);
210			}
211
212			public function testServeCatchesGenericException(): void
213			{
214			$request = Mockery::mock(ServerRequestInterface::class);
215			$response = Mockery::mock(ResponseInterface::class);
216			$uuid = Mockery::mock(UuidInterface::class);
217
218			$errorMessage = 'some-error';
219			$errorCode = 666;
220			$uuidValue = 'some-uuid';
221
222			$error = new Exception($errorMessage, $errorCode);
223
224			$this->requestValidator->shouldReceive('validate')
225			->with($request)
226			->once()
227			->andThrow($error);
228
229			$this->uuidFactory->shouldReceive('uuid4')
230			->withNoArgs()
231			->once()
232			->andReturn($uuid);
233
234			$uuid->shouldReceive('toString')
235			->withNoArgs()
236			->once()
237			->andReturn($uuidValue);
238
239			$this->createResponseExpectations(
240			$response,
241			'',
242			StatusCode::INTERNAL_SERVER_ERROR
243			);
244
245			$this->logger->shouldReceive('error')
246			->with(
247			sprintf('%s (%d)', $errorMessage, $errorCode),
248			Mockery::type('array')
249			)
250			->once();
251
252			static::assertSame(
253			$response,
254			$this->subject->serve($request, $response)
255			);
256			}
257
258			public function testServeCatchesInternalException(): void
259			{
260			$request = Mockery::mock(ServerRequestInterface::class);
261			$response = Mockery::mock(ResponseInterface::class);
262			$uuid = Mockery::mock(UuidInterface::class);
263
264			$errorMessage = 'some-error';
265			$errorCode = 666;
266			$uuidValue = 'some-uuid';
267			$context = ['some' => 'context'];
268
269			$error = new ResponseMalformedException($errorMessage, $errorCode, null, $context);
270
271			$this->requestValidator->shouldReceive('validate')
272			->with($request)
273			->once()
274			->andThrow($error);
275
276			$this->uuidFactory->shouldReceive('uuid4')
277			->withNoArgs()
278			->once()
279			->andReturn($uuid);
280
281			$uuid->shouldReceive('toString')
282			->withNoArgs()
283			->once()
284			->andReturn($uuidValue);
285
286			$this->createResponseExpectations(
287			$response,
288			'',
289			StatusCode::INTERNAL_SERVER_ERROR
290			);
291
292			$this->logger->shouldReceive('error')
293			->with(
294			sprintf('%s (%d)', $errorMessage, $errorCode),
295			Mockery::type('array')
296			)
297			->once();
298
299			static::assertSame(
300			$response,
301			$this->subject->serve($request, $response)
302			);
303			}
304
305			public function testFactoryReturnsInstance(): void
306			{
307			static::assertInstanceOf(
308			Endpoint::class,
309			Endpoint::factory(
310			Mockery::mock(MethodProviderInterface::class),
311			Mockery::mock(StreamFactoryInterface::class)
312			)
313			);
314			}
315
316			public function testProcessWorksWithMiddleware(): void
317			{
318			$request = Mockery::mock(ServerRequestInterface::class);
319			$response = Mockery::mock(ResponseInterface::class);
320			$requestHandler = Mockery::mock(RequestHandlerInterface::class);
321
322			$parameter = new stdClass();
323			$decodedInput = new stdClass();
324			$decodedInput->parameter = $parameter;
325			$responseData = ['some-response'];
326			$processedResponse = ['some-processed-response'];
327
328			$this->requestValidator->shouldReceive('validate')
329			->with($request)
330			->once()
331			->andReturn($decodedInput);
332
333			$this->methodDispatcher->shouldReceive('dispatch')
334			->with($request, $decodedInput)
335			->once()
336			->andReturn($responseData);
337
338			$this->responseBuilder->shouldReceive('buildResponse')
339			->with($responseData)
340			->once()
341			->andReturn($processedResponse);
342
343			$this->createResponseExpectations(
344			$response,
345			$processedResponse,
346			StatusCode::OK
347			);
348
349			$requestHandler->shouldReceive('handle')
350			->with($request)
351			->once()
352			->andReturn($response);
353
354			static::assertSame(
355			$response,
356			$this->subject->process($request, $requestHandler)
357			);
358			}
359
360			/**
361			* @param MockInterface $response
362			* @param string\|array<mixed, mixed> $responseData
363			* @param int $statusCode
364			*/
365			private function createResponseExpectations(
366			MockInterface $response,
367			$responseData,
368			int $statusCode
369			): void {
370			$stream = Mockery::mock(StreamInterface::class);
371
372			$this->streamFactory->shouldReceive('createStream')
373			->with(json_encode($responseData))
374			->once()
375			->andReturn($stream);
376
377			$response->shouldReceive('withHeader')
378			->with('Content-Type', 'application/json')
379			->once()
380			->andReturnSelf();
381			$response->shouldReceive('withStatus')
382			->with($statusCode)
383			->once()
384			->andReturnSelf();
385			$response->shouldReceive('withBody')
386			->with($stream)
387			->once()
388			->andReturnSelf();
389			}
390			}
391

usox / json-schema-api

Push — master ( 1e427b...ae9ba8 )

EndpointTest.php$0 ➔ testServeCatchesApiMethodException() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like