Spiral\Tests\Queue\Core\QueueInjectorTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	testBadArgumentTypeException()	0	8	1
A	testGetByIncorrectContext()	0	9	1
A	createInjector()	0	45	2
A	testGetByContext()	0	8	1

<?php

namespace Spiral\Tests\Queue\Core;

use Mockery as m;
use ReflectionClass;
use RuntimeException;
use Spiral\Core\Exception\Container\NotFoundException;
use Spiral\Core\FactoryInterface;
use Spiral\Queue\Config\QueueConfig;
use Spiral\Queue\Core\QueueInjector;
use Spiral\Queue\QueueInterface;
use Spiral\Queue\QueueManager;
use Spiral\Tests\Queue\Core\Stub\TestQueueClass;
use Spiral\Tests\Queue\TestCase;

final class QueueInjectorTest extends TestCase
{
    private ?QueueInterface $defaultQueue = null;

    public function testGetByContext(): void
    {
        $injector = $this->createInjector();
        $reflection = new ReflectionClass(TestQueueClass::class);

        $result = $injector->createInjection($reflection, 'test');

        $this->assertInstanceOf(TestQueueClass::class, $result);
    }

    public function testGetByIncorrectContext(): void
    {
        $injector = $this->createInjector();
        $reflection = new ReflectionClass(QueueInterface::class);

        $result = $injector->createInjection($reflection, 'userQueue');

        // The default connection should be returned
        $this->assertSame($this->defaultQueue, $result);
    }

    public function testBadArgumentTypeException(): void
    {
        $injector = $this->createInjector();
        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage('The queue obtained by the context');

        $reflection = new ReflectionClass(TestQueueClass::class);
        $injector->createInjection($reflection, 'queue');
    }

    private function createInjector(): QueueInjector
    {
        $this->defaultQueue = m::mock(QueueInterface::class);
        $config = new QueueConfig([
            'default' => 'sync',
            'aliases' => [
                'mail-queue' => 'roadrunner',
                'rating-queue' => 'sync',
                'queue' => 'sync',
                'test' => 'test',
            ],
            'driverAliases' => [],
            'connections' => [
                'sync' => [
                    'driver' => 'sync',
                ],
                'test' => [
                    'driver' => 'test',
                ],
                'roadrunner' => [
                    'driver' => 'roadrunner',
                    'default' => 'local',
                    'pipelines' => [
                        'local' => [
                            'connector' => m::mock(QueueInterface::class),
                            'consume' => true,
                        ],
                    ],
                ],
            ],
        ]);
        $factory = m::mock(FactoryInterface::class);
        $factory->shouldReceive('make')->andReturnUsing(function (string $name): QueueInterface {

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

            $result = [
                    'sync' => $this->defaultQueue,
                    'test' => new TestQueueClass(),
                ][$name] ?? null;
            if ($result === null) {
                throw new NotFoundException();
            }
            return $result;
        });
        $manager = new QueueManager($config, $factory);

$factory of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type Spiral\Core\FactoryInterface expected by parameter $factory of Spiral\Queue\QueueManager::__construct().

        return new QueueInjector($manager, $config);

The call to Spiral\Queue\Core\QueueInjector::__construct() has too many arguments starting with $config.

    }
}