ReceiverLoaderTest::test_unknown_destination_config() - Code Metrics - Inspection of "Add receiver for resetting the services" - b2pweb/bdf-queue-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c2b6eb...8c3bb9 )

by Sébastien

created 2022-06-01 15:21 UTC

test_unknown_destination_config() A

↳ Parent: ReceiverLoaderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	8
rs	10

<?php

namespace Bdf\QueueBundle\Tests\Consumption;

use Bdf\Instantiator\Instantiator;
use Bdf\Instantiator\InstantiatorInterface;
use Bdf\Queue\Consumer\Receiver\Builder\ReceiverFactory;
use Bdf\Queue\Consumer\Receiver\MemoryLimiterReceiver;
use Bdf\Queue\Consumer\Receiver\MessageCountLimiterReceiver;
use Bdf\Queue\Consumer\Receiver\MessageLoggerReceiver;
use Bdf\Queue\Consumer\Receiver\NoFailureReceiver;
use Bdf\Queue\Consumer\Receiver\ProcessorReceiver;
use Bdf\Queue\Consumer\Receiver\RateLimiterReceiver;
use Bdf\Queue\Consumer\Receiver\RetryMessageReceiver;
use Bdf\QueueBundle\Consumption\Receiver\ResetServices;
use Bdf\QueueBundle\Consumption\Receiver\ResetServicesFactory;
use Bdf\QueueBundle\Consumption\ReceiverLoader;
use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;
use Symfony\Component\HttpKernel\DependencyInjection\ServicesResetter;

/**
 *
 */
class ReceiverLoaderTest extends TestCase
{
    private $container;

    public function setUp(): void
    {
        parent::setUp();

        $this->container = new Container();
        $this->container->set(InstantiatorInterface::class, new Instantiator($this->container));
    }

    private function getLoader(array $configuration = []): ReceiverLoader
    {
        $resetFactory = new ResetServicesFactory();
        $factory = new ReceiverFactory($this->container);
        $factory->addFactory($resetFactory->getReceiverNames(), [$resetFactory, 'create']);

        return new ReceiverLoader($this->container, $configuration, $factory);
    }

    /**
     *
     */
    public function test_unknown_destination_config()
    {
        $loader = $this->getLoader();
        $builder = $loader->load('foo');

        $chain = MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;

        $this->assertEquals($chain, (string) $builder->build());
    }

    /**
     *
     */
    public function test_full_config()
    {
        $loader = $this->getLoader([
            'foo' => [
                'retry' => '1',
                'limit' => '2',
                'no_failure' => true,
                'stop_when_empty' => '',
                'max' => '1',
                'memory' => '128',
                'no_reset' => true,
            ]
        ]);
        $builder = $loader->load('foo');

        $chain = MemoryLimiterReceiver::class.'->'.MessageCountLimiterReceiver::class.'->'.NoFailureReceiver::class.'->'
            .RateLimiterReceiver::class.'->'.RetryMessageReceiver::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;

        $this->assertEquals($chain, (string) $builder->build());
    }

    /**
     *
     */
    public function test_without_service_resetter_config()
    {
        $loader = $this->getLoader([
            'foo' => [
                'retry' => '1',
                'limit' => '2',
                'no_failure' => true,
                'stop_when_empty' => '',
                'max' => '1',
                'memory' => '128',
            ]
        ]);
        $builder = $loader->load('foo');

        $chain = MemoryLimiterReceiver::class.'->'.MessageCountLimiterReceiver::class.'->'.NoFailureReceiver::class.'->'
            .RateLimiterReceiver::class.'->'.RetryMessageReceiver::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;

        $this->assertEquals($chain, (string) $builder->build());
    }

    /**
     *
     */
    public function test_default_config()
    {
        $this->container->set('services_resetter', $this->createMock(ServicesResetter::class));

        $loader = $this->getLoader([
            'foo' => [
            ]
        ]);
        $builder = $loader->load('foo');

        $chain = ResetServices::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;

        $this->assertEquals($chain, (string)$builder->build());
    }

    /**
     *
     */
    public function test_full_order_config()
    {
        $this->container->set('services_resetter', $this->createMock(ServicesResetter::class));

        $loader = $this->getLoader([
            'foo' => [
                'retry' => '1',
                'limit' => '2',
                'no_failure' => true,
                'stop_when_empty' => '',
                'max' => '1',
                'memory' => '128',
            ]
        ]);
        $builder = $loader->load('foo');

        $chain = ResetServices::class.'->'.MemoryLimiterReceiver::class.'->'.MessageCountLimiterReceiver::class.'->'.NoFailureReceiver::class.'->'
            .RateLimiterReceiver::class.'->'.RetryMessageReceiver::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;

        $this->assertEquals($chain, (string)$builder->build());
    }
}


class Container implements ContainerInterface
{
    private $service;

    public function __construct(array $service = [])
    {
        $this->service = $service;
    }

    public function set(string $id, $service): void
    {
        $this->service[$id] = $service;
    }

    public function get(string $id)
    {
        return $this->service[$id];
    }

    public function has(string $id): bool
    {
        return isset($this->service[$id]);
    }
}

1			<?php
2
3			namespace Bdf\QueueBundle\Tests\Consumption;
4
5			use Bdf\Instantiator\Instantiator;
6			use Bdf\Instantiator\InstantiatorInterface;
7			use Bdf\Queue\Consumer\Receiver\Builder\ReceiverFactory;
8			use Bdf\Queue\Consumer\Receiver\MemoryLimiterReceiver;
9			use Bdf\Queue\Consumer\Receiver\MessageCountLimiterReceiver;
10			use Bdf\Queue\Consumer\Receiver\MessageLoggerReceiver;
11			use Bdf\Queue\Consumer\Receiver\NoFailureReceiver;
12			use Bdf\Queue\Consumer\Receiver\ProcessorReceiver;
13			use Bdf\Queue\Consumer\Receiver\RateLimiterReceiver;
14			use Bdf\Queue\Consumer\Receiver\RetryMessageReceiver;
15			use Bdf\QueueBundle\Consumption\Receiver\ResetServices;
16			use Bdf\QueueBundle\Consumption\Receiver\ResetServicesFactory;
17			use Bdf\QueueBundle\Consumption\ReceiverLoader;
18			use PHPUnit\Framework\TestCase;
19			use Psr\Container\ContainerInterface;
20			use Symfony\Component\HttpKernel\DependencyInjection\ServicesResetter;
21
22			/**
23			*
24			*/
25			class ReceiverLoaderTest extends TestCase
26			{
27			private $container;
28
29			public function setUp(): void
30			{
31			parent::setUp();
32
33			$this->container = new Container();
34			$this->container->set(InstantiatorInterface::class, new Instantiator($this->container));
35			}
36
37			private function getLoader(array $configuration = []): ReceiverLoader
38			{
39			$resetFactory = new ResetServicesFactory();
40			$factory = new ReceiverFactory($this->container);
41			$factory->addFactory($resetFactory->getReceiverNames(), [$resetFactory, 'create']);
42
43			return new ReceiverLoader($this->container, $configuration, $factory);
44			}
45
46			/**
47			*
48			*/
49			public function test_unknown_destination_config()
50			{
51			$loader = $this->getLoader();
52			$builder = $loader->load('foo');
53
54			$chain = MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;
55
56			$this->assertEquals($chain, (string) $builder->build());
57			}
58
59			/**
60			*
61			*/
62			public function test_full_config()
63			{
64			$loader = $this->getLoader([
65			'foo' => [
66			'retry' => '1',
67			'limit' => '2',
68			'no_failure' => true,
69			'stop_when_empty' => '',
70			'max' => '1',
71			'memory' => '128',
72			'no_reset' => true,
73			]
74			]);
75			$builder = $loader->load('foo');
76
77			$chain = MemoryLimiterReceiver::class.'->'.MessageCountLimiterReceiver::class.'->'.NoFailureReceiver::class.'->'
78			.RateLimiterReceiver::class.'->'.RetryMessageReceiver::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;
79
80			$this->assertEquals($chain, (string) $builder->build());
81			}
82
83			/**
84			*
85			*/
86			public function test_without_service_resetter_config()
87			{
88			$loader = $this->getLoader([
89			'foo' => [
90			'retry' => '1',
91			'limit' => '2',
92			'no_failure' => true,
93			'stop_when_empty' => '',
94			'max' => '1',
95			'memory' => '128',
96			]
97			]);
98			$builder = $loader->load('foo');
99
100			$chain = MemoryLimiterReceiver::class.'->'.MessageCountLimiterReceiver::class.'->'.NoFailureReceiver::class.'->'
101			.RateLimiterReceiver::class.'->'.RetryMessageReceiver::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;
102
103			$this->assertEquals($chain, (string) $builder->build());
104			}
105
106			/**
107			*
108			*/
109			public function test_default_config()
110			{
111			$this->container->set('services_resetter', $this->createMock(ServicesResetter::class));
112
113			$loader = $this->getLoader([
114			'foo' => [
115			]
116			]);
117			$builder = $loader->load('foo');
118
119			$chain = ResetServices::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;
120
121			$this->assertEquals($chain, (string)$builder->build());
122			}
123
124			/**
125			*
126			*/
127			public function test_full_order_config()
128			{
129			$this->container->set('services_resetter', $this->createMock(ServicesResetter::class));
130
131			$loader = $this->getLoader([
132			'foo' => [
133			'retry' => '1',
134			'limit' => '2',
135			'no_failure' => true,
136			'stop_when_empty' => '',
137			'max' => '1',
138			'memory' => '128',
139			]
140			]);
141			$builder = $loader->load('foo');
142
143			$chain = ResetServices::class.'->'.MemoryLimiterReceiver::class.'->'.MessageCountLimiterReceiver::class.'->'.NoFailureReceiver::class.'->'
144			.RateLimiterReceiver::class.'->'.RetryMessageReceiver::class.'->'.MessageLoggerReceiver::class.'->'.ProcessorReceiver::class;
145
146			$this->assertEquals($chain, (string)$builder->build());
147			}
148			}
149
150
151			class Container implements ContainerInterface
152			{
153			private $service;
154
155			public function __construct(array $service = [])
156			{
157			$this->service = $service;
158			}
159
160			public function set(string $id, $service): void
161			{
162			$this->service[$id] = $service;
163			}
164
165			public function get(string $id)
166			{
167			return $this->service[$id];
168			}
169
170			public function has(string $id): bool
171			{
172			return isset($this->service[$id]);
173			}
174			}

b2pweb / bdf-queue-bundle

Push — master ( c2b6eb...8c3bb9 )

test_unknown_destination_config() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like