League\Tactician\Bundle\Tests\DependencyInjection\HandlerMapping\ProtectedMethodHandler

Complexity

Total Complexity

2

Size/Duplication

Total Lines	10
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	0

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	handle()	0	3	1
A	execute()	0	3	1

<?php
declare(strict_types=1);

namespace League\Tactician\Bundle\Tests\DependencyInjection\HandlerMapping;

use DateTime;
use League\Tactician\Bundle\DependencyInjection\HandlerMapping\Routing;
use League\Tactician\Bundle\DependencyInjection\HandlerMapping\TypeHintMapping;
use League\Tactician\Bundle\DependencyInjection\InvalidCommandBusId;
use League\Tactician\Bundle\Tests\Fake\FakeCommand;
use League\Tactician\Bundle\Tests\Fake\OtherFakeCommand;
use PHPUnit\Framework\TestCase;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;

final class TypeHintMappingTest extends TestCase
{
    public function test_will_skip_definitions_without_auto_tag()
    {
        $builder = new ContainerBuilder();
        $builder
            ->setDefinition('some.handler', new Definition(InvokeHandler::class))
            ->addTag('tactician.handler', ['foo' => 'bar']);

        $routing = (new TypeHintMapping())->build($builder, new Routing(['default']));

        $this->assertEquals([], $routing->commandToServiceMapping('default'));
    }

    /**
     * @dataProvider simpleTestCases
     */
    public function test_standard(string $handlerFQCN, array $expectedMapping)
    {
        $builder = new ContainerBuilder();
        $builder
            ->setDefinition('some.handler', new Definition($handlerFQCN))
            ->addTag('tactician.handler', ['auto' => true]);

        $routing = (new TypeHintMapping())->build($builder, new Routing(['default']));

        $this->assertEquals($expectedMapping, $routing->commandToServiceMapping('default'));
    }

    public function simpleTestCases()
    {
        return [
            'can read __invoke magic method type hint' => [
                InvokeHandler::class,
                [FakeCommand::class => 'some.handler']
            ],
            'takes unary methods but not those with multiple parameters' => [
                BasicHandler::class,
                [FakeCommand::class => 'some.handler', OtherFakeCommand::class => 'some.handler']
            ],
            'can not exclude built-in objects unfortunately' => [
                DateTimeHandler::class,
                [DateTime::class => 'some.handler']
            ],
            'will skip methods with no typehint' => [NoTypehintHandler::class, []],
            'will not try to map scalar typehints' => [ScalarHandler::class, []],
            'will not use protected or private methods' => [ProtectedMethodHandler::class, []]
        ];
    }

    public function test_can_bind_to_specific_bus()
    {
        $builder = new ContainerBuilder();
        $builder
            ->setDefinition('first.handler', new Definition(BasicHandler::class))
            ->addTag('tactician.handler', ['auto' => true, 'bus' => 'bus.a']);

        $builder
            ->setDefinition('second.handler', new Definition(DateTimeHandler::class))
            ->addTag('tactician.handler', ['auto' => true, 'bus' => 'bus.b']);

        $routing = (new TypeHintMapping())->build($builder, new Routing(['bus.a', 'bus.b']));

        $this->assertEquals(
            [
                FakeCommand::class => 'first.handler',
                OtherFakeCommand::class => 'first.handler'
            ],
            $routing->commandToServiceMapping('bus.a')
        );
        $this->assertEquals(
            [DateTime::class => 'second.handler'],
            $routing->commandToServiceMapping('bus.b')
        );
    }

    public function test_can_bind_to_multiple_buses()
    {
        $builder = new ContainerBuilder();
        $builder
            ->setDefinition('first.handler', new Definition(BasicHandler::class))
            ->addTag('tactician.handler', ['auto' => true, 'bus' => 'bus.a'])
            ->addTag('tactician.handler', ['auto' => true, 'bus' => 'bus.b']);

        $routing = (new TypeHintMapping())->build($builder, new Routing(['bus.a', 'bus.b']));

        $expected = [
            FakeCommand::class => 'first.handler',
            OtherFakeCommand::class => 'first.handler',
        ];

        $this->assertEquals($expected, $routing->commandToServiceMapping('bus.a'));
        $this->assertEquals($expected, $routing->commandToServiceMapping('bus.b'));
    }

    public function test_will_error_when_given_invalid_bus()
    {
        $this->expectException(InvalidCommandBusId::class);

        $builder = new ContainerBuilder();
        $builder
            ->setDefinition('first.handler', new Definition(BasicHandler::class))
            ->addTag('tactician.handler', ['auto' => true, 'bus' => 'bus.does.not.exist.mwhahahaha']);

        (new TypeHintMapping())->build($builder, new Routing(['bus.a', 'bus.b']));
    }
}

class BasicHandler
{
    public function handle(FakeCommand $command)

The parameter $command is not used and could be removed.

    {
    }

    public function run(OtherFakeCommand $command)

The parameter $command is not used and could be removed.

    {
    }

    public function notACommand(FakeCommand $cmdA, OtherFakeCommand $cmdB)

The parameter $cmdA is not used and could be removed.

The parameter $cmdB is not used and could be removed.

    {
    }
}

class DateTimeHandler
{
    public function handle(DateTime $command)

The parameter $command is not used and could be removed.

    {
    }
}

class ScalarHandler
{
    public function handle(string $someString)

The parameter $someString is not used and could be removed.

    {
    }

    public function execute(int $foobar)

The parameter $foobar is not used and could be removed.

    {
    }

    public function that(callable $thing)

The parameter $thing is not used and could be removed.

    {
    }
}

class NoTypehintHandler
{
    public function handle($foo)

The parameter $foo is not used and could be removed.

    {
    }
}

class InvokeHandler
{
    public function __invoke(FakeCommand $command)
    {
    }
}


class ProtectedMethodHandler
{
    protected function handle(FakeCommand $command)

The parameter $command is not used and could be removed.

    {
    }

    private function execute(OtherFakeCommand $command)

This method is not used, and could be removed.

The parameter $command is not used and could be removed.

    {
    }
}