SqliteSchemaManagerTest::testRenameTable() - Code Metrics - Inspection of "Fix parsing column comments on SQLite" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 2.10.x (#3939)

by Sergei

created 2020-04-10 07:05 UTC

SqliteSchemaManagerTest::testRenameTable() A

↳ Parent: SqliteSchemaManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	5
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Doctrine\Tests\DBAL\Functional\Schema;

use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Driver\Connection;
use Doctrine\DBAL\Schema;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\BlobType;
use Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Types\Types;
use SQLite3;
use function array_map;
use function dirname;
use function extension_loaded;
use function version_compare;

class SqliteSchemaManagerTest extends SchemaManagerFunctionalTestCase
{
    /**
     * SQLITE does not support databases.
     */
    public function testListDatabases() : void
    {
        $this->expectException(DBALException::class);

        $this->schemaManager->listDatabases();
    }

    public function testCreateAndDropDatabase() : void
    {
        $path = dirname(__FILE__) . '/test_create_and_drop_sqlite_database.sqlite';

        $this->schemaManager->createDatabase($path);
        self::assertFileExists($path);
        $this->schemaManager->dropDatabase($path);
        self::assertFileNotExists($path);
    }

    /**
     * @group DBAL-1220
     */
    public function testDropsDatabaseWithActiveConnections() : void
    {
        $this->schemaManager->dropAndCreateDatabase('test_drop_database');

        self::assertFileExists('test_drop_database');

        $params           = $this->connection->getParams();
        $params['dbname'] = 'test_drop_database';

        $user     = $params['user'] ?? null;
        $password = $params['password'] ?? null;

        $connection = $this->connection->getDriver()->connect($params, $user, $password);

        self::assertInstanceOf(Connection::class, $connection);

        $this->schemaManager->dropDatabase('test_drop_database');

        self::assertFileNotExists('test_drop_database');

        unset($connection);
    }

    public function testRenameTable() : void
    {
        $this->createTestTable('oldname');
        $this->schemaManager->renameTable('oldname', 'newname');

        $tables = $this->schemaManager->listTableNames();
        self::assertContains('newname', $tables);
        self::assertNotContains('oldname', $tables);
    }

    public function createListTableColumns() : Table
    {
        $table = parent::createListTableColumns();
        $table->getColumn('id')->setAutoincrement(true);

        return $table;
    }

    public function testListForeignKeysFromExistingDatabase() : void
    {
        $this->connection->exec(<<<EOS
CREATE TABLE user (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    page INTEGER CONSTRAINT FK_1 REFERENCES page (key) DEFERRABLE INITIALLY DEFERRED,
    parent INTEGER REFERENCES user(id) ON DELETE CASCADE,
    log INTEGER,
    CONSTRAINT FK_3 FOREIGN KEY (log) REFERENCES log ON UPDATE SET NULL NOT DEFERRABLE
)
EOS
        );

        $expected = [
            new Schema\ForeignKeyConstraint(
                ['log'],
                'log',
                [null],
                'FK_3',
                ['onUpdate' => 'SET NULL', 'onDelete' => 'NO ACTION', 'deferrable' => false, 'deferred' => false]
            ),
            new Schema\ForeignKeyConstraint(
                ['parent'],
                'user',
                ['id'],
                '1',
                ['onUpdate' => 'NO ACTION', 'onDelete' => 'CASCADE', 'deferrable' => false, 'deferred' => false]
            ),
            new Schema\ForeignKeyConstraint(
                ['page'],
                'page',
                ['key'],
                'FK_1',
                ['onUpdate' => 'NO ACTION', 'onDelete' => 'NO ACTION', 'deferrable' => true, 'deferred' => true]
            ),
        ];

        self::assertEquals($expected, $this->schemaManager->listTableForeignKeys('user'));
    }

    public function testColumnCollation() : void
    {
        $table = new Schema\Table('test_collation');
        $table->addColumn('id', 'integer');
        $table->addColumn('text', 'text');
        $table->addColumn('foo', 'text')->setPlatformOption('collation', 'BINARY');
        $table->addColumn('bar', 'text')->setPlatformOption('collation', 'NOCASE');
        $this->schemaManager->dropAndCreateTable($table);

        $columns = $this->schemaManager->listTableColumns('test_collation');

        self::assertArrayNotHasKey('collation', $columns['id']->getPlatformOptions());
        self::assertEquals('BINARY', $columns['text']->getPlatformOption('collation'));
        self::assertEquals('BINARY', $columns['foo']->getPlatformOption('collation'));
        self::assertEquals('NOCASE', $columns['bar']->getPlatformOption('collation'));
    }

    public function testListTableWithBinary() : void
    {
        $tableName = 'test_binary_table';

        $table = new Table($tableName);
        $table->addColumn('id', 'integer');
        $table->addColumn('column_varbinary', 'binary', []);
        $table->addColumn('column_binary', 'binary', ['fixed' => true]);
        $table->setPrimaryKey(['id']);

        $this->schemaManager->createTable($table);

        $table = $this->schemaManager->listTableDetails($tableName);

        self::assertInstanceOf(BlobType::class, $table->getColumn('column_varbinary')->getType());
        self::assertFalse($table->getColumn('column_varbinary')->getFixed());

        self::assertInstanceOf(BlobType::class, $table->getColumn('column_binary')->getType());
        self::assertFalse($table->getColumn('column_binary')->getFixed());
    }

    public function testNonDefaultPKOrder() : void
    {
        if (! extension_loaded('sqlite3')) {
            $this->markTestSkipped('This test requires the SQLite3 extension.');
        }

        $version = SQLite3::version();
        if (version_compare($version['versionString'], '3.7.16', '<')) {
            $this->markTestSkipped('This version of sqlite doesn\'t return the order of the Primary Key.');
        }
        $this->connection->exec(<<<EOS
CREATE TABLE non_default_pk_order (
    id INTEGER,
    other_id INTEGER,
    PRIMARY KEY(other_id, id)
)
EOS
        );

        $tableIndexes = $this->schemaManager->listTableIndexes('non_default_pk_order');

         self::assertCount(1, $tableIndexes);

        self::assertArrayHasKey('primary', $tableIndexes, 'listTableIndexes() has to return a "primary" array key.');
        self::assertEquals(['other_id', 'id'], array_map('strtolower', $tableIndexes['primary']->getColumns()));
    }

    /**
     * @group DBAL-1779
     */
    public function testListTableColumnsWithWhitespacesInTypeDeclarations() : void
    {
        $sql = <<<SQL
CREATE TABLE dbal_1779 (
    foo VARCHAR (64) ,
    bar TEXT (100)
)
SQL;

        $this->connection->exec($sql);

        $columns = $this->schemaManager->listTableColumns('dbal_1779');

        self::assertCount(2, $columns);

        self::assertArrayHasKey('foo', $columns);
        self::assertArrayHasKey('bar', $columns);

        self::assertSame(Type::getType(Types::STRING), $columns['foo']->getType());
        self::assertSame(Type::getType(Types::TEXT), $columns['bar']->getType());

        self::assertSame(64, $columns['foo']->getLength());
        self::assertSame(100, $columns['bar']->getLength());
    }

    /**
     * @dataProvider getDiffListIntegerAutoincrementTableColumnsData
     * @group DBAL-924
     */
    public function testDiffListIntegerAutoincrementTableColumns(string $integerType, bool $unsigned, bool $expectedComparatorDiff) : void
    {
        $tableName = 'test_int_autoincrement_table';

        $offlineTable = new Table($tableName);
        $offlineTable->addColumn('id', $integerType, ['autoincrement' => true, 'unsigned' => $unsigned]);
        $offlineTable->setPrimaryKey(['id']);

        $this->schemaManager->dropAndCreateTable($offlineTable);

        $onlineTable = $this->schemaManager->listTableDetails($tableName);
        $comparator  = new Schema\Comparator();
        $diff        = $comparator->diffTable($offlineTable, $onlineTable);

        if ($expectedComparatorDiff) {
            self::assertEmpty($this->schemaManager->getDatabasePlatform()->getAlterTableSQL($diff));
        } else {
            self::assertFalse($diff);
        }
    }

    /**
     * @return mixed[][]
     */
    public static function getDiffListIntegerAutoincrementTableColumnsData() : iterable
    {
        return [
            ['smallint', false, true],
            ['smallint', true, true],
            ['integer', false, false],
            ['integer', true, true],
            ['bigint', false, true],
            ['bigint', true, true],
        ];
    }

    /**
     * @group DBAL-2921
     */
    public function testPrimaryKeyNoAutoIncrement() : void
    {
        $table = new Schema\Table('test_pk_auto_increment');
        $table->addColumn('id', 'integer');
        $table->addColumn('text', 'text');
        $table->setPrimaryKey(['id']);
        $this->schemaManager->dropAndCreateTable($table);

        $this->connection->insert('test_pk_auto_increment', ['text' => '1']);

        $this->connection->query('DELETE FROM test_pk_auto_increment');

        $this->connection->insert('test_pk_auto_increment', ['text' => '2']);

        $query = $this->connection->query('SELECT id FROM test_pk_auto_increment WHERE text = "2"');
        $query->execute();
        $lastUsedIdAfterDelete = (int) $query->fetchColumn();

        // with an empty table, non autoincrement rowid is always 1
        $this->assertEquals(1, $lastUsedIdAfterDelete);
    }

    public function testOnlyOwnCommentIsParsed() : void
    {
        $table = new Table('test');
        $table->addColumn('col1', 'string', ['length' => 16]);
        $table->addColumn('col2', 'string', ['length' => 16, 'comment' => 'Column #2']);
        $table->addColumn('col3', 'string', ['length' => 16]);

        $sm = $this->connection->getSchemaManager();
        $sm->createTable($table);

        $this->assertNull($sm->listTableDetails('test')
            ->getColumn('col1')
            ->getComment());
    }
}


1			<?php
2
3			namespace Doctrine\Tests\DBAL\Functional\Schema;
4
5			use Doctrine\DBAL\DBALException;
6			use Doctrine\DBAL\Driver\Connection;
7			use Doctrine\DBAL\Schema;
8			use Doctrine\DBAL\Schema\Table;
9			use Doctrine\DBAL\Types\BlobType;
10			use Doctrine\DBAL\Types\Type;
11			use Doctrine\DBAL\Types\Types;
12			use SQLite3;
13			use function array_map;
14			use function dirname;
15			use function extension_loaded;
16			use function version_compare;
17
18			class SqliteSchemaManagerTest extends SchemaManagerFunctionalTestCase
19			{
20			/**
21			* SQLITE does not support databases.
22			*/
23			public function testListDatabases() : void
24			{
25			$this->expectException(DBALException::class);
26
27			$this->schemaManager->listDatabases();
28			}
29
30			public function testCreateAndDropDatabase() : void
31			{
32			$path = dirname(__FILE__) . '/test_create_and_drop_sqlite_database.sqlite';
33
34			$this->schemaManager->createDatabase($path);
35			self::assertFileExists($path);
36			$this->schemaManager->dropDatabase($path);
37			self::assertFileNotExists($path);
38			}
39
40			/**
41			* @group DBAL-1220
42			*/
43			public function testDropsDatabaseWithActiveConnections() : void
44			{
45			$this->schemaManager->dropAndCreateDatabase('test_drop_database');
46
47			self::assertFileExists('test_drop_database');
48
49			$params = $this->connection->getParams();
50			$params['dbname'] = 'test_drop_database';
51
52			$user = $params['user'] ?? null;
53			$password = $params['password'] ?? null;
54
55			$connection = $this->connection->getDriver()->connect($params, $user, $password);
56
57			self::assertInstanceOf(Connection::class, $connection);
58
59			$this->schemaManager->dropDatabase('test_drop_database');
60
61			self::assertFileNotExists('test_drop_database');
62
63			unset($connection);
64			}
65
66			public function testRenameTable() : void
67			{
68			$this->createTestTable('oldname');
69			$this->schemaManager->renameTable('oldname', 'newname');
70
71			$tables = $this->schemaManager->listTableNames();
72			self::assertContains('newname', $tables);
73			self::assertNotContains('oldname', $tables);
74			}
75
76			public function createListTableColumns() : Table
77			{
78			$table = parent::createListTableColumns();
79			$table->getColumn('id')->setAutoincrement(true);
80
81			return $table;
82			}
83
84			public function testListForeignKeysFromExistingDatabase() : void
85			{
86			$this->connection->exec(<<<EOS
87			CREATE TABLE user (
88			id INTEGER PRIMARY KEY AUTOINCREMENT,
89			page INTEGER CONSTRAINT FK_1 REFERENCES page (key) DEFERRABLE INITIALLY DEFERRED,
90			parent INTEGER REFERENCES user(id) ON DELETE CASCADE,
91			log INTEGER,
92			CONSTRAINT FK_3 FOREIGN KEY (log) REFERENCES log ON UPDATE SET NULL NOT DEFERRABLE
93			)
94			EOS
95			);
96
97			$expected = [
98			new Schema\ForeignKeyConstraint(
99			['log'],
100			'log',
101			[null],
102			'FK_3',
103			['onUpdate' => 'SET NULL', 'onDelete' => 'NO ACTION', 'deferrable' => false, 'deferred' => false]
104			),
105			new Schema\ForeignKeyConstraint(
106			['parent'],
107			'user',
108			['id'],
109			'1',
110			['onUpdate' => 'NO ACTION', 'onDelete' => 'CASCADE', 'deferrable' => false, 'deferred' => false]
111			),
112			new Schema\ForeignKeyConstraint(
113			['page'],
114			'page',
115			['key'],
116			'FK_1',
117			['onUpdate' => 'NO ACTION', 'onDelete' => 'NO ACTION', 'deferrable' => true, 'deferred' => true]
118			),
119			];
120
121			self::assertEquals($expected, $this->schemaManager->listTableForeignKeys('user'));
122			}
123
124			public function testColumnCollation() : void
125			{
126			$table = new Schema\Table('test_collation');
127			$table->addColumn('id', 'integer');
128			$table->addColumn('text', 'text');
129			$table->addColumn('foo', 'text')->setPlatformOption('collation', 'BINARY');
130			$table->addColumn('bar', 'text')->setPlatformOption('collation', 'NOCASE');
131			$this->schemaManager->dropAndCreateTable($table);
132
133			$columns = $this->schemaManager->listTableColumns('test_collation');
134
135			self::assertArrayNotHasKey('collation', $columns['id']->getPlatformOptions());
136			self::assertEquals('BINARY', $columns['text']->getPlatformOption('collation'));
137			self::assertEquals('BINARY', $columns['foo']->getPlatformOption('collation'));
138			self::assertEquals('NOCASE', $columns['bar']->getPlatformOption('collation'));
139			}
140
141			public function testListTableWithBinary() : void
142			{
143			$tableName = 'test_binary_table';
144
145			$table = new Table($tableName);
146			$table->addColumn('id', 'integer');
147			$table->addColumn('column_varbinary', 'binary', []);
148			$table->addColumn('column_binary', 'binary', ['fixed' => true]);
149			$table->setPrimaryKey(['id']);
150
151			$this->schemaManager->createTable($table);
152
153			$table = $this->schemaManager->listTableDetails($tableName);
154
155			self::assertInstanceOf(BlobType::class, $table->getColumn('column_varbinary')->getType());
156			self::assertFalse($table->getColumn('column_varbinary')->getFixed());
157
158			self::assertInstanceOf(BlobType::class, $table->getColumn('column_binary')->getType());
159			self::assertFalse($table->getColumn('column_binary')->getFixed());
160			}
161
162			public function testNonDefaultPKOrder() : void
163			{
164			if (! extension_loaded('sqlite3')) {
165			$this->markTestSkipped('This test requires the SQLite3 extension.');
166			}
167
168			$version = SQLite3::version();
169			if (version_compare($version['versionString'], '3.7.16', '<')) {
170			$this->markTestSkipped('This version of sqlite doesn\'t return the order of the Primary Key.');
171			}
172			$this->connection->exec(<<<EOS
173			CREATE TABLE non_default_pk_order (
174			id INTEGER,
175			other_id INTEGER,
176			PRIMARY KEY(other_id, id)
177			)
178			EOS
179			);
180
181			$tableIndexes = $this->schemaManager->listTableIndexes('non_default_pk_order');
182
183			self::assertCount(1, $tableIndexes);
184
185			self::assertArrayHasKey('primary', $tableIndexes, 'listTableIndexes() has to return a "primary" array key.');
186			self::assertEquals(['other_id', 'id'], array_map('strtolower', $tableIndexes['primary']->getColumns()));
187			}
188
189			/**
190			* @group DBAL-1779
191			*/
192			public function testListTableColumnsWithWhitespacesInTypeDeclarations() : void
193			{
194			$sql = <<<SQL
195			CREATE TABLE dbal_1779 (
196			foo VARCHAR (64) ,
197			bar TEXT (100)
198			)
199			SQL;
200
201			$this->connection->exec($sql);
202
203			$columns = $this->schemaManager->listTableColumns('dbal_1779');
204
205			self::assertCount(2, $columns);
206
207			self::assertArrayHasKey('foo', $columns);
208			self::assertArrayHasKey('bar', $columns);
209
210			self::assertSame(Type::getType(Types::STRING), $columns['foo']->getType());
211			self::assertSame(Type::getType(Types::TEXT), $columns['bar']->getType());
212
213			self::assertSame(64, $columns['foo']->getLength());
214			self::assertSame(100, $columns['bar']->getLength());
215			}
216
217			/**
218			* @dataProvider getDiffListIntegerAutoincrementTableColumnsData
219			* @group DBAL-924
220			*/
221			public function testDiffListIntegerAutoincrementTableColumns(string $integerType, bool $unsigned, bool $expectedComparatorDiff) : void
222			{
223			$tableName = 'test_int_autoincrement_table';
224
225			$offlineTable = new Table($tableName);
226			$offlineTable->addColumn('id', $integerType, ['autoincrement' => true, 'unsigned' => $unsigned]);
227			$offlineTable->setPrimaryKey(['id']);
228
229			$this->schemaManager->dropAndCreateTable($offlineTable);
230
231			$onlineTable = $this->schemaManager->listTableDetails($tableName);
232			$comparator = new Schema\Comparator();
233			$diff = $comparator->diffTable($offlineTable, $onlineTable);
234
235			if ($expectedComparatorDiff) {
236			self::assertEmpty($this->schemaManager->getDatabasePlatform()->getAlterTableSQL($diff));
237			} else {
238			self::assertFalse($diff);
239			}
240			}
241
242			/**
243			* @return mixed[][]
244			*/
245			public static function getDiffListIntegerAutoincrementTableColumnsData() : iterable
246			{
247			return [
248			['smallint', false, true],
249			['smallint', true, true],
250			['integer', false, false],
251			['integer', true, true],
252			['bigint', false, true],
253			['bigint', true, true],
254			];
255			}
256
257			/**
258			* @group DBAL-2921
259			*/
260			public function testPrimaryKeyNoAutoIncrement() : void
261			{
262			$table = new Schema\Table('test_pk_auto_increment');
263			$table->addColumn('id', 'integer');
264			$table->addColumn('text', 'text');
265			$table->setPrimaryKey(['id']);
266			$this->schemaManager->dropAndCreateTable($table);
267
268			$this->connection->insert('test_pk_auto_increment', ['text' => '1']);
269
270			$this->connection->query('DELETE FROM test_pk_auto_increment');
271
272			$this->connection->insert('test_pk_auto_increment', ['text' => '2']);
273
274			$query = $this->connection->query('SELECT id FROM test_pk_auto_increment WHERE text = "2"');
275			$query->execute();
276			$lastUsedIdAfterDelete = (int) $query->fetchColumn();
277
278			// with an empty table, non autoincrement rowid is always 1
279			$this->assertEquals(1, $lastUsedIdAfterDelete);
280			}
281
282			public function testOnlyOwnCommentIsParsed() : void
283			{
284			$table = new Table('test');
285			$table->addColumn('col1', 'string', ['length' => 16]);
286			$table->addColumn('col2', 'string', ['length' => 16, 'comment' => 'Column #2']);
287			$table->addColumn('col3', 'string', ['length' => 16]);
288
289			$sm = $this->connection->getSchemaManager();
290			$sm->createTable($table);
291
292			$this->assertNull($sm->listTableDetails('test')
293			->getColumn('col1')
294			->getComment());
295			}
296			}
297

doctrine / dbal

Pull Request — 2.10.x (#3939)

SqliteSchemaManagerTest::testRenameTable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like