Doctrine\Tests\DBAL\Schema\Visitor\CreateSchemaSqlCollectorTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	169
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\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\ForeignKeyConstraint;
use Doctrine\DBAL\Schema\Sequence;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Schema\View;
use Doctrine\DBAL\Schema\Visitor\CreateSchemaSqlCollector;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class CreateSchemaSqlCollectorTest extends TestCase
{
    /** @var AbstractPlatform|PHPUnit_Framework_MockObject_MockObject */

The type Doctrine\Tests\DBAL\Schema\Visitor\PHPUnit_Framework_MockObject_MockObject was not found. Did you mean PHPUnit_Framework_MockObject_MockObject? If so, make sure to prefix the type with \.

    private $platformMock;

    /** @var CreateSchemaSqlCollector */
    private $visitor;

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

        $this->platformMock = $this->getMockBuilder(AbstractPlatform::class)

It seems like $this->getMockBuilder(Doctrine\DBAL\Platforms\AbstractPlatform::class)->setMethods(array('getCreateForeignKeySQL', 'getCreateSchemaSQL', 'getCreateSequenceSQL', 'getCreateTableSQL', 'supportsForeignKeyConstraints', 'getCreateViewSQL', 'supportsSchemas'))->getMockForAbstractClass() of type PHPUnit\Framework\MockObject\MockObject is incompatible with the declared type Doctrine\DBAL\Platforms\AbstractPlatform|Doctrine\Tests\DBAL\Schema\Visitor\PHPUnit_Framework_MockObject_MockObject of property $platformMock.

            ->setMethods(
                [
                    'getCreateForeignKeySQL',
                    'getCreateSchemaSQL',
                    'getCreateSequenceSQL',
                    'getCreateTableSQL',
                    'supportsForeignKeyConstraints',
                    'getCreateViewSQL',
                    'supportsSchemas',
                ]
            )
            ->getMockForAbstractClass();
        $this->visitor      = new CreateSchemaSqlCollector($this->platformMock);

        foreach (['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(['foo'], $this->visitor->getQueries());
    }

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

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

        self::assertSame(['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(['foo'], $this->visitor->getQueries());
    }

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

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

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

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

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

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

    public function testResetsQueries()
    {
        foreach (['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 ForeignKeyConstraint|PHPUnit_Framework_MockObject_MockObject
     */
    private function createForeignKeyConstraintMock()
    {
        return $this->getMockBuilder(ForeignKeyConstraint::class)

The expression return $this->getMockBuilder(Doctrine\DBAL\Schema\ForeignKeyConstraint::class)->disableOriginalConstructor()->getMock() returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the documented return type Doctrine\DBAL\Schema\ForeignKeyConstraint|Doctrine\Tests\DBAL\Schema\Visitor\PHPUnit_Framework_MockObject_MockObject.

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

    /**
     * @return Sequence|PHPUnit_Framework_MockObject_MockObject
     */
    private function createSequenceMock()
    {
        return $this->getMockBuilder(Sequence::class)

The expression return $this->getMockBuilder(Doctrine\DBAL\Schema\Sequence::class)->disableOriginalConstructor()->getMock() returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the documented return type Doctrine\DBAL\Schema\Sequence|Doctrine\Tests\DBAL\Schema\Visitor\PHPUnit_Framework_MockObject_MockObject.

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

    /**
     * @return Table|PHPUnit_Framework_MockObject_MockObject
     */
    private function createTableMock()
    {
        return $this->getMockBuilder(Table::class)

The expression return $this->getMockBuilder(Doctrine\DBAL\Schema\Table::class)->disableOriginalConstructor()->getMock() returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the documented return type Doctrine\DBAL\Schema\Table|Doctrine\Tests\DBAL\Schema\Visitor\PHPUnit_Framework_MockObject_MockObject.

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

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