Graze\Sprout\Test\Unit\Db\DbTablePopulatorTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testTablesAreNotExcludedIfIncludedInExcludeList()	0	11	1
A	testTablesAreFilteredWhenPopulatedFromADatabase()	0	40	1
A	testTablePopulation()	0	36	1
A	testNoTablesArePopulatedIfTheyAreAlreadyProvided()	0	11	1
A	setUp()	0	5	1

<?php
/**
 * This file is part of graze/sprout.
 *
 * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license https://github.com/graze/sprout/blob/master/LICENSE.md
 * @link    https://github.com/graze/sprout
 */

namespace Graze\Sprout\Test\Unit\Db;

use Graze\Sprout\Config\ConnectionConfigInterface;
use Graze\Sprout\Config\SchemaConfigInterface;
use Graze\Sprout\Db\DbTablePopulator;
use Graze\Sprout\Db\PdoFactory;
use Graze\Sprout\Parser\ParsedSchema;
use Graze\Sprout\Parser\TableFilterer;
use Graze\Sprout\Test\TestCase;
use Mockery;
use PDO;

/**
 * @runTestsInSeparateProcesses
 * @preserveGlobalState disabled
 */
class DbTablePopulatorTest extends TestCase
{
    /** @var DbTablePopulator */
    private $tablePopulator;
    /** @var mixed */
    private $tableFilterer;
    /** @var mixed */
    private $pdoFactory;

    public function setUp()
    {
        $this->pdoFactory = Mockery::mock(PdoFactory::class);
        $this->tableFilterer = Mockery::mock(TableFilterer::class);
        $this->tablePopulator = new DbTablePopulator($this->pdoFactory, $this->tableFilterer);

$this->tableFilterer of type Mockery\MockInterface is incompatible with the type Graze\Sprout\Parser\TableFilterer|null expected by parameter $tableFilterer of Graze\Sprout\Db\DbTablePopulator::__construct().

$this->pdoFactory of type Mockery\MockInterface is incompatible with the type Graze\Sprout\Db\PdoFactory|null expected by parameter $pdoFactory of Graze\Sprout\Db\DbTablePopulator::__construct().

    }

    public function testTablePopulation()
    {
        $config = Mockery::mock(SchemaConfigInterface::class);
        $parsedSchema = new ParsedSchema($config, '/a/path', []);

$config of type Mockery\MockInterface is incompatible with the type Graze\Sprout\Config\SchemaConfigInterface expected by parameter $schemaConfig of Graze\Sprout\Parser\ParsedSchema::__construct().

        $connection = Mockery::mock(ConnectionConfigInterface::class);
        $config->allows([
            'getExcludes'   => [],
            'getSchema'     => 'schema1',
            'getConnection' => $connection,
        ]);

        $pdo = Mockery::mock(PDO::class);
        $this->pdoFactory->allows()
                         ->getPdo($connection)
                         ->andReturns($pdo);
        $statement = Mockery::mock(\PDOStatement::class);
        $pdo->allows()
            ->prepare(

The method prepare() does not exist on Mockery\ExpectationInterface. It seems like you code against a sub-type of Mockery\ExpectationInterface such as Mockery\CompositeExpectation.

The method prepare() does not exist on Mockery\Expectation.

                'SELECT table_name
                FROM INFORMATION_SCHEMA.TABLES 
                WHERE table_schema = :schema
                AND table_type = "BASE TABLE"'
            )
            ->andReturns($statement);
        $statement->allows()
                  ->execute(['schema' => 'schema1'])

The method execute() does not exist on Mockery\Expectation.

The method execute() does not exist on Mockery\ExpectationInterface. It seems like you code against a sub-type of Mockery\ExpectationInterface such as Mockery\CompositeExpectation.

                  ->andReturns($statement);
        $statement->allows()
                  ->fetchAll(PDO::FETCH_COLUMN)

The method fetchAll() does not exist on Mockery\Expectation.

The method fetchAll() does not exist on Mockery\ExpectationInterface. It seems like you code against a sub-type of Mockery\ExpectationInterface such as Mockery\CompositeExpectation.

                  ->andReturns(['table1', 'table2']);

        $output = $this->tablePopulator->populateTables($parsedSchema);

        $this->assertSame($parsedSchema, $output);

        $this->assertEquals(['table1', 'table2'], $output->getTables());
    }

    public function testNoTablesArePopulatedIfTheyAreAlreadyProvided()
    {
        $config = Mockery::mock(SchemaConfigInterface::class);
        $parsedSchema = new ParsedSchema($config, '/a/path', ['table1', 'table2']);

$config of type Mockery\MockInterface is incompatible with the type Graze\Sprout\Config\SchemaConfigInterface expected by parameter $schemaConfig of Graze\Sprout\Parser\ParsedSchema::__construct().

        $config->allows(['getExcludes' => []]);

        $output = $this->tablePopulator->populateTables($parsedSchema);

        $this->assertSame($parsedSchema, $output);

        $this->assertEquals(['table1', 'table2'], $output->getTables());
    }

    public function testTablesAreNotExcludedIfIncludedInExcludeList()
    {
        $config = Mockery::mock(SchemaConfigInterface::class);
        $parsedSchema = new ParsedSchema($config, '/a/path', ['table1', 'table2']);

$config of type Mockery\MockInterface is incompatible with the type Graze\Sprout\Config\SchemaConfigInterface expected by parameter $schemaConfig of Graze\Sprout\Parser\ParsedSchema::__construct().

        $config->allows(['getExcludes' => ['table1']]);

        $output = $this->tablePopulator->populateTables($parsedSchema);

        $this->assertSame($parsedSchema, $output);

        $this->assertEquals(['table1', 'table2'], $output->getTables());
    }

    public function testTablesAreFilteredWhenPopulatedFromADatabase()
    {
        $config = Mockery::mock(SchemaConfigInterface::class);
        $parsedSchema = new ParsedSchema($config, '/a/path', []);

$config of type Mockery\MockInterface is incompatible with the type Graze\Sprout\Config\SchemaConfigInterface expected by parameter $schemaConfig of Graze\Sprout\Parser\ParsedSchema::__construct().

        $connection = Mockery::mock(ConnectionConfigInterface::class);
        $config->allows([
            'getExcludes'   => ['table1'],
            'getSchema'     => 'schema1',
            'getConnection' => $connection,
        ]);

        $pdo = Mockery::mock(PDO::class);
        $this->pdoFactory->allows()
                         ->getPdo($connection)
                         ->andReturns($pdo);
        $statement = Mockery::mock(\PDOStatement::class);
        $pdo->allows()
            ->prepare(
                'SELECT table_name
                FROM INFORMATION_SCHEMA.TABLES 
                WHERE table_schema = :schema
                AND table_type = "BASE TABLE"'
            )
            ->andReturns($statement);
        $statement->allows()
                  ->execute(['schema' => 'schema1'])
                  ->andReturns($statement);
        $statement->allows()
                  ->fetchAll(PDO::FETCH_COLUMN)
                  ->andReturns(['table1', 'table2']);

        $this->tableFilterer->allows()
                            ->filter(['table1', 'table2'], ['table1'])
                            ->andReturns(['table2']);

        $output = $this->tablePopulator->populateTables($parsedSchema);

        $this->assertSame($parsedSchema, $output);

        $this->assertEquals(['table2'], $output->getTables());
    }
}