OracleSchemaManagerTest::testListTableDetailsWithDifferentIdentifierQuotingRequirements() - Code Metrics - Inspection of "Excluded tests from Scrutinizer CI analysis" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#3120)

by Sergei

created 2018-04-29 02:06 UTC

OracleSchemaManagerTest::testListTableDetailsWithDifferentIdentifierQuotingRequirements() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	105
Code Lines	78

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	105
rs	8.2857
c	0
b	0
f	0
cc	1
eloc	78
nc	1
nop	0

How to fix Long Method

<?php

namespace Doctrine\Tests\DBAL\Functional\Schema;

use Doctrine\DBAL\Schema;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\Type;
use Doctrine\Tests\TestUtil;
use function array_map;

class OracleSchemaManagerTest extends SchemaManagerFunctionalTestCase
{
    protected function setUp()
    {
        parent::setUp();

        if(!isset($GLOBALS['db_username'])) {
            $this->markTestSkipped('Foo');
        }

        $username = $GLOBALS['db_username'];

        $query = "GRANT ALL PRIVILEGES TO ".$username;

        $conn = \Doctrine\Tests\TestUtil::getTempConnection();
        $conn->executeUpdate($query);
    }

    public function testRenameTable()
    {
        $this->_sm->tryMethod('DropTable', 'list_tables_test');
        $this->_sm->tryMethod('DropTable', 'list_tables_test_new_name');

        $this->createTestTable('list_tables_test');
        $this->_sm->renameTable('list_tables_test', 'list_tables_test_new_name');

        $tables = $this->_sm->listTables();

        self::assertHasTable($tables, 'list_tables_test_new_name');
    }

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

        $table = new \Doctrine\DBAL\Schema\Table($tableName);
        $table->addColumn('id', 'integer');
        $table->addColumn('column_varbinary', 'binary', array());
        $table->addColumn('column_binary', 'binary', array('fixed' => true));
        $table->setPrimaryKey(array('id'));

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

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

        self::assertInstanceOf('Doctrine\DBAL\Types\BinaryType', $table->getColumn('column_varbinary')->getType());
        self::assertFalse($table->getColumn('column_varbinary')->getFixed());

        self::assertInstanceOf('Doctrine\DBAL\Types\BinaryType', $table->getColumn('column_binary')->getType());
        self::assertFalse($table->getColumn('column_binary')->getFixed());
    }

    /**
     * @group DBAL-472
     * @group DBAL-1001
     */
    public function testAlterTableColumnNotNull()
    {
        $comparator = new Schema\Comparator();
        $tableName  = 'list_table_column_notnull';
        $table      = new Schema\Table($tableName);

        $table->addColumn('id', 'integer');
        $table->addColumn('foo', 'integer');
        $table->addColumn('bar', 'string');
        $table->setPrimaryKey(array('id'));

        $this->_sm->dropAndCreateTable($table);

        $columns = $this->_sm->listTableColumns($tableName);

        self::assertTrue($columns['id']->getNotnull());
        self::assertTrue($columns['foo']->getNotnull());
        self::assertTrue($columns['bar']->getNotnull());

        $diffTable = clone $table;
        $diffTable->changeColumn('foo', array('notnull' => false));
        $diffTable->changeColumn('bar', array('length' => 1024));

        $this->_sm->alterTable($comparator->diffTable($table, $diffTable));

        $columns = $this->_sm->listTableColumns($tableName);

        self::assertTrue($columns['id']->getNotnull());
        self::assertFalse($columns['foo']->getNotnull());
        self::assertTrue($columns['bar']->getNotnull());
    }

    public function testListDatabases()
    {
        // We need the temp connection that has privileges to create a database.
        $sm = TestUtil::getTempConnection()->getSchemaManager();

        $sm->dropAndCreateDatabase('c##test_create_database');

        $databases = $this->_sm->listDatabases();
        $databases = array_map('strtolower', $databases);

        self::assertContains('c##test_create_database', $databases);
    }

    /**
     * @group DBAL-831
     */
    public function testListTableDetailsWithDifferentIdentifierQuotingRequirements()
    {
        $primaryTableName = '"Primary_Table"';
        $offlinePrimaryTable = new Schema\Table($primaryTableName);
        $offlinePrimaryTable->addColumn(
            '"Id"',
            'integer',
            array('autoincrement' => true, 'comment' => 'Explicit casing.')
        );
        $offlinePrimaryTable->addColumn('select', 'integer', array('comment' => 'Reserved keyword.'));
        $offlinePrimaryTable->addColumn('foo', 'integer', array('comment' => 'Implicit uppercasing.'));
        $offlinePrimaryTable->addColumn('BAR', 'integer');
        $offlinePrimaryTable->addColumn('"BAZ"', 'integer');
        $offlinePrimaryTable->addIndex(array('select'), 'from');
        $offlinePrimaryTable->addIndex(array('foo'), 'foo_index');
        $offlinePrimaryTable->addIndex(array('BAR'), 'BAR_INDEX');
        $offlinePrimaryTable->addIndex(array('"BAZ"'), 'BAZ_INDEX');
        $offlinePrimaryTable->setPrimaryKey(array('"Id"'));

        $foreignTableName = 'foreign';
        $offlineForeignTable = new Schema\Table($foreignTableName);
        $offlineForeignTable->addColumn('id', 'integer', array('autoincrement' => true));
        $offlineForeignTable->addColumn('"Fk"', 'integer');
        $offlineForeignTable->addIndex(array('"Fk"'), '"Fk_index"');
        $offlineForeignTable->addForeignKeyConstraint(
            $primaryTableName,
            array('"Fk"'),
            array('"Id"'),
            array(),
            '"Primary_Table_Fk"'
        );
        $offlineForeignTable->setPrimaryKey(array('id'));

        $this->_sm->tryMethod('dropTable', $foreignTableName);
        $this->_sm->tryMethod('dropTable', $primaryTableName);

        $this->_sm->createTable($offlinePrimaryTable);
        $this->_sm->createTable($offlineForeignTable);

        $onlinePrimaryTable = $this->_sm->listTableDetails($primaryTableName);
        $onlineForeignTable = $this->_sm->listTableDetails($foreignTableName);

        $platform = $this->_sm->getDatabasePlatform();

        // Primary table assertions
        self::assertSame($primaryTableName, $onlinePrimaryTable->getQuotedName($platform));

        self::assertTrue($onlinePrimaryTable->hasColumn('"Id"'));
        self::assertSame('"Id"', $onlinePrimaryTable->getColumn('"Id"')->getQuotedName($platform));
        self::assertTrue($onlinePrimaryTable->hasPrimaryKey());
        self::assertSame(array('"Id"'), $onlinePrimaryTable->getPrimaryKey()->getQuotedColumns($platform));

        self::assertTrue($onlinePrimaryTable->hasColumn('select'));
        self::assertSame('"select"', $onlinePrimaryTable->getColumn('select')->getQuotedName($platform));

        self::assertTrue($onlinePrimaryTable->hasColumn('foo'));
        self::assertSame('FOO', $onlinePrimaryTable->getColumn('foo')->getQuotedName($platform));

        self::assertTrue($onlinePrimaryTable->hasColumn('BAR'));
        self::assertSame('BAR', $onlinePrimaryTable->getColumn('BAR')->getQuotedName($platform));

        self::assertTrue($onlinePrimaryTable->hasColumn('"BAZ"'));
        self::assertSame('BAZ', $onlinePrimaryTable->getColumn('"BAZ"')->getQuotedName($platform));

        self::assertTrue($onlinePrimaryTable->hasIndex('from'));
        self::assertTrue($onlinePrimaryTable->getIndex('from')->hasColumnAtPosition('"select"'));
        self::assertSame(array('"select"'), $onlinePrimaryTable->getIndex('from')->getQuotedColumns($platform));

        self::assertTrue($onlinePrimaryTable->hasIndex('foo_index'));
        self::assertTrue($onlinePrimaryTable->getIndex('foo_index')->hasColumnAtPosition('foo'));
        self::assertSame(array('FOO'), $onlinePrimaryTable->getIndex('foo_index')->getQuotedColumns($platform));

        self::assertTrue($onlinePrimaryTable->hasIndex('BAR_INDEX'));
        self::assertTrue($onlinePrimaryTable->getIndex('BAR_INDEX')->hasColumnAtPosition('BAR'));
        self::assertSame(array('BAR'), $onlinePrimaryTable->getIndex('BAR_INDEX')->getQuotedColumns($platform));

        self::assertTrue($onlinePrimaryTable->hasIndex('BAZ_INDEX'));
        self::assertTrue($onlinePrimaryTable->getIndex('BAZ_INDEX')->hasColumnAtPosition('"BAZ"'));
        self::assertSame(array('BAZ'), $onlinePrimaryTable->getIndex('BAZ_INDEX')->getQuotedColumns($platform));

        // Foreign table assertions
        self::assertTrue($onlineForeignTable->hasColumn('id'));
        self::assertSame('ID', $onlineForeignTable->getColumn('id')->getQuotedName($platform));
        self::assertTrue($onlineForeignTable->hasPrimaryKey());
        self::assertSame(array('ID'), $onlineForeignTable->getPrimaryKey()->getQuotedColumns($platform));

        self::assertTrue($onlineForeignTable->hasColumn('"Fk"'));
        self::assertSame('"Fk"', $onlineForeignTable->getColumn('"Fk"')->getQuotedName($platform));

        self::assertTrue($onlineForeignTable->hasIndex('"Fk_index"'));
        self::assertTrue($onlineForeignTable->getIndex('"Fk_index"')->hasColumnAtPosition('"Fk"'));
        self::assertSame(array('"Fk"'), $onlineForeignTable->getIndex('"Fk_index"')->getQuotedColumns($platform));

        self::assertTrue($onlineForeignTable->hasForeignKey('"Primary_Table_Fk"'));
        self::assertSame(
            $primaryTableName,
            $onlineForeignTable->getForeignKey('"Primary_Table_Fk"')->getQuotedForeignTableName($platform)
        );
        self::assertSame(
            array('"Fk"'),
            $onlineForeignTable->getForeignKey('"Primary_Table_Fk"')->getQuotedLocalColumns($platform)
        );
        self::assertSame(
            array('"Id"'),
            $onlineForeignTable->getForeignKey('"Primary_Table_Fk"')->getQuotedForeignColumns($platform)
        );
    }

    public function testListTableColumnsSameTableNamesInDifferentSchemas()
    {
        $table = $this->createListTableColumns();
        $this->_sm->dropAndCreateTable($table);

        $otherTable = new Table($table->getName());
        $otherTable->addColumn('id', Type::STRING);
        TestUtil::getTempConnection()->getSchemaManager()->dropAndCreateTable($otherTable);

        $columns = $this->_sm->listTableColumns($table->getName(), $this->_conn->getUsername());
        self::assertCount(7, $columns);
    }

    /**
     * @group DBAL-1234
     */
    public function testListTableIndexesPrimaryKeyConstraintNameDiffersFromIndexName()
    {
        $table = new Table('list_table_indexes_pk_id_test');
        $table->setSchemaConfig($this->_sm->createSchemaConfig());
        $table->addColumn('id', 'integer', array('notnull' => true));
        $table->addUniqueIndex(array('id'), 'id_unique_index');
        $this->_sm->dropAndCreateTable($table);

        // Adding a primary key on already indexed columns
        // Oracle will reuse the unique index, which cause a constraint name differing from the index name
        $this->_sm->createConstraint(new Schema\Index('id_pk_id_index', array('id'), true, true), 'list_table_indexes_pk_id_test');

        $tableIndexes = $this->_sm->listTableIndexes('list_table_indexes_pk_id_test');

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

    /**
     * @group DBAL-2555
     */
    public function testListTableDateTypeColumns()
    {
        $table = new Table('tbl_date');
        $table->addColumn('col_date', 'date');
        $table->addColumn('col_datetime', 'datetime');
        $table->addColumn('col_datetimetz', 'datetimetz');

        $this->_sm->dropAndCreateTable($table);

        $columns = $this->_sm->listTableColumns('tbl_date');

        self::assertSame('date', $columns['col_date']->getType()->getName());
        self::assertSame('datetime', $columns['col_datetime']->getType()->getName());
        self::assertSame('datetimetz', $columns['col_datetimetz']->getType()->getName());
    }

    public function testCreateAndListSequences() : void
    {
        self::markTestSkipped("Skipped for uppercase letters are contained in sequences' names. Fix the schema manager in 3.0.");
    }
}


1			<?php
2
3			namespace Doctrine\Tests\DBAL\Functional\Schema;
4
5			use Doctrine\DBAL\Schema;
6			use Doctrine\DBAL\Schema\Table;
7			use Doctrine\DBAL\Types\Type;
8			use Doctrine\Tests\TestUtil;
9			use function array_map;
10
11			class OracleSchemaManagerTest extends SchemaManagerFunctionalTestCase
12			{
13			protected function setUp()
14			{
15			parent::setUp();
16
17			if(!isset($GLOBALS['db_username'])) {
18			$this->markTestSkipped('Foo');
19			}
20
21			$username = $GLOBALS['db_username'];
22
23			$query = "GRANT ALL PRIVILEGES TO ".$username;
24
25			$conn = \Doctrine\Tests\TestUtil::getTempConnection();
26			$conn->executeUpdate($query);
27			}
28
29			public function testRenameTable()
30			{
31			$this->_sm->tryMethod('DropTable', 'list_tables_test');
32			$this->_sm->tryMethod('DropTable', 'list_tables_test_new_name');
33
34			$this->createTestTable('list_tables_test');
35			$this->_sm->renameTable('list_tables_test', 'list_tables_test_new_name');
36
37			$tables = $this->_sm->listTables();
38
39			self::assertHasTable($tables, 'list_tables_test_new_name');
40			}
41
42			public function testListTableWithBinary()
43			{
44			$tableName = 'test_binary_table';
45
46			$table = new \Doctrine\DBAL\Schema\Table($tableName);
47			$table->addColumn('id', 'integer');
48			$table->addColumn('column_varbinary', 'binary', array());
49			$table->addColumn('column_binary', 'binary', array('fixed' => true));
50			$table->setPrimaryKey(array('id'));
51
52			$this->_sm->createTable($table);
53
54			$table = $this->_sm->listTableDetails($tableName);
55
56			self::assertInstanceOf('Doctrine\DBAL\Types\BinaryType', $table->getColumn('column_varbinary')->getType());
57			self::assertFalse($table->getColumn('column_varbinary')->getFixed());
58
59			self::assertInstanceOf('Doctrine\DBAL\Types\BinaryType', $table->getColumn('column_binary')->getType());
60			self::assertFalse($table->getColumn('column_binary')->getFixed());
61			}
62
63			/**
64			* @group DBAL-472
65			* @group DBAL-1001
66			*/
67			public function testAlterTableColumnNotNull()
68			{
69			$comparator = new Schema\Comparator();
70			$tableName = 'list_table_column_notnull';
71			$table = new Schema\Table($tableName);
72
73			$table->addColumn('id', 'integer');
74			$table->addColumn('foo', 'integer');
75			$table->addColumn('bar', 'string');
76			$table->setPrimaryKey(array('id'));
77
78			$this->_sm->dropAndCreateTable($table);
79
80			$columns = $this->_sm->listTableColumns($tableName);
81
82			self::assertTrue($columns['id']->getNotnull());
83			self::assertTrue($columns['foo']->getNotnull());
84			self::assertTrue($columns['bar']->getNotnull());
85
86			$diffTable = clone $table;
87			$diffTable->changeColumn('foo', array('notnull' => false));
88			$diffTable->changeColumn('bar', array('length' => 1024));
89
90			$this->_sm->alterTable($comparator->diffTable($table, $diffTable));
91
92			$columns = $this->_sm->listTableColumns($tableName);
93
94			self::assertTrue($columns['id']->getNotnull());
95			self::assertFalse($columns['foo']->getNotnull());
96			self::assertTrue($columns['bar']->getNotnull());
97			}
98
99			public function testListDatabases()
100			{
101			// We need the temp connection that has privileges to create a database.
102			$sm = TestUtil::getTempConnection()->getSchemaManager();
103
104			$sm->dropAndCreateDatabase('c##test_create_database');
105
106			$databases = $this->_sm->listDatabases();
107			$databases = array_map('strtolower', $databases);
108
109			self::assertContains('c##test_create_database', $databases);
110			}
111
112			/**
113			* @group DBAL-831
114			*/
115			public function testListTableDetailsWithDifferentIdentifierQuotingRequirements()
116			{
117			$primaryTableName = '"Primary_Table"';
118			$offlinePrimaryTable = new Schema\Table($primaryTableName);
119			$offlinePrimaryTable->addColumn(
120			'"Id"',
121			'integer',
122			array('autoincrement' => true, 'comment' => 'Explicit casing.')
123			);
124			$offlinePrimaryTable->addColumn('select', 'integer', array('comment' => 'Reserved keyword.'));
125			$offlinePrimaryTable->addColumn('foo', 'integer', array('comment' => 'Implicit uppercasing.'));
126			$offlinePrimaryTable->addColumn('BAR', 'integer');
127			$offlinePrimaryTable->addColumn('"BAZ"', 'integer');
128			$offlinePrimaryTable->addIndex(array('select'), 'from');
129			$offlinePrimaryTable->addIndex(array('foo'), 'foo_index');
130			$offlinePrimaryTable->addIndex(array('BAR'), 'BAR_INDEX');
131			$offlinePrimaryTable->addIndex(array('"BAZ"'), 'BAZ_INDEX');
132			$offlinePrimaryTable->setPrimaryKey(array('"Id"'));
133
134			$foreignTableName = 'foreign';
135			$offlineForeignTable = new Schema\Table($foreignTableName);
136			$offlineForeignTable->addColumn('id', 'integer', array('autoincrement' => true));
137			$offlineForeignTable->addColumn('"Fk"', 'integer');
138			$offlineForeignTable->addIndex(array('"Fk"'), '"Fk_index"');
139			$offlineForeignTable->addForeignKeyConstraint(
140			$primaryTableName,
141			array('"Fk"'),
142			array('"Id"'),
143			array(),
144			'"Primary_Table_Fk"'
145			);
146			$offlineForeignTable->setPrimaryKey(array('id'));
147
148			$this->_sm->tryMethod('dropTable', $foreignTableName);
149			$this->_sm->tryMethod('dropTable', $primaryTableName);
150
151			$this->_sm->createTable($offlinePrimaryTable);
152			$this->_sm->createTable($offlineForeignTable);
153
154			$onlinePrimaryTable = $this->_sm->listTableDetails($primaryTableName);
155			$onlineForeignTable = $this->_sm->listTableDetails($foreignTableName);
156
157			$platform = $this->_sm->getDatabasePlatform();
158
159			// Primary table assertions
160			self::assertSame($primaryTableName, $onlinePrimaryTable->getQuotedName($platform));
161
162			self::assertTrue($onlinePrimaryTable->hasColumn('"Id"'));
163			self::assertSame('"Id"', $onlinePrimaryTable->getColumn('"Id"')->getQuotedName($platform));
164			self::assertTrue($onlinePrimaryTable->hasPrimaryKey());
165			self::assertSame(array('"Id"'), $onlinePrimaryTable->getPrimaryKey()->getQuotedColumns($platform));
166
167			self::assertTrue($onlinePrimaryTable->hasColumn('select'));
168			self::assertSame('"select"', $onlinePrimaryTable->getColumn('select')->getQuotedName($platform));
169
170			self::assertTrue($onlinePrimaryTable->hasColumn('foo'));
171			self::assertSame('FOO', $onlinePrimaryTable->getColumn('foo')->getQuotedName($platform));
172
173			self::assertTrue($onlinePrimaryTable->hasColumn('BAR'));
174			self::assertSame('BAR', $onlinePrimaryTable->getColumn('BAR')->getQuotedName($platform));
175
176			self::assertTrue($onlinePrimaryTable->hasColumn('"BAZ"'));
177			self::assertSame('BAZ', $onlinePrimaryTable->getColumn('"BAZ"')->getQuotedName($platform));
178
179			self::assertTrue($onlinePrimaryTable->hasIndex('from'));
180			self::assertTrue($onlinePrimaryTable->getIndex('from')->hasColumnAtPosition('"select"'));
181			self::assertSame(array('"select"'), $onlinePrimaryTable->getIndex('from')->getQuotedColumns($platform));
182
183			self::assertTrue($onlinePrimaryTable->hasIndex('foo_index'));
184			self::assertTrue($onlinePrimaryTable->getIndex('foo_index')->hasColumnAtPosition('foo'));
185			self::assertSame(array('FOO'), $onlinePrimaryTable->getIndex('foo_index')->getQuotedColumns($platform));
186
187			self::assertTrue($onlinePrimaryTable->hasIndex('BAR_INDEX'));
188			self::assertTrue($onlinePrimaryTable->getIndex('BAR_INDEX')->hasColumnAtPosition('BAR'));
189			self::assertSame(array('BAR'), $onlinePrimaryTable->getIndex('BAR_INDEX')->getQuotedColumns($platform));
190
191			self::assertTrue($onlinePrimaryTable->hasIndex('BAZ_INDEX'));
192			self::assertTrue($onlinePrimaryTable->getIndex('BAZ_INDEX')->hasColumnAtPosition('"BAZ"'));
193			self::assertSame(array('BAZ'), $onlinePrimaryTable->getIndex('BAZ_INDEX')->getQuotedColumns($platform));
194
195			// Foreign table assertions
196			self::assertTrue($onlineForeignTable->hasColumn('id'));
197			self::assertSame('ID', $onlineForeignTable->getColumn('id')->getQuotedName($platform));
198			self::assertTrue($onlineForeignTable->hasPrimaryKey());
199			self::assertSame(array('ID'), $onlineForeignTable->getPrimaryKey()->getQuotedColumns($platform));
200
201			self::assertTrue($onlineForeignTable->hasColumn('"Fk"'));
202			self::assertSame('"Fk"', $onlineForeignTable->getColumn('"Fk"')->getQuotedName($platform));
203
204			self::assertTrue($onlineForeignTable->hasIndex('"Fk_index"'));
205			self::assertTrue($onlineForeignTable->getIndex('"Fk_index"')->hasColumnAtPosition('"Fk"'));
206			self::assertSame(array('"Fk"'), $onlineForeignTable->getIndex('"Fk_index"')->getQuotedColumns($platform));
207
208			self::assertTrue($onlineForeignTable->hasForeignKey('"Primary_Table_Fk"'));
209			self::assertSame(
210			$primaryTableName,
211			$onlineForeignTable->getForeignKey('"Primary_Table_Fk"')->getQuotedForeignTableName($platform)
212			);
213			self::assertSame(
214			array('"Fk"'),
215			$onlineForeignTable->getForeignKey('"Primary_Table_Fk"')->getQuotedLocalColumns($platform)
216			);
217			self::assertSame(
218			array('"Id"'),
219			$onlineForeignTable->getForeignKey('"Primary_Table_Fk"')->getQuotedForeignColumns($platform)
220			);
221			}
222
223			public function testListTableColumnsSameTableNamesInDifferentSchemas()
224			{
225			$table = $this->createListTableColumns();
226			$this->_sm->dropAndCreateTable($table);
227
228			$otherTable = new Table($table->getName());
229			$otherTable->addColumn('id', Type::STRING);
230			TestUtil::getTempConnection()->getSchemaManager()->dropAndCreateTable($otherTable);
231
232			$columns = $this->_sm->listTableColumns($table->getName(), $this->_conn->getUsername());
233			self::assertCount(7, $columns);
234			}
235
236			/**
237			* @group DBAL-1234
238			*/
239			public function testListTableIndexesPrimaryKeyConstraintNameDiffersFromIndexName()
240			{
241			$table = new Table('list_table_indexes_pk_id_test');
242			$table->setSchemaConfig($this->_sm->createSchemaConfig());
243			$table->addColumn('id', 'integer', array('notnull' => true));
244			$table->addUniqueIndex(array('id'), 'id_unique_index');
245			$this->_sm->dropAndCreateTable($table);
246
247			// Adding a primary key on already indexed columns
248			// Oracle will reuse the unique index, which cause a constraint name differing from the index name
249			$this->_sm->createConstraint(new Schema\Index('id_pk_id_index', array('id'), true, true), 'list_table_indexes_pk_id_test');
250
251			$tableIndexes = $this->_sm->listTableIndexes('list_table_indexes_pk_id_test');
252
253			self::assertArrayHasKey('primary', $tableIndexes, 'listTableIndexes() has to return a "primary" array key.');
254			self::assertEquals(array('id'), array_map('strtolower', $tableIndexes['primary']->getColumns()));
255			self::assertTrue($tableIndexes['primary']->isUnique());
256			self::assertTrue($tableIndexes['primary']->isPrimary());
257			}
258
259			/**
260			* @group DBAL-2555
261			*/
262			public function testListTableDateTypeColumns()
263			{
264			$table = new Table('tbl_date');
265			$table->addColumn('col_date', 'date');
266			$table->addColumn('col_datetime', 'datetime');
267			$table->addColumn('col_datetimetz', 'datetimetz');
268
269			$this->_sm->dropAndCreateTable($table);
270
271			$columns = $this->_sm->listTableColumns('tbl_date');
272
273			self::assertSame('date', $columns['col_date']->getType()->getName());
274			self::assertSame('datetime', $columns['col_datetime']->getType()->getName());
275			self::assertSame('datetimetz', $columns['col_datetimetz']->getType()->getName());
276			}
277
278			public function testCreateAndListSequences() : void
279			{
280			self::markTestSkipped("Skipped for uppercase letters are contained in sequences' names. Fix the schema manager in 3.0.");
281			}
282			}
283

doctrine / dbal

Pull Request — master (#3120)

OracleSchemaManagerTest::testListTableDetailsWithDifferentIdentifierQuotingRequirements() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like