SonataNotificationExtensionTest::testRabbitMQMonitoringProviders() - Code Metrics - Inspection of "Close issue #182" - sonata-project/SonataNotificationBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 3.x (#336)

unknown

created 2018-06-29 15:03 UTC

testRabbitMQMonitoringProviders() A

↳ Parent: SonataNotificationExtensionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	27
rs	9.488
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\NotificationBundle\Tests\DependencyInjection;

use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
use Doctrine\Bundle\DoctrineBundle\Registry;
use PHPUnit\Framework\TestCase;
use Sonata\NotificationBundle\DependencyInjection\Compiler\NotificationCompilerPass;
use Sonata\NotificationBundle\DependencyInjection\SonataNotificationExtension;
use Sonata\NotificationBundle\SonataNotificationBundle;
use Symfony\Bridge\Monolog\Logger;
use Symfony\Bundle\MonologBundle\MonologBundle;
use Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;

class SonataNotificationExtensionTest extends TestCase
{
    /**
     * @var ContainerBuilder
     */
    private $container;

    protected function tearDown()
    {
        unset($this->container);
    }

    public function testEmptyConfig()
    {
        $container = $this->getContainerBuilder([
            'MonologBundle' => MonologBundle::class,
            'SwiftmailerBundle' => SwiftmailerBundle::class,
        ]);
        $extension = new SonataNotificationExtension();
        $extension->load([], $container);

        $this->assertAlias('sonata.notification.backend.runtime', 'sonata.notification.backend');
        $this->assertHasDefinition('sonata.notification.consumer.swift_mailer');
        $this->assertHasDefinition('sonata.notification.consumer.logger');
        $this->assertParameter('sonata.notification.backend.runtime', 'sonata.notification.backend');

        $container->compile();
    }

    public function testDoNotRegisterDefaultConsumers()
    {
        $container = $this->getContainerBuilder();
        $extension = new SonataNotificationExtension();
        $extension->load([
            [
                'consumers' => [
                    'register_default' => false,
                ],
            ],
        ], $container);

        $this->assertHasNoDefinition('sonata.notification.consumer.swift_mailer');
        $this->assertHasNoDefinition('sonata.notification.consumer.logger');
        $this->assertHasNoDefinition('sonata.notification.manager.message.default');
        $this->assertHasNoDefinition('sonata.notification.erroneous_messages_selector');
        $this->assertHasNoDefinition('sonata.notification.event.doctrine_optimize');
        $this->assertHasNoDefinition('sonata.notification.event.doctrine_backend_optimize');

        $this->assertParameter([], 'sonata.notification.event.iteration_listeners');

        $container->compile();
    }

    public function testDoctrineBackendNoConfig()
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Please configure the sonata_notification.backends.doctrine section');

        $container = $this->getContainerBuilder([
            'DoctrineBundle' => DoctrineBundle::class,
        ]);
        $extension = new SonataNotificationExtension();

        $extension->load([
            [
                'backend' => 'sonata.notification.backend.doctrine',
            ],
        ], $container);
    }

    public function testDoctrineBackend()
    {
        $container = $this->getContainerBuilder([
            'DoctrineBundle' => DoctrineBundle::class,
        ]);
        $extension = new SonataNotificationExtension();
        $extension->load([
            [
                'backend' => 'sonata.notification.backend.doctrine',
                'backends' => [
                    'doctrine' => null,
                ],
                'consumers' => [
                    'register_default' => false,
                ],
            ],
        ], $container);

        $this->assertHasDefinition('sonata.notification.manager.message.default');
        $this->assertHasDefinition('sonata.notification.erroneous_messages_selector');
        $this->assertHasDefinition('sonata.notification.event.doctrine_optimize');
        $this->assertHasDefinition('sonata.notification.event.doctrine_backend_optimize');

        $this->assertParameter(
            ['sonata.notification.event.doctrine_backend_optimize'],
            'sonata.notification.event.iteration_listeners'
        );

        $container->compile();
    }

    public function testRabbitMQBackendNoConfig()
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Please configure the sonata_notification.backends.rabbitmq section');

        $container = $this->getContainerBuilder();
        $extension = new SonataNotificationExtension();

        $extension->load([
            [
                'backend' => 'sonata.notification.backend.rabbitmq',
            ],
        ], $container);
    }

    public function testRabbitMQBackend()
    {
        $container = $this->getContainerBuilder();
        $extension = new SonataNotificationExtension();
        $extension->load([
            [
                'backend' => 'sonata.notification.backend.rabbitmq',
                'backends' => [
                    'rabbitmq' => [
                        'exchange' => 'logs',
                    ],
                ],
                'consumers' => [
                    'register_default' => false,
                ],
            ],
        ], $container);

        $this->assertHasNoDefinition('sonata.notification.manager.message.default');
        $this->assertHasNoDefinition('sonata.notification.erroneous_messages_selector');
        $this->assertHasNoDefinition('sonata.notification.event.doctrine_optimize');
        $this->assertHasNoDefinition('sonata.notification.event.doctrine_backend_optimize');

        $this->assertParameter([], 'sonata.notification.event.iteration_listeners');

        $container->compile();
    }

    public function testRabbitMQMonitoringProviders()
    {
        $this->expectException(ServiceNotFoundException::class);
        $this->expectExceptionMessage('The service "sonata.notification.backend.rabbitmq" has a dependency on a non-existent service "httplug.client"');

        $container = $this->getContainerBuilder();
        $bundles = $container->getParameter('kernel.bundles');
        $bundles['HttplugBundle'] = 'Http\HttplugBundle\HttplugBundle';
        $container->setParameter('kernel.bundles', $bundles);
        $extension = new SonataNotificationExtension();
        $extension->load([
            [
                'backend' => 'sonata.notification.backend.rabbitmq',
                'backends' => [
                    'rabbitmq' => [
                        'exchange' => 'logs',
                    ],
                ],
            ],
        ], $container);

        // NEXT_MAJOR: remove this assert
        $this->assertHasDefinition('sonata.notification.rabbitmq.queue_status.guzzle_provider');
        $this->assertHasDefinition('sonata.notification.rabbitmq.queue_status.http_provider');

        $container->compile();
    }

    private function getContainerBuilder(array $bundles = [])
    {
        $container = new ContainerBuilder();

        $containerBundles = array_merge(
            ['SonataNotificationBundle' => SonataNotificationBundle::class], $bundles
        );
        $container->setParameter('kernel.bundles', $containerBundles);

        $container->addCompilerPass(new NotificationCompilerPass());

        if (isset($containerBundles['MonologBundle'])) {
            $container->register('logger')
                ->setClass(Logger::class)
                ->setPublic(true);
        }
        if (isset($containerBundles['SwiftmailerBundle'])) {
            $container->register('mailer')
                ->setClass(\Swift_Mailer::class)
                ->setPublic(true);
        }
        if (isset($containerBundles['DoctrineBundle'])) {
            $container->register('doctrine')
                ->setClass(Registry::class)
                ->setPublic(true);
        }

        return $this->container = $container;
    }

    private function assertAlias($alias, $service)
    {
        $this->assertSame(
            $alias, (string) $this->container->getAlias($service), sprintf('%s alias is correct', $service)
        );
    }

    private function assertParameter($expectedValue, $name)
    {
        $this->assertSame(
            $expectedValue, $this->container->getParameter($name), sprintf('%s parameter is correct', $name)
        );
    }

    private function assertHasDefinition($definition)
    {
        $this->assertTrue(
            $this->container->hasDefinition($definition) ? true : $this->container->hasAlias($definition)
        );
    }

    private function assertHasNoDefinition($service)
    {
        $this->assertFalse(
            $this->container->hasDefinition($service) ? true : $this->container->hasAlias($service)
        );
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sonata Project package.
5			*
6			* (c) Thomas Rabaix <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sonata\NotificationBundle\Tests\DependencyInjection;
13
14			use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
15			use Doctrine\Bundle\DoctrineBundle\Registry;
16			use PHPUnit\Framework\TestCase;
17			use Sonata\NotificationBundle\DependencyInjection\Compiler\NotificationCompilerPass;
18			use Sonata\NotificationBundle\DependencyInjection\SonataNotificationExtension;
19			use Sonata\NotificationBundle\SonataNotificationBundle;
20			use Symfony\Bridge\Monolog\Logger;
21			use Symfony\Bundle\MonologBundle\MonologBundle;
22			use Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle;
23			use Symfony\Component\DependencyInjection\ContainerBuilder;
24			use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
25
26			class SonataNotificationExtensionTest extends TestCase
27			{
28			/**
29			* @var ContainerBuilder
30			*/
31			private $container;
32
33			protected function tearDown()
34			{
35			unset($this->container);
36			}
37
38			public function testEmptyConfig()
39			{
40			$container = $this->getContainerBuilder([
41			'MonologBundle' => MonologBundle::class,
42			'SwiftmailerBundle' => SwiftmailerBundle::class,
43			]);
44			$extension = new SonataNotificationExtension();
45			$extension->load([], $container);
46
47			$this->assertAlias('sonata.notification.backend.runtime', 'sonata.notification.backend');
48			$this->assertHasDefinition('sonata.notification.consumer.swift_mailer');
49			$this->assertHasDefinition('sonata.notification.consumer.logger');
50			$this->assertParameter('sonata.notification.backend.runtime', 'sonata.notification.backend');
51
52			$container->compile();
53			}
54
55			public function testDoNotRegisterDefaultConsumers()
56			{
57			$container = $this->getContainerBuilder();
58			$extension = new SonataNotificationExtension();
59			$extension->load([
60			[
61			'consumers' => [
62			'register_default' => false,
63			],
64			],
65			], $container);
66
67			$this->assertHasNoDefinition('sonata.notification.consumer.swift_mailer');
68			$this->assertHasNoDefinition('sonata.notification.consumer.logger');
69			$this->assertHasNoDefinition('sonata.notification.manager.message.default');
70			$this->assertHasNoDefinition('sonata.notification.erroneous_messages_selector');
71			$this->assertHasNoDefinition('sonata.notification.event.doctrine_optimize');
72			$this->assertHasNoDefinition('sonata.notification.event.doctrine_backend_optimize');
73
74			$this->assertParameter([], 'sonata.notification.event.iteration_listeners');
75
76			$container->compile();
77			}
78
79			public function testDoctrineBackendNoConfig()
80			{
81			$this->expectException(\RuntimeException::class);
82			$this->expectExceptionMessage('Please configure the sonata_notification.backends.doctrine section');
83
84			$container = $this->getContainerBuilder([
85			'DoctrineBundle' => DoctrineBundle::class,
86			]);
87			$extension = new SonataNotificationExtension();
88
89			$extension->load([
90			[
91			'backend' => 'sonata.notification.backend.doctrine',
92			],
93			], $container);
94			}
95
96			public function testDoctrineBackend()
97			{
98			$container = $this->getContainerBuilder([
99			'DoctrineBundle' => DoctrineBundle::class,
100			]);
101			$extension = new SonataNotificationExtension();
102			$extension->load([
103			[
104			'backend' => 'sonata.notification.backend.doctrine',
105			'backends' => [
106			'doctrine' => null,
107			],
108			'consumers' => [
109			'register_default' => false,
110			],
111			],
112			], $container);
113
114			$this->assertHasDefinition('sonata.notification.manager.message.default');
115			$this->assertHasDefinition('sonata.notification.erroneous_messages_selector');
116			$this->assertHasDefinition('sonata.notification.event.doctrine_optimize');
117			$this->assertHasDefinition('sonata.notification.event.doctrine_backend_optimize');
118
119			$this->assertParameter(
120			['sonata.notification.event.doctrine_backend_optimize'],
121			'sonata.notification.event.iteration_listeners'
122			);
123
124			$container->compile();
125			}
126
127			public function testRabbitMQBackendNoConfig()
128			{
129			$this->expectException(\RuntimeException::class);
130			$this->expectExceptionMessage('Please configure the sonata_notification.backends.rabbitmq section');
131
132			$container = $this->getContainerBuilder();
133			$extension = new SonataNotificationExtension();
134
135			$extension->load([
136			[
137			'backend' => 'sonata.notification.backend.rabbitmq',
138			],
139			], $container);
140			}
141
142			public function testRabbitMQBackend()
143			{
144			$container = $this->getContainerBuilder();
145			$extension = new SonataNotificationExtension();
146			$extension->load([
147			[
148			'backend' => 'sonata.notification.backend.rabbitmq',
149			'backends' => [
150			'rabbitmq' => [
151			'exchange' => 'logs',
152			],
153			],
154			'consumers' => [
155			'register_default' => false,
156			],
157			],
158			], $container);
159
160			$this->assertHasNoDefinition('sonata.notification.manager.message.default');
161			$this->assertHasNoDefinition('sonata.notification.erroneous_messages_selector');
162			$this->assertHasNoDefinition('sonata.notification.event.doctrine_optimize');
163			$this->assertHasNoDefinition('sonata.notification.event.doctrine_backend_optimize');
164
165			$this->assertParameter([], 'sonata.notification.event.iteration_listeners');
166
167			$container->compile();
168			}
169
170			public function testRabbitMQMonitoringProviders()
171			{
172			$this->expectException(ServiceNotFoundException::class);
173			$this->expectExceptionMessage('The service "sonata.notification.backend.rabbitmq" has a dependency on a non-existent service "httplug.client"');
174
175			$container = $this->getContainerBuilder();
176			$bundles = $container->getParameter('kernel.bundles');
177			$bundles['HttplugBundle'] = 'Http\HttplugBundle\HttplugBundle';
178			$container->setParameter('kernel.bundles', $bundles);
179			$extension = new SonataNotificationExtension();
180			$extension->load([
181			[
182			'backend' => 'sonata.notification.backend.rabbitmq',
183			'backends' => [
184			'rabbitmq' => [
185			'exchange' => 'logs',
186			],
187			],
188			],
189			], $container);
190
191			// NEXT_MAJOR: remove this assert
192			$this->assertHasDefinition('sonata.notification.rabbitmq.queue_status.guzzle_provider');
193			$this->assertHasDefinition('sonata.notification.rabbitmq.queue_status.http_provider');
194
195			$container->compile();
196			}
197
198			private function getContainerBuilder(array $bundles = [])
199			{
200			$container = new ContainerBuilder();
201
202			$containerBundles = array_merge(
203			['SonataNotificationBundle' => SonataNotificationBundle::class], $bundles
204			);
205			$container->setParameter('kernel.bundles', $containerBundles);
206
207			$container->addCompilerPass(new NotificationCompilerPass());
208
209			if (isset($containerBundles['MonologBundle'])) {
210			$container->register('logger')
211			->setClass(Logger::class)
212			->setPublic(true);
213			}
214			if (isset($containerBundles['SwiftmailerBundle'])) {
215			$container->register('mailer')
216			->setClass(\Swift_Mailer::class)
217			->setPublic(true);
218			}
219			if (isset($containerBundles['DoctrineBundle'])) {
220			$container->register('doctrine')
221			->setClass(Registry::class)
222			->setPublic(true);
223			}
224
225			return $this->container = $container;
226			}
227
228			private function assertAlias($alias, $service)
229			{
230			$this->assertSame(
231			$alias, (string) $this->container->getAlias($service), sprintf('%s alias is correct', $service)
232			);
233			}
234
235			private function assertParameter($expectedValue, $name)
236			{
237			$this->assertSame(
238			$expectedValue, $this->container->getParameter($name), sprintf('%s parameter is correct', $name)
239			);
240			}
241
242			private function assertHasDefinition($definition)
243			{
244			$this->assertTrue(
245			$this->container->hasDefinition($definition) ? true : $this->container->hasAlias($definition)
246			);
247			}
248
249			private function assertHasNoDefinition($service)
250			{
251			$this->assertFalse(
252			$this->container->hasDefinition($service) ? true : $this->container->hasAlias($service)
253			);
254			}
255			}
256

sonata-project / SonataNotificationBundle

Pull Request — 3.x (#336)

testRabbitMQMonitoringProviders() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like