Usox\JsonSchemaApi\Dispatch\RequestValidatorTest

Complexity

Total Complexity

4

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	testValidateThrowsExceptionIfInputIsInvalid()	0	22	1
A	setUp()	0	8	1
A	testValidateReturnsValidatedInput()	0	37	1
A	testValidateThrowsExceptionIfInputDoesNotValidate()	0	39	1

<?php

declare(strict_types=1);

namespace Usox\JsonSchemaApi\Dispatch;

use JsonSchema\Validator;
use Mockery;
use Mockery\Adapter\Phpunit\MockeryTestCase;
use Mockery\MockInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;
use Teapot\StatusCode;
use Usox\JsonSchemaApi\Dispatch\Exception\JsonInvalidException;
use Usox\JsonSchemaApi\Exception\RequestMalformedException;

class RequestValidatorTest extends MockeryTestCase
{
    /** @var MockInterface|SchemaLoaderInterface */
    private MockInterface $schemaLoader;
    
    /** @var MockInterface|Validator */
    private MockInterface $validator;
    
    private RequestValidator $subject;
    
    public function setUp(): void
    {
        $this->schemaLoader = Mockery::mock(SchemaLoaderInterface::class);
        $this->validator = Mockery::mock(Validator::class);
        
        $this->subject = new RequestValidator(
            $this->schemaLoader,

$this->schemaLoader of type Mockery\MockInterface is incompatible with the type Usox\JsonSchemaApi\Dispatch\SchemaLoaderInterface expected by parameter $schemaLoader of Usox\JsonSchemaApi\Dispatch\RequestValidator::__construct().

            $this->validator

$this->validator of type Mockery\MockInterface is incompatible with the type JsonSchema\Validator expected by parameter $schemaValidator of Usox\JsonSchemaApi\Dispatch\RequestValidator::__construct().

        );
    }
    
    public function testValidateThrowsExceptionIfInputIsInvalid(): void
    {
        $this->expectException(JsonInvalidException::class);
        $this->expectExceptionMessage('Input is no valid json (Syntax error)');
        $this->expectExceptionCode(StatusCode::BAD_REQUEST);
        
        $stream = Mockery::mock(StreamInterface::class);
        $request = Mockery::mock(ServerRequestInterface::class);
        
        $input = 'some-input' . PHP_EOL . 'errors';
        
        $request->shouldReceive('getBody')
            ->withNoArgs()
            ->once()
            ->andReturn($stream);
        
        $stream->shouldReceive('getContents')
            ->withNoArgs()
            ->once()
            ->andReturn($input);
        
        $this->subject->validate($request);

$request of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type Psr\Http\Message\ServerRequestInterface expected by parameter $request of Usox\JsonSchemaApi\Dispatch\RequestValidator::validate().

    }

    public function testValidateThrowsExceptionIfInputDoesNotValidate(): void
    {
        $this->expectException(RequestMalformedException::class);
        $this->expectExceptionMessage('Request is invalid');
        $this->expectExceptionCode(StatusCode::BAD_REQUEST);

        $stream = Mockery::mock(StreamInterface::class);
        $request = Mockery::mock(ServerRequestInterface::class);

        $input = ['some' => 'input'];
        $schemaContent = (object) ['some' => 'schema-content'];

        $this->schemaLoader->shouldReceive('load')
            ->once()
            ->andReturn($schemaContent);
        
        $this->validator->shouldReceive('validate')
            ->with(
                Mockery::on(static function ($value) use ($input): bool {
                    return (array) $value === $input;
                }),
                Mockery::on(static function ($value) use ($schemaContent): bool {
                    return $value == $schemaContent;
                })
            )
            ->once()
            ->andReturn(666);

        $request->shouldReceive('getBody')
            ->withNoArgs()
            ->once()
            ->andReturn($stream);

        $stream->shouldReceive('getContents')
            ->withNoArgs()
            ->once()
            ->andReturn(json_encode($input));

        $this->subject->validate($request);

$request of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type Psr\Http\Message\ServerRequestInterface expected by parameter $request of Usox\JsonSchemaApi\Dispatch\RequestValidator::validate().

    }

    public function testValidateReturnsValidatedInput(): void
    {
        $stream = Mockery::mock(StreamInterface::class);
        $request = Mockery::mock(ServerRequestInterface::class);

        $input = ['some' => 'input'];
        $schemaContent = (object) ['some' => 'schema-content'];

        $this->schemaLoader->shouldReceive('load')
            ->once()
            ->andReturn($schemaContent);

        $this->validator->shouldReceive('validate')
            ->with(
                Mockery::on(static function ($value) use ($input): bool {
                    return (array) $value === $input;
                }),
                Mockery::on(static function ($value) use ($schemaContent): bool {
                    return $value == $schemaContent;
                })
            )
            ->once()
            ->andReturn(Validator::ERROR_NONE);

        $request->shouldReceive('getBody')
            ->withNoArgs()
            ->once()
            ->andReturn($stream);

        $stream->shouldReceive('getContents')
            ->withNoArgs()
            ->once()
            ->andReturn(json_encode($input));

        static::assertEquals(
            (object) $input,
            $this->subject->validate($request)

$request of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type Psr\Http\Message\ServerRequestInterface expected by parameter $request of Usox\JsonSchemaApi\Dispatch\RequestValidator::validate().

        );
    }
}