Doctrine\Tests\DBAL\Schema\PostgreSQLSchemaManagerTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	setupConnectionAndManager()	0	10	1
B	testFiltersSequences()	0	32	1
A	filtersSequencesDataProvider()	0	22	1

<?php

namespace Doctrine\Tests\DBAL\Schema;

use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Platforms\PostgreSQL100Platform;
use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
use Doctrine\DBAL\Schema\PostgreSqlSchemaManager;
use Doctrine\DBAL\Schema\Sequence;

class PostgreSQLSchemaManagerTest extends \PHPUnit\Framework\TestCase
{
    /**
     * @var \Doctrine\DBAL\Schema\PostgreSQLSchemaManager
     */
    private $schemaManager;

    /**
     * @var \Doctrine\DBAL\Connection|\PHPUnit_Framework_MockObject_MockObject
     */
    private $connection;

    private function setupConnectionAndManager(string $platformClass) : void
    {
        $driverMock = $this->createMock('Doctrine\DBAL\Driver');
        $platform   = $this->createMock($platformClass);

        $this->connection = $this->getMockBuilder('Doctrine\DBAL\Connection')
            ->setConstructorArgs([['platform' => $platform], $driverMock])
            ->getMock();

        $this->schemaManager = new PostgreSqlSchemaManager($this->connection, $platform);
    }

    /**
     * @group DBAL-474
     * @dataProvider filtersSequencesDataProvider
     */
    public function testFiltersSequences(string $platformClass, array $sequencesData, int $fetchAllexpectationCount) : void
    {
        $this->setupConnectionAndManager($platformClass);

        $configuration = new Configuration();
        $configuration->setFilterSchemaAssetsExpression('/^schema/');

        $this->connection->expects($this->any())
            ->method('getConfiguration')
            ->will($this->returnValue($configuration));

        $this->connection->expects($this->at(0))
            ->method('fetchAll')
            ->will($this->returnValue($sequencesData));

        $this->connection->expects($this->at(1))
            ->method('fetchAll')
            ->will($this->returnValue([['min_value' => 1, 'increment_by' => 1]]));

        $this->connection->expects($this->at(2))
            ->method('fetchAll')
            ->will($this->returnValue([['min_value' => 2, 'increment_by' => 2]]));

        $this->connection->expects($this->exactly($fetchAllexpectationCount))
            ->method('fetchAll');

        self::assertEquals(
            [
                new Sequence('schema.foo', 2, 2),
                new Sequence('schema.bar', 1, 1),
            ],
            $this->schemaManager->listSequences('database')
        );
    }

    public function filtersSequencesDataProvider() : array
    {
        return [
            [
                'platform' => PostgreSqlPlatform::class,
                'sequencesData' => [
                    ['relname' => 'foo', 'schemaname' => 'schema'],
                    ['relname' => 'bar', 'schemaname' => 'schema'],
                    ['relname' => 'baz', 'schemaname' => ''],
                    ['relname' => 'bloo', 'schemaname' => 'bloo_schema'],
                ],
                'fetchAllexpectationCount' => 3
            ],
            [
                'platform' => PostgreSQL100Platform::class,
                'sequencesData' => [
                    ['relname' => 'foo', 'schemaname' => 'schema', 'min_value' => 2, 'increment_by' => 2],
                    ['relname' => 'bar', 'schemaname' => 'schema', 'min_value' => 1, 'increment_by' => 1],
                    ['relname' => 'baz', 'schemaname' => '', 'min_value' => 3, 'increment_by' => 3],
                    ['relname' => 'bloo', 'schemaname' => 'bloo_schema', 'min_value' => 4, 'increment_by' => 4],
                ],
                'fetchAllexpectationCount' => 1
            ]
        ];
    }
}