Usox\JsonSchemaApi\Dispatch\MethodDispatcherTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	10	1
A	testDispatchReturnsHandler()	0	49	1
A	testDispatchThrowsExceptionIfMethodDoesNotExist()	0	21	1

<?php

declare(strict_types=1);

namespace Usox\JsonSchemaApi\Dispatch;

use Mockery;
use Mockery\Adapter\Phpunit\MockeryTestCase;
use Mockery\MockInterface;
use Psr\Http\Message\ServerRequestInterface;
use Teapot\StatusCode;
use Usox\JsonSchemaApi\Contract\ApiMethodInterface;
use Usox\JsonSchemaApi\Contract\MethodProviderInterface;
use Usox\JsonSchemaApi\Exception\MethodNotFoundException;

class MethodDispatcherTest extends MockeryTestCase
{
    /** @var MockInterface|SchemaLoaderInterface */
    private MockInterface $schemaLoader;
    
    /** @var MethodValidatorInterface|MockInterface */
    private MockInterface $methodValidator;

    /** @var MethodProviderInterface|MockInterface */
    private MockInterface $methodProvider;
    
    private MethodDispatcher $subject;
    
    public function setUp(): void
    {
        $this->schemaLoader = Mockery::mock(SchemaLoaderInterface::class);
        $this->methodValidator = Mockery::mock(MethodValidatorInterface::class);
        $this->methodProvider = Mockery::mock(MethodProviderInterface::class);
        
        $this->subject = new MethodDispatcher(
            $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\MethodDispatcher::__construct().

            $this->methodValidator,

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

            $this->methodProvider

$this->methodProvider of type Mockery\MockInterface is incompatible with the type Usox\JsonSchemaApi\Contract\MethodProviderInterface expected by parameter $methodProvider of Usox\JsonSchemaApi\Dispatch\MethodDispatcher::__construct().

        );
    }
    
    public function testDispatchThrowsExceptionIfMethodDoesNotExist(): void
    {
        $request = Mockery::mock(ServerRequestInterface::class);
        
        $this->expectException(MethodNotFoundException::class);
        $this->expectExceptionMessage('Method not found');
        $this->expectExceptionCode(StatusCode::BAD_REQUEST);
        
        $method = 'some-method';
        $version = null;
        
        $input = ['method' => $method, 'version' => $version];
        
        $this->methodProvider->shouldReceive('lookup')
            ->with($method)
            ->once()
            ->andReturnNull();

The method andReturnNull() does not exist on Mockery\ExpectationInterface. Did you maybe mean andReturn()?

        
        $this->subject->dispatch(
            $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\MethodDispatcher::dispatch().

            (object) $input
        );
    }

    public function testDispatchReturnsHandler(): void
    {
        $method = 'some-method';
        $version = 666;
        $result = ['some-result'];
        $parameter = (object) ['some-parameter'];
        $schemaContent = (object) ['some' => 'schema-content'];
        $schemaFilePath = 'some-path';

        $input = (object) ['method' => $method, 'version' => $version, 'parameter' => $parameter];

        $request = Mockery::mock(ServerRequestInterface::class);
        $handler = Mockery::mock(ApiMethodInterface::class);
        
        $handler->shouldReceive('getSchemaFile')
            ->withNoArgs()
            ->once()
            ->andReturn($schemaFilePath);
        
        $this->schemaLoader->shouldReceive('load')
            ->with($schemaFilePath)
            ->once()
            ->andReturn($schemaContent);

        $this->methodProvider->shouldReceive('lookup')
            ->with(sprintf('%s.%d', $method, $version))
            ->once()
            ->andReturn($handler);
        
        $this->methodValidator->shouldReceive('validateInput')
            ->with($schemaContent, $input)
            ->once();
        $this->methodValidator->shouldReceive('validateOutput')
            ->with(
                $schemaContent,
                Mockery::on(function ($param) use ($result): bool {
                    return (array) $param == $result;
                })
            )
            ->once();
        
        $handler->shouldReceive('handle')
            ->with($request, $parameter)
            ->once()
            ->andReturn($result);
        
        static::assertSame(
            $result,
            $this->subject->dispatch($request, $input)

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

        );
    }
}