Spiral\Tests\Core\InjectableTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	testInjectorOuterBinding()	0	8	1
A	testInjector()	0	16	1
A	testInvalidRuntimeInjector()	0	13	1
A	testInvalidInjection()	0	13	1
A	testGetInjectors()	0	16	1
A	testInjectorWithContext()	0	16	1
A	methodInjection()	0	2	1
A	testMissingInjector()	0	7	1
A	testInvalidInjector()	0	11	1
A	testInvalidInjectorBinding()	0	9	1
A	testInjectorForMethod()	0	19	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Tests\Core;

use Mockery as m;
use PHPUnit\Framework\TestCase;
use ReflectionClass;
use ReflectionMethod;
use Spiral\Core\ConfigsInterface;
use Spiral\Core\Container;
use Spiral\Core\Exception\Container\AutowireException;
use Spiral\Core\Exception\Container\InjectionException;
use Spiral\Tests\Core\Fixtures\InvalidInjector;
use Spiral\Tests\Core\Fixtures\SampleClass;
use Spiral\Tests\Core\Fixtures\TestConfig;

class InjectableTest extends TestCase
{
    public function testMissingInjector(): void
    {
        $this->expectExceptionMessage("Undefined class or binding 'Spiral\Core\ConfigsInterface'");
        $this->expectException(AutowireException::class);

        $container = new Container();
        $container->get(TestConfig::class);
    }

    public function testInvalidInjector(): void
    {
        $excepted = "Class 'Spiral\Tests\Core\Fixtures\InvalidInjector' must be an " .
                    "instance of InjectorInterface for 'Spiral\Tests\Core\Fixtures\TestConfig'";
        $this->expectException(InjectionException::class);
        $this->expectExceptionMessage($excepted);

        $container = new Container();

        $container->bindInjector(TestConfig::class, InvalidInjector::class);
        $container->get(TestConfig::class);
    }

    public function testInvalidInjectorBinding(): void
    {
        $this->expectException(AutowireException::class);
        $this->expectExceptionMessage("Undefined class or binding 'invalid-injector'");

        $container = new Container();

        $container->bindInjector(TestConfig::class, 'invalid-injector');
        $container->get(TestConfig::class);
    }

    public function testInvalidRuntimeInjector(): void
    {
        $excepted = "Class 'Spiral\Tests\Core\Fixtures\InvalidInjector' must be an " .
            "instance of InjectorInterface for 'Spiral\Tests\Core\Fixtures\TestConfig'";
        $this->expectException(InjectionException::class);
        $this->expectExceptionMessage($excepted);

        $container = new Container();

        $container->bindInjector(TestConfig::class, 'invalid-injector');
        $container->bind('invalid-injector', new InvalidInjector());

new Spiral\Tests\Core\Fixtures\InvalidInjector() of type Spiral\Tests\Core\Fixtures\InvalidInjector is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $container->get(TestConfig::class);
    }

    public function testGetInjectors(): void
    {
        $container = new Container();

        $container->bindInjector(TestConfig::class, 'invalid-injector');

        $injectors = $container->getInjectors();

        $this->assertNotEmpty($injectors);
        $this->assertArrayHasKey(TestConfig::class, $injectors);
        $this->assertSame('invalid-injector', $injectors[TestConfig::class]);

        $container->removeInjector(TestConfig::class);
        $injectors = $container->getInjectors();

        $this->assertEmpty($injectors);
    }

    public function testInjectorOuterBinding(): void
    {
        $this->expectException(AutowireException::class);
        $this->expectExceptionMessage("Undefined class or binding 'invalid-configurator'");
        $container = new Container();
        $container->bind(ConfigsInterface::class, 'invalid-configurator');

        $container->get(TestConfig::class);
    }

    public function testInvalidInjection(): void
    {
        $this->expectException(InjectionException::class);
        $this->expectExceptionMessage("Invalid injection response for 'Spiral\Tests\Core\Fixtures\TestConfig'");

        $container = new Container();

        $configurator = m::mock(ConfigsInterface::class);
        $container->bind(ConfigsInterface::class, $configurator);

$configurator of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $configurator->shouldReceive('createInjection')->andReturn(new SampleClass());

        $container->get(TestConfig::class);
    }

    public function testInjector(): void
    {
        $configurator = m::mock(ConfigsInterface::class);
        $expected = new TestConfig();

        $container = new Container();
        $container->bind(ConfigsInterface::class, $configurator);

$configurator of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $configurator->shouldReceive('createInjection')
            ->with(m::on(static function (ReflectionClass $r) {
                return $r->getName() === TestConfig::class;
            }), null)
            ->andReturn($expected)
        ;

        $this->assertSame($expected, $container->get(TestConfig::class));
    }

    public function testInjectorWithContext(): void
    {
        $configurator = m::mock(ConfigsInterface::class);
        $expected = new TestConfig();

        $container = new Container();
        $container->bind(ConfigsInterface::class, $configurator);

$configurator of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $configurator->shouldReceive('createInjection')
            ->with(m::on(static function (ReflectionClass $r) {
                return $r->getName() === TestConfig::class;
            }), 'context')
            ->andReturn($expected)
        ;

        $this->assertSame($expected, $container->get(TestConfig::class, 'context'));
    }

    public function testInjectorForMethod(): void
    {
        $configurator = m::mock(ConfigsInterface::class);
        $expected = new TestConfig();

        $container = new Container();
        $container->bind(ConfigsInterface::class, $configurator);

$configurator of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $configurator->shouldReceive('createInjection')
            ->with(m::on(static function (ReflectionClass $r) {
                return $r->getName() === TestConfig::class;
            }), 'contextArgument')
            ->andReturn($expected)
        ;

        $arguments = $container->resolveArguments(new ReflectionMethod($this, 'methodInjection'));

        $this->assertCount(1, $arguments);
        $this->assertSame($expected, $arguments[0]);
    }

    /**
     * @param TestConfig $contextArgument
     */
    private function methodInjection(TestConfig $contextArgument): void

The method methodInjection() is not used, and could be removed.

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

    {
    }
}