Doctrine\Tests\DBAL\Schema\Visitor\CreateSchemaSqlCollectorTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	createTableMock()	0	5	1
A	createForeignKeyConstraintMock()	0	5	1
A	testAcceptsSequences()	0	7	1
A	testAcceptsView()	0	7	1
A	testAcceptsTable()	0	7	1
A	testAcceptsForeignKey()	0	20	1
A	setUp()	0	23	2
A	testResetsQueries()	0	24	2
A	testAcceptsNamespace()	0	17	1
A	createSequenceMock()	0	5	1
A	createViewMock()	0	5	1

<?php

namespace Doctrine\Tests\DBAL\Schema\Visitor;

use \Doctrine\DBAL\Schema\Visitor\CreateSchemaSqlCollector;

class CreateSchemaSqlCollectorTest extends \PHPUnit\Framework\TestCase
{
    /**
     * @var \Doctrine\DBAL\Platforms\AbstractPlatform|\PHPUnit_Framework_MockObject_MockObject
     */
    private $platformMock;

    /**
     * @var \Doctrine\DBAL\Schema\Visitor\CreateSchemaSqlCollector
     */
    private $visitor;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        parent::setUp();

        $this->platformMock = $this->getMockBuilder('Doctrine\DBAL\Platforms\AbstractPlatform')
            ->setMethods(
                array(
                    'getCreateForeignKeySQL',
                    'getCreateSchemaSQL',
                    'getCreateSequenceSQL',
                    'getCreateTableSQL',
                    'supportsForeignKeyConstraints',
                    'getCreateViewSQL',
                    'supportsSchemas'
                )
            )
            ->getMockForAbstractClass();
        $this->visitor = new CreateSchemaSqlCollector($this->platformMock);

        foreach (array('getCreateSchemaSQL', 'getCreateTableSQL', 'getCreateForeignKeySQL', 'getCreateSequenceSQL', 'getCreateViewSQL') as $method) {
            $this->platformMock->expects($this->any())
                ->method($method)
                ->will($this->returnValue('foo'));
        }
    }

    public function testAcceptsNamespace()
    {
        $this->platformMock->expects($this->at(0))
            ->method('supportsSchemas')
            ->will($this->returnValue(false));

        $this->platformMock->expects($this->at(1))
            ->method('supportsSchemas')
            ->will($this->returnValue(true));

        $this->visitor->acceptNamespace('foo');

        self::assertEmpty($this->visitor->getQueries());

        $this->visitor->acceptNamespace('foo');

        self::assertSame(array('foo'), $this->visitor->getQueries());
    }

    public function testAcceptsTable()
    {
        $table = $this->createTableMock();

        $this->visitor->acceptTable($table);

        self::assertSame(array('foo'), $this->visitor->getQueries());
    }

    public function testAcceptsForeignKey()
    {
        $this->platformMock->expects($this->at(0))
            ->method('supportsForeignKeyConstraints')
            ->will($this->returnValue(false));

        $this->platformMock->expects($this->at(1))
            ->method('supportsForeignKeyConstraints')
            ->will($this->returnValue(true));

        $table = $this->createTableMock();
        $foreignKey = $this->createForeignKeyConstraintMock();

        $this->visitor->acceptForeignKey($table, $foreignKey);

        self::assertEmpty($this->visitor->getQueries());

        $this->visitor->acceptForeignKey($table, $foreignKey);

        self::assertSame(array('foo'), $this->visitor->getQueries());
    }

    public function testAcceptsSequences()
    {
        $sequence = $this->createSequenceMock();

        $this->visitor->acceptSequence($sequence);

        self::assertSame(array('foo'), $this->visitor->getQueries());
    }

    public function testAcceptsView()
    {
      $view = $this->createViewMock();

      $this->visitor->acceptView($view);

      $this->assertSame(array('foo'), $this->visitor->getQueries());
    }

    public function testResetsQueries()
    {
        foreach (array('supportsSchemas', 'supportsForeignKeyConstraints') as $method) {
            $this->platformMock->expects($this->any())
                ->method($method)
                ->will($this->returnValue(true));
        }

        $table = $this->createTableMock();
        $foreignKey = $this->createForeignKeyConstraintMock();
        $sequence = $this->createSequenceMock();
        $view = $this->createViewMock();

        $this->visitor->acceptNamespace('foo');
        $this->visitor->acceptTable($table);
        $this->visitor->acceptForeignKey($table, $foreignKey);
        $this->visitor->acceptSequence($sequence);
        $this->visitor->acceptView($view);

        self::assertNotEmpty($this->visitor->getQueries());

        $this->visitor->resetQueries();

        self::assertEmpty($this->visitor->getQueries());
    }

    /**
     * @return \Doctrine\DBAL\Schema\ForeignKeyConstraint|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createForeignKeyConstraintMock()
    {
        return $this->getMockBuilder('Doctrine\DBAL\Schema\ForeignKeyConstraint')
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return \Doctrine\DBAL\Schema\Sequence|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createSequenceMock()
    {
        return $this->getMockBuilder('Doctrine\DBAL\Schema\Sequence')
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return \Doctrine\DBAL\Schema\Table|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createTableMock()
    {
        return $this->getMockBuilder('Doctrine\DBAL\Schema\Table')
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return \Doctrine\DBAL\Schema\View|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createViewMock()
    {
        return $this->getMockBuilder('Doctrine\DBAL\Schema\View')
            ->disableOriginalConstructor()
            ->getMock();
    }
}