Doctrine\Tests\DBAL\Driver\AbstractDriverTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	247
Duplicated Lines	0 %

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	5	1
A	hp$0 ➔ __construct()	0	3	1
	testCreatesDatabasePlatformForVersion()	0	28	?
	getExceptionConversionData()	0	3	?
	testReturnsDatabaseName()	0	15	?
A	hp$0 ➔ testReturnsDatabasePlatform()	0	3	1
A	hp$0 ➔ testThrowsExceptionOnCreatingDatabasePlatformsForInvalidVersion()	0	8	2
A	hp$0 ➔ getSQLState()	0	3	1
A	hp$0 ➔ getConnectionMock()	0	5	1
A	hp$1 ➔ __construct()	0	5	1
A	hp$0 ➔ testConvertsException()	0	49	2
A	hp$0 ➔ getExceptionConversionData()	0	3	1
A	hp$0 ➔ testReturnsSchemaManager()	0	11	1
	testReturnsDatabasePlatform()	0	3	?
A	hp$0 ➔ testReturnsDatabaseName()	0	15	1
A	hp$1 ➔ getExceptionConversions()	0	34	3
A	hp$1 ➔ getSQLState()	0	3	1
	testThrowsExceptionOnCreatingDatabasePlatformsForInvalidVersion()	0	8	?
A	hp$0 ➔ testCreatesDatabasePlatformForVersion()	0	28	3
	getExceptionConversions()	0	34	?
	testReturnsSchemaManager()	0	11	?
	getDatabasePlatformsForVersions()	0	3	?
	getConnectionMock()	0	5	?
	testConvertsException()	0	49	?
A	hp$0 ➔ getDatabasePlatformsForVersions()	0	3	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\DBAL\Driver;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\DriverException as DriverExceptionInterface;
use Doctrine\DBAL\Driver\ExceptionConverterDriver;
use Doctrine\DBAL\Exception\ConnectionException;
use Doctrine\DBAL\Exception\ConstraintViolationException;
use Doctrine\DBAL\Exception\DatabaseObjectExistsException;
use Doctrine\DBAL\Exception\DatabaseObjectNotFoundException;
use Doctrine\DBAL\Exception\DeadlockException;
use Doctrine\DBAL\Exception\DriverException;
use Doctrine\DBAL\Exception\ForeignKeyConstraintViolationException;
use Doctrine\DBAL\Exception\InvalidFieldNameException;
use Doctrine\DBAL\Exception\LockWaitTimeoutException;
use Doctrine\DBAL\Exception\NonUniqueFieldNameException;
use Doctrine\DBAL\Exception\NotNullConstraintViolationException;
use Doctrine\DBAL\Exception\ReadOnlyException;
use Doctrine\DBAL\Exception\ServerException;
use Doctrine\DBAL\Exception\SyntaxErrorException;
use Doctrine\DBAL\Exception\TableExistsException;
use Doctrine\DBAL\Exception\TableNotFoundException;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\VersionAwarePlatformDriver;
use Doctrine\Tests\DbalTestCase;
use Exception;
use ReflectionProperty;
use function get_class;
use function sprintf;

abstract class AbstractDriverTest extends DbalTestCase
{
    public const EXCEPTION_CONNECTION                       = ConnectionException::class;
    public const EXCEPTION_CONSTRAINT_VIOLATION             = ConstraintViolationException::class;
    public const EXCEPTION_DATABASE_OBJECT_EXISTS           = DatabaseObjectExistsException::class;
    public const EXCEPTION_DATABASE_OBJECT_NOT_FOUND        = DatabaseObjectNotFoundException::class;
    public const EXCEPTION_DRIVER                           = DriverException::class;
    public const EXCEPTION_FOREIGN_KEY_CONSTRAINT_VIOLATION = ForeignKeyConstraintViolationException::class;
    public const EXCEPTION_INVALID_FIELD_NAME               = InvalidFieldNameException::class;
    public const EXCEPTION_NON_UNIQUE_FIELD_NAME            = NonUniqueFieldNameException::class;
    public const EXCEPTION_NOT_NULL_CONSTRAINT_VIOLATION    = NotNullConstraintViolationException::class;
    public const EXCEPTION_READ_ONLY                        = ReadOnlyException::class;
    public const EXCEPTION_SERVER                           = ServerException::class;
    public const EXCEPTION_SYNTAX_ERROR                     = SyntaxErrorException::class;
    public const EXCEPTION_TABLE_EXISTS                     = TableExistsException::class;
    public const EXCEPTION_TABLE_NOT_FOUND                  = TableNotFoundException::class;
    public const EXCEPTION_UNIQUE_CONSTRAINT_VIOLATION      = UniqueConstraintViolationException::class;
    public const EXCEPTION_DEADLOCK                         = DeadlockException::class;
    public const EXCEPTION_LOCK_WAIT_TIMEOUT                = LockWaitTimeoutException::class;

    /**
     * The driver mock under test.
     *
     * @var Driver
     */
    protected $driver;

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

        $this->driver = $this->createDriver();
    }

    public function testConvertsException() : void
    {
        if (! $this->driver instanceof ExceptionConverterDriver) {
            $this->markTestSkipped('This test is only intended for exception converter drivers.');
        }

        $data = $this->getExceptionConversions();

        if (empty($data)) {
            $this->fail(
                sprintf(
                    'No test data found for test %s. You have to return test data from %s.',
                    static::class . '::' . __FUNCTION__,
                    static::class . '::getExceptionConversionData'
                )
            );
        }

        $driverException = new class extends Exception implements DriverExceptionInterface
        {
            public function __construct()
            {
                parent::__construct('baz');
            }

            /**
             * {@inheritDoc}
             */
            public function getSQLState() : ?string
            {
                return 'bar';
            }
        };

        $data[] = [$driverException, self::EXCEPTION_DRIVER];

        $message = 'DBAL exception message';

        foreach ($data as $item) {
            /** @var $driverException \Doctrine\DBAL\Driver\DriverException */
            [$driverException, $convertedExceptionClassName] = $item;

            $convertedException = $this->driver->convertException($message, $driverException);

            self::assertSame($convertedExceptionClassName, get_class($convertedException));

            self::assertSame($driverException->getCode(), $convertedException->getCode());
            self::assertSame($driverException->getSQLState(), $convertedException->getSQLState());
            self::assertSame($message, $convertedException->getMessage());
        }
    }

    public function testCreatesDatabasePlatformForVersion() : void
    {
        if (! $this->driver instanceof VersionAwarePlatformDriver) {
            $this->markTestSkipped('This test is only intended for version aware platform drivers.');
        }

        $data = $this->getDatabasePlatformsForVersions();

        self::assertNotEmpty(
            $data,
            sprintf(
                'No test data found for test %s. You have to return test data from %s.',
                static::class . '::' . __FUNCTION__,
                static::class . '::getDatabasePlatformsForVersions'
            )
        );

        foreach ($data as $item) {
            $generatedVersion = get_class($this->driver->createDatabasePlatformForVersion($item[0]));

            self::assertSame(
                $item[1],
                $generatedVersion,
                sprintf(
                    'Expected platform for version "%s" should be "%s", "%s" given',
                    $item[0],
                    $item[1],
                    $generatedVersion
                )
            );
        }
    }

    public function testThrowsExceptionOnCreatingDatabasePlatformsForInvalidVersion() : void
    {
        if (! $this->driver instanceof VersionAwarePlatformDriver) {
            $this->markTestSkipped('This test is only intended for version aware platform drivers.');
        }

        $this->expectException(DBALException::class);
        $this->driver->createDatabasePlatformForVersion('foo');
    }

    public function testReturnsDatabaseName() : void
    {
        $params = [
            'user'     => 'foo',
            'password' => 'bar',
            'dbname'   => 'baz',
        ];

        $connection = $this->getConnectionMock();

        $connection->expects($this->once())
            ->method('getParams')
            ->will($this->returnValue($params));

        self::assertSame($params['dbname'], $this->driver->getDatabase($connection));
    }

    public function testReturnsDatabasePlatform() : void
    {
        self::assertEquals($this->createPlatform(), $this->driver->getDatabasePlatform());
    }

    public function testReturnsSchemaManager() : void
    {
        $connection    = $this->getConnectionMock();
        $schemaManager = $this->driver->getSchemaManager($connection);

        self::assertEquals($this->createSchemaManager($connection), $schemaManager);

        $re = new ReflectionProperty($schemaManager, '_conn');
        $re->setAccessible(true);

        self::assertSame($connection, $re->getValue($schemaManager));
    }

    /**
     * Factory method for creating the driver instance under test.
     */
    abstract protected function createDriver() : Driver;

    /**
     * Factory method for creating the the platform instance return by the driver under test.
     *
     * The platform instance returned by this method must be the same as returned by
     * the driver's getDatabasePlatform() method.
     */
    abstract protected function createPlatform() : AbstractPlatform;

    /**
     * Factory method for creating the the schema manager instance return by the driver under test.
     *
     * The schema manager instance returned by this method must be the same as returned by
     * the driver's getSchemaManager() method.
     *
     * @param Connection $connection The underlying connection to use.
     */
    abstract protected function createSchemaManager(Connection $connection) : AbstractSchemaManager;

    protected function getConnectionMock() : Connection
    {
        return $this->getMockBuilder(Connection::class)

The expression return $this->getMockBuilder(Doctrine\DBAL\Connection::class)->disableOriginalConstructor()->getMock() returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Doctrine\DBAL\Connection.

            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return mixed[]
     */
    protected function getDatabasePlatformsForVersions() : array
    {
        return [];
    }

    /**
     * @return mixed[]
     */
    protected function getExceptionConversionData() : array
    {
        return [];
    }

    /**
     * @return mixed[]
     */
    private function getExceptionConversions() : array
    {
        $data = [];

        foreach ($this->getExceptionConversionData() as $convertedExceptionClassName => $errors) {
            foreach ($errors as $error) {
                $driverException = new class (...$error)

$error is expanded, but the parameter $code of anonymous//tests/Doctrine/Tests/DBAL/Driver/AbstractDriverTest.php$1::__construct() does not expect variable arguments.

                    extends Exception
                    implements DriverExceptionInterface
                {
                    /** @var string|null */
                    private $sqlState;

                    public function __construct(int $code, ?string $sqlState = null, string $message = '')
                    {
                        parent::__construct($message, $code);

                        $this->sqlState = $sqlState;
                    }

                    /**
                     * {@inheritDoc}
                     */
                    public function getSQLState() : ?string
                    {
                        return $this->sqlState;
                    }
                };

                $data[] = [$driverException, $convertedExceptionClassName];
            }
        }

        return $data;
    }
}