Doctrine\Tests\ORM\Functional\SchemaTool\SqliteSchemaToolTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDown()	0	6	1
A	provideUpdateSchemaSqlWithSchemaAssetFilter()	0	8	1
A	testUpdateSchemaSql()	0	21	1
A	setUp()	0	6	2
A	filterCreateTable()	0	4	1
A	testUpdateSchemaSqlWithSchemaAssetFilter()	0	28	5

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional\SchemaTool;

use Doctrine\DBAL\Configuration;
use Doctrine\ORM\Tools\SchemaTool;
use Doctrine\Tests\OrmFunctionalTestCase;
use function array_filter;
use function current;
use function method_exists;
use function sprintf;
use function strpos;

class SqliteSchemaToolTest extends OrmFunctionalTestCase
{
    protected function setUp() : void
    {
        parent::setUp();

        if ($this->_em->getConnection()->getDatabasePlatform()->getName() !== 'sqlite') {
            $this->markTestSkipped('The ' . self::class . ' requires the use of sqlite.');
        }
    }

    protected function tearDown() : void
    {
        $this->_em->getConnection()->exec('DROP TABLE IF EXISTS my_entity');
        $this->_em->getConnection()->exec('DROP TABLE IF EXISTS my_other_entity');

        parent::tearDown();
    }

    private function filterCreateTable(array $sqls, string $tableName) : array
    {
        return array_filter($sqls, static function (string $sql) use ($tableName) : bool {
            return strpos($sql, sprintf('CREATE TABLE %s (', $tableName)) === 0;
        });
    }

    public function testUpdateSchemaSql() : void
    {
        $classes = [
            $this->_em->getClassMetadata(MyEntity::class),
        ];
        $tool    = new SchemaTool($this->_em);
        $sqls    = $tool->getUpdateSchemaSql($classes);
        $sqls    = $this->filterCreateTable($sqls, 'my_entity');
        $this->assertCount(1, $sqls);

        $this->_em->getConnection()->exec(current($sqls));
        $sqls = $tool->getUpdateSchemaSql($classes);
        $sqls = array_filter($sqls, static function (string $sql) : bool {
            return (bool) strpos($sql, 'my_entity');
        });
        $this->assertCount(0, $sqls);

        $classes[] = $this->_em->getClassMetadata(MyOtherEntity::class);
        $sqls      = $tool->getUpdateSchemaSql($classes);
        self::assertCount(0, $this->filterCreateTable($sqls, 'my_entity'));
        self::assertCount(1, $this->filterCreateTable($sqls, 'my_other_entity'));
    }

    public function provideUpdateSchemaSqlWithSchemaAssetFilter() : array
    {
        return [
            ['/^(?!my_enti)/', null],
            [
                null,
                static function ($assetName) : bool {
                    return $assetName !== 'my_entity';
                },
            ],
        ];
    }

    /**
     * @dataProvider provideUpdateSchemaSqlWithSchemaAssetFilter
     */
    public function testUpdateSchemaSqlWithSchemaAssetFilter(?string $filterRegex, ?callable $filterCallback) : void
    {
        if ($filterRegex && ! method_exists(Configuration::class, 'setFilterSchemaAssetsExpression')) {
            self::markTestSkipped(sprintf('Test require %s::setFilterSchemaAssetsExpression method', Configuration::class));
        }

        $classes = [$this->_em->getClassMetadata(MyEntity::class)];

        $tool = new SchemaTool($this->_em);
        $tool->createSchema($classes);

        $config = $this->_em->getConnection()->getConfiguration();
        if ($filterRegex) {
            $config->setFilterSchemaAssetsExpression($filterRegex);

The function Doctrine\DBAL\Configuration::setFilterSchemaAssetsExpression() has been deprecated: Use Configuration::setSchemaAssetsFilter() instead

        } else {
            $config->setSchemaAssetsFilter($filterCallback);
        }

        $sqls = $tool->getUpdateSchemaSql($classes);
        $sqls = array_filter($sqls, static function (string $sql) : bool {
            return (bool) strpos($sql, 'my_entity');
        });
        self::assertCount(0, $sqls);

        if ($filterRegex) {
            self::assertEquals($filterRegex, $config->getFilterSchemaAssetsExpression());
        } else {
            self::assertSame($filterCallback, $config->getSchemaAssetsFilter());
        }
    }
}

/**
 * @Entity
 * @Table(name="my_entity")
 */
class MyEntity
{
    /**
     * @Id @Column(type="integer")
     * @GeneratedValue(strategy="AUTO")
     */
    public $id;
}

/**
 * @Entity
 * @Table(name="my_other_entity")
 */
class MyOtherEntity
{
    /**
     * @Id @Column(type="integer")
     * @GeneratedValue(strategy="AUTO")
     */
    public $id;
}