ConfigurationManagerTest::testGetConfigurationWillThrowConfigurationManagerExceptionForUnknownConnection() - Code Metrics - Inspection of "Feature/0.2.0" - alex-patterson-webdev/laminas-doctrine - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2)

by Alex

created 2021-08-20 17:11 UTC

testGetConfigurationWillThrowConfigurationManagerExceptionForUnknownConnection() A

↳ Parent: ConfigurationManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	10
c	1
b	0
f	0
dl	0
loc	17
rs	9.9332
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace ArpTest\LaminasDoctrine\Service\Configuration;

use Arp\LaminasDoctrine\Config\DoctrineConfig;
use Arp\LaminasDoctrine\Service\Configuration\ConfigurationFactoryInterface;
use Arp\LaminasDoctrine\Service\Configuration\ConfigurationManager;
use Arp\LaminasDoctrine\Service\Configuration\ConfigurationManagerInterface;
use Arp\LaminasDoctrine\Service\Configuration\Exception\ConfigurationFactoryException;
use Arp\LaminasDoctrine\Service\Configuration\Exception\ConfigurationManagerException;
use Doctrine\ORM\Configuration;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @covers  \Arp\LaminasDoctrine\Service\Configuration\ConfigurationManager
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\LaminasDoctrine\Service\Configuration
 */
final class ConfigurationManagerTest extends TestCase
{
    /**
     * @var ConfigurationFactoryInterface&MockObject
     */
    private $configurationFactory;

    /**
     * @var DoctrineConfig&MockObject
     */
    private $doctrineConfig;

    /**
     * Prepare the test case dependencies
     */
    public function setUp(): void
    {
        $this->configurationFactory = $this->createMock(ConfigurationFactoryInterface::class);

        $this->doctrineConfig = $this->createMock(DoctrineConfig::class);
    }

    /**
     * Assert that the configuration manager implements ConfigurationManagerInterface
     */
    public function testImplementsConfigurationManagerInterface(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $this->assertInstanceOf(ConfigurationManagerInterface::class, $manager);
    }

    /**
     * Assert calls to addConfigurationConfig() will proxy to the internal DoctrineConfig instance
     */
    public function testAddConfigurationConfig(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $name = 'FooTestConfiguration';
        $config = [
            'foo' => 123,
        ];

        $this->doctrineConfig->expects($this->once())
            ->method('setConfigurationConfig')
            ->with($name, $config);

        $manager->addConfigurationConfig($name, $config);
    }

    /**
     * Assert that a ConfigurationManagerException is thrown when calling getConfiguration() with a
     * unknown configuration $name
     *
     * @throws ConfigurationManagerException
     */
    public function testGetConfigurationWillThrowConfigurationManagerExceptionForUnknownConnection(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $name = 'Fred';

        $this->doctrineConfig->expects($this->once())
            ->method('hasConfigurationConfig')
            ->with($name)
            ->willReturn(false);

        $this->expectException(ConfigurationManagerException::class);
        $this->expectExceptionMessage(
            sprintf('Unable to find Doctrine Configuration registered with name \'%s\'', $name)
        );

        $manager->getConfiguration($name);
    }

    /**
     * Assert a ConfigurationFactoryException is thrown if getConnection() is unable to create a lazy loaded
     * connection instance from matched configuration
     *
     * @throws ConfigurationManagerException
     */
    public function testGetConfigurationWillThrowConfigurationManagerExceptionIfUnableToLazyLoadConfiguration(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $name = 'Fred';
        $config = [
            'foo' => 123,
        ];

        $this->doctrineConfig->expects($this->once())
            ->method('hasConfigurationConfig')
            ->with($name)
            ->willReturn(true);

        $this->doctrineConfig->expects($this->once())
            ->method('getConfigurationConfig')
            ->with($name)
            ->willReturn($config);

        $exceptionCode = 1234;
        $exceptionMessage = 'This is a test exception message for ' . __FUNCTION__;
        $exception = new ConfigurationFactoryException($exceptionMessage, $exceptionCode);

        $this->configurationFactory->expects($this->once())
            ->method('create')
            ->with($config)
            ->willThrowException($exception);

        $this->expectException(ConfigurationManagerException::class);
        $this->expectExceptionCode($exceptionCode);
        $this->expectExceptionMessage(
            sprintf('Failed to create doctrine configuration \'%s\': %s', $name, $exceptionMessage),
        );

        $manager->getConfiguration($name);
    }

    /**
     * Assert that getConfiguration() will return a lazy loaded Configuration instance if the provided $name is
     * able to be created
     *
     * @throws ConfigurationManagerException
     */
    public function testGetConfigurationWillLazyLoadAndReturnConfigurationFromDoctrineConfig(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $name = 'TestConnectionName';

        /** @var Configuration&MockObject $createdConfiguration */
        $createdConfiguration = $this->createMock(Configuration::class);

        $this->doctrineConfig->expects($this->once())
            ->method('hasConfigurationConfig')
            ->with($name)
            ->willReturn(true);

        $configurationConfig = [
            'foo' => 123,
        ];

        $this->doctrineConfig->expects($this->once())
            ->method('getConfigurationConfig')
            ->willReturn($configurationConfig);

        $this->configurationFactory->expects($this->once())
            ->method('create')
            ->with($configurationConfig)
            ->willReturn($createdConfiguration);

        $this->assertSame($createdConfiguration, $manager->getConfiguration($name));
    }

    /**
     * Assert that an array of configuration can be set when calling setConfiguration() and retrieved by $name
     * when calling getConfiguration($name)
     *
     * @throws ConfigurationManagerException
     */
    public function testSetAndGetConfigurationObjects(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $configs = [
            'fred'  => $this->createMock(Configuration::class),
            'bob'   => $this->createMock(Configuration::class),
            'dick'  => $this->createMock(Configuration::class),
            'harry' => $this->createMock(Configuration::class),
        ];

        $manager->setConfigurations($configs);

        foreach ($configs as $name => $config) {
            $this->assertSame($config, $manager->getConfiguration($name));
        }
    }

    /**
     * Assert that setConfigurations() accepts Connection configuration which is added to the internal DoctrineConfig
     */
    public function testSetAndGetConfigurationArray(): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        $configs = [
            'fred'     => [
                'test' => 123,
            ],
            'bob'      => [
                'test' => 456,
            ],
            'jennifer' => [
                'test' => 456,
            ],
        ];

        $setArgs = [];
        foreach ($configs as $name => $config) {
            $setArgs[] = [$name, $config];
        }

        $this->doctrineConfig->expects($this->exactly(count($setArgs)))
            ->method('setConfigurationConfig')
            ->withConsecutive(...$setArgs);

        $manager->setConfigurations($configs);
    }

    /**
     * Assert has will return $expected bool value if the connection is set in $config or the $doctrineConfig
     *
     * @param bool         $expected
     * @param string       $name
     * @param array<mixed> $configs
     *
     * @dataProvider getHasConfigurationData
     */
    public function testHasConfigurationObject(bool $expected, string $name, array $configs): void
    {
        $manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);

        if (!empty($configs)) {
            $manager->setConfigurations($configs);
        }

        if (!isset($configs[$name])) {
            $this->doctrineConfig->expects($this->once())
                ->method('hasConfigurationConfig')
                ->with($name)
                ->willReturn($expected);
        }

        $this->assertSame($expected, $manager->hasConfiguration($name));
    }

    /**
     * @return array<mixed>
     */
    public function getHasConfigurationData(): array
    {
        return [
            // Found match in config
            [
                true,
                'fred',
                [
                    'fred' => $this->createMock(Configuration::class),
                ],
            ],

            // Missing from both
            [
                false,
                'Kitty',
                [
                    'fred' => $this->createMock(Configuration::class),
                ],
            ],

            // In Doctrine Config
            [
                true,
                'Barney',
                [
                    'fred' => $this->createMock(Configuration::class),
                    'bob'  => $this->createMock(Configuration::class),
                ],
            ],
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ArpTest\LaminasDoctrine\Service\Configuration;
6
7			use Arp\LaminasDoctrine\Config\DoctrineConfig;
8			use Arp\LaminasDoctrine\Service\Configuration\ConfigurationFactoryInterface;
9			use Arp\LaminasDoctrine\Service\Configuration\ConfigurationManager;
10			use Arp\LaminasDoctrine\Service\Configuration\ConfigurationManagerInterface;
11			use Arp\LaminasDoctrine\Service\Configuration\Exception\ConfigurationFactoryException;
12			use Arp\LaminasDoctrine\Service\Configuration\Exception\ConfigurationManagerException;
13			use Doctrine\ORM\Configuration;
14			use PHPUnit\Framework\MockObject\MockObject;
15			use PHPUnit\Framework\TestCase;
16
17			/**
18			* @covers \Arp\LaminasDoctrine\Service\Configuration\ConfigurationManager
19			*
20			* @author Alex Patterson <[email protected]>
21			* @package ArpTest\LaminasDoctrine\Service\Configuration
22			*/
23			final class ConfigurationManagerTest extends TestCase
24			{
25			/**
26			* @var ConfigurationFactoryInterface&MockObject
27			*/
28			private $configurationFactory;
29
30			/**
31			* @var DoctrineConfig&MockObject
32			*/
33			private $doctrineConfig;
34
35			/**
36			* Prepare the test case dependencies
37			*/
38			public function setUp(): void
39			{
40			$this->configurationFactory = $this->createMock(ConfigurationFactoryInterface::class);
41
42			$this->doctrineConfig = $this->createMock(DoctrineConfig::class);
43			}
44
45			/**
46			* Assert that the configuration manager implements ConfigurationManagerInterface
47			*/
48			public function testImplementsConfigurationManagerInterface(): void
49			{
50			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
51
52			$this->assertInstanceOf(ConfigurationManagerInterface::class, $manager);
53			}
54
55			/**
56			* Assert calls to addConfigurationConfig() will proxy to the internal DoctrineConfig instance
57			*/
58			public function testAddConfigurationConfig(): void
59			{
60			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
61
62			$name = 'FooTestConfiguration';
63			$config = [
64			'foo' => 123,
65			];
66
67			$this->doctrineConfig->expects($this->once())
68			->method('setConfigurationConfig')
69			->with($name, $config);
70
71			$manager->addConfigurationConfig($name, $config);
72			}
73
74			/**
75			* Assert that a ConfigurationManagerException is thrown when calling getConfiguration() with a
76			* unknown configuration $name
77			*
78			* @throws ConfigurationManagerException
79			*/
80			public function testGetConfigurationWillThrowConfigurationManagerExceptionForUnknownConnection(): void
81			{
82			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
83
84			$name = 'Fred';
85
86			$this->doctrineConfig->expects($this->once())
87			->method('hasConfigurationConfig')
88			->with($name)
89			->willReturn(false);
90
91			$this->expectException(ConfigurationManagerException::class);
92			$this->expectExceptionMessage(
93			sprintf('Unable to find Doctrine Configuration registered with name \'%s\'', $name)
94			);
95
96			$manager->getConfiguration($name);
97			}
98
99			/**
100			* Assert a ConfigurationFactoryException is thrown if getConnection() is unable to create a lazy loaded
101			* connection instance from matched configuration
102			*
103			* @throws ConfigurationManagerException
104			*/
105			public function testGetConfigurationWillThrowConfigurationManagerExceptionIfUnableToLazyLoadConfiguration(): void
106			{
107			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
108
109			$name = 'Fred';
110			$config = [
111			'foo' => 123,
112			];
113
114			$this->doctrineConfig->expects($this->once())
115			->method('hasConfigurationConfig')
116			->with($name)
117			->willReturn(true);
118
119			$this->doctrineConfig->expects($this->once())
120			->method('getConfigurationConfig')
121			->with($name)
122			->willReturn($config);
123
124			$exceptionCode = 1234;
125			$exceptionMessage = 'This is a test exception message for ' . __FUNCTION__;
126			$exception = new ConfigurationFactoryException($exceptionMessage, $exceptionCode);
127
128			$this->configurationFactory->expects($this->once())
129			->method('create')
130			->with($config)
131			->willThrowException($exception);
132
133			$this->expectException(ConfigurationManagerException::class);
134			$this->expectExceptionCode($exceptionCode);
135			$this->expectExceptionMessage(
136			sprintf('Failed to create doctrine configuration \'%s\': %s', $name, $exceptionMessage),
137			);
138
139			$manager->getConfiguration($name);
140			}
141
142			/**
143			* Assert that getConfiguration() will return a lazy loaded Configuration instance if the provided $name is
144			* able to be created
145			*
146			* @throws ConfigurationManagerException
147			*/
148			public function testGetConfigurationWillLazyLoadAndReturnConfigurationFromDoctrineConfig(): void
149			{
150			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
151
152			$name = 'TestConnectionName';
153
154			/** @var Configuration&MockObject $createdConfiguration */
155			$createdConfiguration = $this->createMock(Configuration::class);
156
157			$this->doctrineConfig->expects($this->once())
158			->method('hasConfigurationConfig')
159			->with($name)
160			->willReturn(true);
161
162			$configurationConfig = [
163			'foo' => 123,
164			];
165
166			$this->doctrineConfig->expects($this->once())
167			->method('getConfigurationConfig')
168			->willReturn($configurationConfig);
169
170			$this->configurationFactory->expects($this->once())
171			->method('create')
172			->with($configurationConfig)
173			->willReturn($createdConfiguration);
174
175			$this->assertSame($createdConfiguration, $manager->getConfiguration($name));
176			}
177
178			/**
179			* Assert that an array of configuration can be set when calling setConfiguration() and retrieved by $name
180			* when calling getConfiguration($name)
181			*
182			* @throws ConfigurationManagerException
183			*/
184			public function testSetAndGetConfigurationObjects(): void
185			{
186			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
187
188			$configs = [
189			'fred' => $this->createMock(Configuration::class),
190			'bob' => $this->createMock(Configuration::class),
191			'dick' => $this->createMock(Configuration::class),
192			'harry' => $this->createMock(Configuration::class),
193			];
194
195			$manager->setConfigurations($configs);
196
197			foreach ($configs as $name => $config) {
198			$this->assertSame($config, $manager->getConfiguration($name));
199			}
200			}
201
202			/**
203			* Assert that setConfigurations() accepts Connection configuration which is added to the internal DoctrineConfig
204			*/
205			public function testSetAndGetConfigurationArray(): void
206			{
207			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
208
209			$configs = [
210			'fred' => [
211			'test' => 123,
212			],
213			'bob' => [
214			'test' => 456,
215			],
216			'jennifer' => [
217			'test' => 456,
218			],
219			];
220
221			$setArgs = [];
222			foreach ($configs as $name => $config) {
223			$setArgs[] = [$name, $config];
224			}
225
226			$this->doctrineConfig->expects($this->exactly(count($setArgs)))
227			->method('setConfigurationConfig')
228			->withConsecutive(...$setArgs);
229
230			$manager->setConfigurations($configs);
231			}
232
233			/**
234			* Assert has will return $expected bool value if the connection is set in $config or the $doctrineConfig
235			*
236			* @param bool $expected
237			* @param string $name
238			* @param array<mixed> $configs
239			*
240			* @dataProvider getHasConfigurationData
241			*/
242			public function testHasConfigurationObject(bool $expected, string $name, array $configs): void
243			{
244			$manager = new ConfigurationManager($this->configurationFactory, $this->doctrineConfig);
245
246			if (!empty($configs)) {
247			$manager->setConfigurations($configs);
248			}
249
250			if (!isset($configs[$name])) {
251			$this->doctrineConfig->expects($this->once())
252			->method('hasConfigurationConfig')
253			->with($name)
254			->willReturn($expected);
255			}
256
257			$this->assertSame($expected, $manager->hasConfiguration($name));
258			}
259
260			/**
261			* @return array<mixed>
262			*/
263			public function getHasConfigurationData(): array
264			{
265			return [
266			// Found match in config
267			[
268			true,
269			'fred',
270			[
271			'fred' => $this->createMock(Configuration::class),
272			],
273			],
274
275			// Missing from both
276			[
277			false,
278			'Kitty',
279			[
280			'fred' => $this->createMock(Configuration::class),
281			],
282			],
283
284			// In Doctrine Config
285			[
286			true,
287			'Barney',
288			[
289			'fred' => $this->createMock(Configuration::class),
290			'bob' => $this->createMock(Configuration::class),
291			],
292			],
293			];
294			}
295			}
296

alex-patterson-webdev / laminas-doctrine

Pull Request — master (#2)

testGetConfigurationWillThrowConfigurationManagerExceptionForUnknownConnection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like