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

Test Failed
Pull Request — master (#2)

by Alex
created 2021-03-16 00:15 UTC
testGetConnectionWillReturnANamedConnection() A

↳ Parent: ConnectionManagerTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	16
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	8
c	1
b	0
f	0
dl	0
loc	16
rs	10
cc	1
nc	1
nop	0
<?php

declare(strict_types=1);

namespace ArpTest\LaminasDoctrine\Service\Connection;

use Arp\LaminasDoctrine\Config\DoctrineConfig;
use Arp\LaminasDoctrine\Service\Connection\ConnectionFactoryInterface;
use Arp\LaminasDoctrine\Service\Connection\ConnectionManager;
use Arp\LaminasDoctrine\Service\Connection\ConnectionManagerInterface;
use Arp\LaminasDoctrine\Service\Connection\Exception\ConnectionFactoryException;
use Arp\LaminasDoctrine\Service\Connection\Exception\ConnectionManagerException;
use Doctrine\DBAL\Connection;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @covers  \Arp\LaminasDoctrine\Service\Connection\ConnectionManager
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\LaminasDoctrine\Service\Connection
 */
final class ConnectionManagerTest extends TestCase
{
    /**
     * @var DoctrineConfig|MockObject
     */
    private DoctrineConfig $config;

    /**
     * @var ConnectionFactoryInterface|MockObject
     */
    private ConnectionFactoryInterface $connectionFactory;

    /**
     * @var Connection[]|MockObject[]|array
     */
    private array $connections = [];

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

        $this->connectionFactory = $this->createMock(ConnectionFactoryInterface::class);
    }

    /**
     * Assert that the class implement ConnectionManagerInterface
     */
    public function testImplementsConnectionManagerInterface(): void
    {
        $manager = new ConnectionManager($this->config, $this->connectionFactory, $this->connections);

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

    /**
     * Assert that a hasConnection() will return a boolean value for existing/missing connection values
     */
    public function testHasConnectionWillReturnBool(): void
    {
        $manager = new ConnectionManager($this->config, $this->connectionFactory, $this->connections);

        $connections = [
            'baz'  => $this->createMock(Connection::class),
            'bar'  => $this->createMock(Connection::class),
            'test' => [
                'hello' => 123,
                'fred'  => true,
                'test'  => 'Hello',
            ],
        ];

        $this->config->expects($this->once())
                       expects($this->once())
            ->method('setConnectionConfig')
            ->with('test', $connections['test']);

        $this->config->expects($this->exactly(2))
            ->method('hasConnectionConfig')
            ->withConsecutive(['test'], ['fred']
            )->willReturnOnConsecutiveCalls(true, false);

        $manager->setConnections($connections);

        $this->assertTrue($manager->hasConnection('baz'));
        $this->assertTrue($manager->hasConnection('bar'));
        $this->assertTrue($manager->hasConnection('test'));
        $this->assertFalse($manager->hasConnection('fred'));
    }

    /**
     * Assert that a connection can be fetched from the collection by $name
     *
     * @throws ConnectionManagerException
     */
    public function testGetConnectionWillReturnANamedConnection(): void
    {
        $manager = new ConnectionManager($this->config, $this->connectionFactory, $this->connections);

        $name = 'FooConnection';
        /** @var Connection|MockObject $expected */
        $expected = $this->createMock(Connection::class);

        $connections = [
            'bar' => $this->createMock(Connection::class),
            $name => $expected,
        ];

        $manager->setConnections($connections);

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

    /**
     * Asset A ConnectionManagerException is thrown should a call to getConnection() be unable to return a
     * connection for a known connection $name
     *
     * @throws ConnectionManagerException
     */
    public function testGetConnectionWillThrowConnectionManagerExceptionIfUnableToCreateNamedConnection(): void
    {
        $manager = new ConnectionManager($this->config, $this->connectionFactory, $this->connections);

        $name = 'FooConnection';
        $connections = [
            $name => [
                'foo'  => 123,
                'test' => 'abc',
            ],
        ];

        $this->config->expects($this->once())
            ->method('setConnectionConfig')
            ->with($name, $connections[$name]);

        $this->config->expects($this->once())
            ->method('hasConnectionConfig')
            ->with($name)
            ->willReturn(true);

        $this->config->expects($this->once())
            ->method('getConnectionConfig')
            ->with($name)
            ->willReturn($connections[$name]);

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

        $this->connectionFactory->expects($this->once())
                                  expects($this->once())
            ->method('create')
            ->with($connections[$name])
            ->willThrowException($exception);

        $this->expectException(ConnectionManagerException::class);
        $this->expectExceptionCode($exceptionCode);
        $this->expectExceptionMessage(sprintf('Failed to establish connection \'%s\': %s', $name, $exceptionMessage));

        $manager->setConnections($connections);

        $manager->getConnection($name);
    }

    /**
     * Assert that a collection can be lazy loaded from the collection by its $name
     *
     * @throws ConnectionManagerException
     */
    public function testGetConnectionWillLazyLoadAndReturnANamedConnection(): void
    {
        $manager = new ConnectionManager($this->config, $this->connectionFactory, $this->connections);

        $name = 'FooConnection';
        $connections = [
            $name => [
                'foo'  => 123,
                'test' => 'abc',
            ],
            'foo' => $this->createMock(Connection::class),
        ];

        $this->config->expects($this->once())
            ->method('setConnectionConfig')
            ->with($name, $connections[$name]);

        $this->config->expects($this->once())
            ->method('hasConnectionConfig')
            ->with($name)
            ->willReturn(true);

        $this->config->expects($this->once())
            ->method('getConnectionConfig')
            ->with($name)
            ->willReturn($connections[$name]);

        /** @var Connection|MockObject $expected */
        $expected = $this->createMock(Connection::class);

        $this->connectionFactory->expects($this->once())
            ->method('create')
            ->with($connections[$name])
            ->willReturn($expected);

        $manager->setConnections($connections);

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

    /**
     * Assert that calling getConnection() with a non-existing connection $name a ConnectionManagerException is thrown
     *
     * @throws ConnectionManagerException
     */
    public function testGetConnectionWillThrowConnectionManagerExceptionIfNotFound(): void
    {
        $manager = new ConnectionManager($this->config, $this->connectionFactory, $this->connections);

        $name = 'NonExistingName';

        $this->config->expects($this->once())
            ->method('hasConnectionConfig')
            ->with($name)
            ->willReturn(false);

        $this->expectException(ConnectionManagerException::class);
        $this->expectExceptionMessage(
            sprintf('Failed to establish connection \'%s\': Failed to find a the required configuration', $name)
        );

        $manager->getConnection($name);
    }
}

alex-patterson-webdev / laminas-doctrine

Pull Request — master (#2)

testGetConnectionWillReturnANamedConnection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
