SchemaTest::testDropSequenceIfExists() - Code Metrics - Inspection of "Add IfExists and IfNotExists convenience methods t..." - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#3535)

by Jonathan

created 2019-04-29 22:26 UTC

SchemaTest::testDropSequenceIfExists() A

↳ Parent: SchemaTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Doctrine\Tests\DBAL\Schema;

use Doctrine\DBAL\Schema\Schema;
use Doctrine\DBAL\Schema\SchemaConfig;
use Doctrine\DBAL\Schema\SchemaException;
use Doctrine\DBAL\Schema\Sequence;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Schema\Visitor\AbstractVisitor;
use Doctrine\DBAL\Schema\Visitor\Visitor;
use PHPUnit\Framework\TestCase;
use ReflectionProperty;
use function current;
use function strlen;

class SchemaTest extends TestCase
{
    public function testAddTable()
    {
        $tableName = 'public.foo';
        $table     = new Table($tableName);

        $schema = new Schema([$table]);

        self::assertTrue($schema->hasTable($tableName));

        $tables = $schema->getTables();
        self::assertArrayHasKey($tableName, $tables);
        self::assertSame($table, $tables[$tableName]);
        self::assertSame($table, $schema->getTable($tableName));
        self::assertTrue($schema->hasTable($tableName));
    }

    public function testTableMatchingCaseInsensitive()
    {
        $table = new Table('Foo');

        $schema = new Schema([$table]);
        self::assertTrue($schema->hasTable('foo'));
        self::assertTrue($schema->hasTable('FOO'));

        self::assertSame($table, $schema->getTable('FOO'));
        self::assertSame($table, $schema->getTable('foo'));
        self::assertSame($table, $schema->getTable('Foo'));
    }

    public function testGetUnknownTableThrowsException()
    {
        $this->expectException(SchemaException::class);

        $schema = new Schema();
        $schema->getTable('unknown');
    }

    public function testCreateTableTwiceThrowsException()
    {
        $this->expectException(SchemaException::class);

        $tableName = 'foo';
        $table     = new Table($tableName);
        $tables    = [$table, $table];

        $schema = new Schema($tables);

    }

    public function testRenameTable()
    {
        $tableName = 'foo';
        $table     = new Table($tableName);
        $schema    = new Schema([$table]);

        self::assertTrue($schema->hasTable('foo'));
        $schema->renameTable('foo', 'bar');
        self::assertFalse($schema->hasTable('foo'));
        self::assertTrue($schema->hasTable('bar'));
        self::assertSame($table, $schema->getTable('bar'));
    }

    public function testDropTable()
    {
        $tableName = 'foo';
        $table     = new Table($tableName);
        $schema    = new Schema([$table]);

        self::assertTrue($schema->hasTable('foo'));

        $schema->dropTable('foo');

        self::assertFalse($schema->hasTable('foo'));
    }

    public function testDropTableIfExists() : void
    {
        $table  = new Table('foo');
        $schema = new Schema([$table]);

        self::assertTrue($schema->hasTable('foo'));

        $schema->dropTableIfExists('foo');

        self::assertFalse($schema->hasTable('foo'));

        $schema->dropTableIfExists('foo');
    }

    public function testCreateTable()
    {
        $schema = new Schema();

        self::assertFalse($schema->hasTable('foo'));

        $table = $schema->createTable('foo');

        self::assertInstanceOf(Table::class, $table);
        self::assertEquals('foo', $table->getName());
        self::assertTrue($schema->hasTable('foo'));
    }

    public function testCreateTableIfNotExists() : void
    {
        $schema = new Schema();

        $table = $schema->createTableIfNotExists('foo');

        self::assertSame($table, $schema->createTableIfNotExists('foo'));
    }

    public function testAddSequences()
    {
        $sequence = new Sequence('a_seq', 1, 1);

        $schema = new Schema([], [$sequence]);

        self::assertTrue($schema->hasSequence('a_seq'));
        self::assertInstanceOf(Sequence::class, $schema->getSequence('a_seq'));

        $sequences = $schema->getSequences();
        self::assertArrayHasKey('public.a_seq', $sequences);
    }

    public function testSequenceAccessCaseInsensitive()
    {
        $sequence = new Sequence('a_Seq');

        $schema = new Schema([], [$sequence]);
        self::assertTrue($schema->hasSequence('a_seq'));
        self::assertTrue($schema->hasSequence('a_Seq'));
        self::assertTrue($schema->hasSequence('A_SEQ'));

        self::assertEquals($sequence, $schema->getSequence('a_seq'));
        self::assertEquals($sequence, $schema->getSequence('a_Seq'));
        self::assertEquals($sequence, $schema->getSequence('A_SEQ'));
    }

    public function testGetUnknownSequenceThrowsException()
    {
        $this->expectException(SchemaException::class);

        $schema = new Schema();
        $schema->getSequence('unknown');
    }

    public function testCreateSequence()
    {
        $schema   = new Schema();
        $sequence = $schema->createSequence('a_seq', 10, 20);

        self::assertEquals('a_seq', $sequence->getName());
        self::assertEquals(10, $sequence->getAllocationSize());
        self::assertEquals(20, $sequence->getInitialValue());

        self::assertTrue($schema->hasSequence('a_seq'));
        self::assertInstanceOf(Sequence::class, $schema->getSequence('a_seq'));

        $sequences = $schema->getSequences();
        self::assertArrayHasKey('public.a_seq', $sequences);
    }

    public function testCreateSequenceIfNotExists() : void
    {
        $schema   = new Schema();
        $sequence = $schema->createSequenceIfNotExists('a_seq', 10, 20);

        self::assertSame($sequence, $schema->createSequenceIfNotExists('a_seq', 10, 20));
    }

    public function testDropSequence()
    {
        $sequence = new Sequence('a_seq', 1, 1);

        $schema = new Schema([], [$sequence]);

        $schema->dropSequence('a_seq');
        self::assertFalse($schema->hasSequence('a_seq'));
    }

    public function testDropSequenceIfExists() : void
    {
        $sequence = new Sequence('a_seq', 1, 1);

        $schema = new Schema([], [$sequence]);

        $schema->dropSequenceIfExists('a_seq');

        self::assertFalse($schema->hasSequence('a_seq'));

        $schema->dropSequenceIfExists('a_seq');
    }

    public function testAddSequenceTwiceThrowsException()
    {
        $this->expectException(SchemaException::class);

        $sequence = new Sequence('a_seq', 1, 1);

        $schema = new Schema([], [$sequence, $sequence]);

    }

    public function testConfigMaxIdentifierLength()
    {
        $schemaConfig = new SchemaConfig();
        $schemaConfig->setMaxIdentifierLength(5);

        $schema = new Schema([], [], $schemaConfig);
        $table  = $schema->createTable('smalltable');
        $table->addColumn('long_id', 'integer');
        $table->addIndex(['long_id']);

        $index = current($table->getIndexes());
        self::assertEquals(5, strlen($index->getName()));
    }

    public function testDeepClone()
    {
        $schema   = new Schema();
        $sequence = $schema->createSequence('baz');

        $tableA = $schema->createTable('foo');
        $tableA->addColumn('id', 'integer');

        $tableB = $schema->createTable('bar');
        $tableB->addColumn('id', 'integer');
        $tableB->addColumn('foo_id', 'integer');
        $tableB->addForeignKeyConstraint($tableA, ['foo_id'], ['id']);

        $schemaNew = clone $schema;

        self::assertNotSame($sequence, $schemaNew->getSequence('baz'));

        self::assertNotSame($tableA, $schemaNew->getTable('foo'));
        self::assertNotSame($tableA->getColumn('id'), $schemaNew->getTable('foo')->getColumn('id'));

        self::assertNotSame($tableB, $schemaNew->getTable('bar'));
        self::assertNotSame($tableB->getColumn('id'), $schemaNew->getTable('bar')->getColumn('id'));

        $fk = $schemaNew->getTable('bar')->getForeignKeys();
        $fk = current($fk);

        $re = new ReflectionProperty($fk, '_localTable');
        $re->setAccessible(true);

        self::assertSame($schemaNew->getTable('bar'), $re->getValue($fk));
    }

    /**
     * @group DBAL-219
     */
    public function testHasTableForQuotedAsset()
    {
        $schema = new Schema();

        $tableA = $schema->createTable('foo');
        $tableA->addColumn('id', 'integer');

        self::assertTrue($schema->hasTable('`foo`'));
    }

    /**
     * @group DBAL-669
     */
    public function testHasNamespace()
    {
        $schema = new Schema();

        self::assertFalse($schema->hasNamespace('foo'));

        $schema->createTable('foo');

        self::assertFalse($schema->hasNamespace('foo'));

        $schema->createTable('bar.baz');

        self::assertFalse($schema->hasNamespace('baz'));
        self::assertTrue($schema->hasNamespace('bar'));
        self::assertFalse($schema->hasNamespace('tab'));

        $schema->createTable('tab.taz');

        self::assertTrue($schema->hasNamespace('tab'));
    }

    /**
     * @group DBAL-669
     */
    public function testCreatesNamespace()
    {
        $schema = new Schema();

        self::assertFalse($schema->hasNamespace('foo'));

        $schema->createNamespace('foo');

        self::assertTrue($schema->hasNamespace('foo'));
        self::assertTrue($schema->hasNamespace('FOO'));
        self::assertTrue($schema->hasNamespace('`foo`'));
        self::assertTrue($schema->hasNamespace('`FOO`'));

        $schema->createNamespace('`bar`');

        self::assertTrue($schema->hasNamespace('bar'));
        self::assertTrue($schema->hasNamespace('BAR'));
        self::assertTrue($schema->hasNamespace('`bar`'));
        self::assertTrue($schema->hasNamespace('`BAR`'));

        self::assertSame(['foo' => 'foo', 'bar' => '`bar`'], $schema->getNamespaces());
    }

    /**
     * @group DBAL-669
     */
    public function testThrowsExceptionOnCreatingNamespaceTwice()
    {
        $schema = new Schema();

        $schema->createNamespace('foo');

        $this->expectException(SchemaException::class);

        $schema->createNamespace('foo');
    }

    /**
     * @group DBAL-669
     */
    public function testCreatesNamespaceThroughAddingTableImplicitly()
    {
        $schema = new Schema();

        self::assertFalse($schema->hasNamespace('foo'));

        $schema->createTable('baz');

        self::assertFalse($schema->hasNamespace('foo'));
        self::assertFalse($schema->hasNamespace('baz'));

        $schema->createTable('foo.bar');

        self::assertTrue($schema->hasNamespace('foo'));
        self::assertFalse($schema->hasNamespace('bar'));

        $schema->createTable('`baz`.bloo');

        self::assertTrue($schema->hasNamespace('baz'));
        self::assertFalse($schema->hasNamespace('bloo'));

        $schema->createTable('`baz`.moo');

        self::assertTrue($schema->hasNamespace('baz'));
        self::assertFalse($schema->hasNamespace('moo'));
    }

    /**
     * @group DBAL-669
     */
    public function testCreatesNamespaceThroughAddingSequenceImplicitly()
    {
        $schema = new Schema();

        self::assertFalse($schema->hasNamespace('foo'));

        $schema->createSequence('baz');

        self::assertFalse($schema->hasNamespace('foo'));
        self::assertFalse($schema->hasNamespace('baz'));

        $schema->createSequence('foo.bar');

        self::assertTrue($schema->hasNamespace('foo'));
        self::assertFalse($schema->hasNamespace('bar'));

        $schema->createSequence('`baz`.bloo');

        self::assertTrue($schema->hasNamespace('baz'));
        self::assertFalse($schema->hasNamespace('bloo'));

        $schema->createSequence('`baz`.moo');

        self::assertTrue($schema->hasNamespace('baz'));
        self::assertFalse($schema->hasNamespace('moo'));
    }

    public function testCreateNamespaceIfNotExists() : void
    {
        $schema = new Schema();

        $schema->createNamespaceIfNotExists('namespace');

        self::assertTrue($schema->hasNamespace('namespace'));
        self::assertCount(1, $schema->getNamespaces());

        $schema->createNamespaceIfNotExists('namespace');

        self::assertCount(1, $schema->getNamespaces());
    }

    /**
     * @group DBAL-669
     */
    public function testVisitsVisitor()
    {
        $schema  = new Schema();
        $visitor = $this->createMock(Visitor::class);

        $schema->createNamespace('foo');
        $schema->createNamespace('bar');

        $schema->createTable('baz');
        $schema->createTable('bla.bloo');

        $schema->createSequence('moo');
        $schema->createSequence('war');

        $visitor->expects($this->once())
            ->method('acceptSchema')
            ->with($schema);

        $visitor->expects($this->at(1))
            ->method('acceptTable')
            ->with($schema->getTable('baz'));

        $visitor->expects($this->at(2))
            ->method('acceptTable')
            ->with($schema->getTable('bla.bloo'));

        $visitor->expects($this->exactly(2))
            ->method('acceptTable');

        $visitor->expects($this->at(3))
            ->method('acceptSequence')
            ->with($schema->getSequence('moo'));

        $visitor->expects($this->at(4))
            ->method('acceptSequence')
            ->with($schema->getSequence('war'));

        $visitor->expects($this->exactly(2))
            ->method('acceptSequence');

        self::assertNull($schema->visit($visitor));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @group DBAL-669
     */
    public function testVisitsNamespaceVisitor()
    {
        $schema  = new Schema();
        $visitor = $this->createMock(AbstractVisitor::class);

        $schema->createNamespace('foo');
        $schema->createNamespace('bar');

        $schema->createTable('baz');
        $schema->createTable('bla.bloo');

        $schema->createSequence('moo');
        $schema->createSequence('war');

        $visitor->expects($this->once())
            ->method('acceptSchema')
            ->with($schema);

        $visitor->expects($this->at(1))
            ->method('acceptNamespace')
            ->with('foo');

        $visitor->expects($this->at(2))
            ->method('acceptNamespace')
            ->with('bar');

        $visitor->expects($this->at(3))
            ->method('acceptNamespace')
            ->with('bla');

        $visitor->expects($this->exactly(3))
            ->method('acceptNamespace');

        $visitor->expects($this->at(4))
            ->method('acceptTable')
            ->with($schema->getTable('baz'));

        $visitor->expects($this->at(5))
            ->method('acceptTable')
            ->with($schema->getTable('bla.bloo'));

        $visitor->expects($this->exactly(2))
            ->method('acceptTable');

        $visitor->expects($this->at(6))
            ->method('acceptSequence')
            ->with($schema->getSequence('moo'));

        $visitor->expects($this->at(7))
            ->method('acceptSequence')
            ->with($schema->getSequence('war'));

        $visitor->expects($this->exactly(2))
            ->method('acceptSequence');

        self::assertNull($schema->visit($visitor));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }
}


1			<?php
2
3			namespace Doctrine\Tests\DBAL\Schema;
4
5			use Doctrine\DBAL\Schema\Schema;
6			use Doctrine\DBAL\Schema\SchemaConfig;
7			use Doctrine\DBAL\Schema\SchemaException;
8			use Doctrine\DBAL\Schema\Sequence;
9			use Doctrine\DBAL\Schema\Table;
10			use Doctrine\DBAL\Schema\Visitor\AbstractVisitor;
11			use Doctrine\DBAL\Schema\Visitor\Visitor;
12			use PHPUnit\Framework\TestCase;
13			use ReflectionProperty;
14			use function current;
15			use function strlen;
16
17			class SchemaTest extends TestCase
18			{
19			public function testAddTable()
20			{
21			$tableName = 'public.foo';
22			$table = new Table($tableName);
23
24			$schema = new Schema([$table]);
25
26			self::assertTrue($schema->hasTable($tableName));
27
28			$tables = $schema->getTables();
29			self::assertArrayHasKey($tableName, $tables);
30			self::assertSame($table, $tables[$tableName]);
31			self::assertSame($table, $schema->getTable($tableName));
32			self::assertTrue($schema->hasTable($tableName));
33			}
34
35			public function testTableMatchingCaseInsensitive()
36			{
37			$table = new Table('Foo');
38
39			$schema = new Schema([$table]);
40			self::assertTrue($schema->hasTable('foo'));
41			self::assertTrue($schema->hasTable('FOO'));
42
43			self::assertSame($table, $schema->getTable('FOO'));
44			self::assertSame($table, $schema->getTable('foo'));
45			self::assertSame($table, $schema->getTable('Foo'));
46			}
47
48			public function testGetUnknownTableThrowsException()
49			{
50			$this->expectException(SchemaException::class);
51
52			$schema = new Schema();
53			$schema->getTable('unknown');
54			}
55
56			public function testCreateTableTwiceThrowsException()
57			{
58			$this->expectException(SchemaException::class);
59
60			$tableName = 'foo';
61			$table = new Table($tableName);
62			$tables = [$table, $table];
63
64			$schema = new Schema($tables);
			0 ignored issues – show Unused Code introduced 2017-11-18 19:58 UTC by Report Bug Copy Issue Report The assignment to `$schema` is dead and can be removed. Loading history...
65			}
66
67			public function testRenameTable()
68			{
69			$tableName = 'foo';
70			$table = new Table($tableName);
71			$schema = new Schema([$table]);
72
73			self::assertTrue($schema->hasTable('foo'));
74			$schema->renameTable('foo', 'bar');
75			self::assertFalse($schema->hasTable('foo'));
76			self::assertTrue($schema->hasTable('bar'));
77			self::assertSame($table, $schema->getTable('bar'));
78			}
79
80			public function testDropTable()
81			{
82			$tableName = 'foo';
83			$table = new Table($tableName);
84			$schema = new Schema([$table]);
85
86			self::assertTrue($schema->hasTable('foo'));
87
88			$schema->dropTable('foo');
89
90			self::assertFalse($schema->hasTable('foo'));
91			}
92
93			public function testDropTableIfExists() : void
94			{
95			$table = new Table('foo');
96			$schema = new Schema([$table]);
97
98			self::assertTrue($schema->hasTable('foo'));
99
100			$schema->dropTableIfExists('foo');
101
102			self::assertFalse($schema->hasTable('foo'));
103
104			$schema->dropTableIfExists('foo');
105			}
106
107			public function testCreateTable()
108			{
109			$schema = new Schema();
110
111			self::assertFalse($schema->hasTable('foo'));
112
113			$table = $schema->createTable('foo');
114
115			self::assertInstanceOf(Table::class, $table);
116			self::assertEquals('foo', $table->getName());
117			self::assertTrue($schema->hasTable('foo'));
118			}
119
120			public function testCreateTableIfNotExists() : void
121			{
122			$schema = new Schema();
123
124			$table = $schema->createTableIfNotExists('foo');
125
126			self::assertSame($table, $schema->createTableIfNotExists('foo'));
127			}
128
129			public function testAddSequences()
130			{
131			$sequence = new Sequence('a_seq', 1, 1);
132
133			$schema = new Schema([], [$sequence]);
134
135			self::assertTrue($schema->hasSequence('a_seq'));
136			self::assertInstanceOf(Sequence::class, $schema->getSequence('a_seq'));
137
138			$sequences = $schema->getSequences();
139			self::assertArrayHasKey('public.a_seq', $sequences);
140			}
141
142			public function testSequenceAccessCaseInsensitive()
143			{
144			$sequence = new Sequence('a_Seq');
145
146			$schema = new Schema([], [$sequence]);
147			self::assertTrue($schema->hasSequence('a_seq'));
148			self::assertTrue($schema->hasSequence('a_Seq'));
149			self::assertTrue($schema->hasSequence('A_SEQ'));
150
151			self::assertEquals($sequence, $schema->getSequence('a_seq'));
152			self::assertEquals($sequence, $schema->getSequence('a_Seq'));
153			self::assertEquals($sequence, $schema->getSequence('A_SEQ'));
154			}
155
156			public function testGetUnknownSequenceThrowsException()
157			{
158			$this->expectException(SchemaException::class);
159
160			$schema = new Schema();
161			$schema->getSequence('unknown');
162			}
163
164			public function testCreateSequence()
165			{
166			$schema = new Schema();
167			$sequence = $schema->createSequence('a_seq', 10, 20);
168
169			self::assertEquals('a_seq', $sequence->getName());
170			self::assertEquals(10, $sequence->getAllocationSize());
171			self::assertEquals(20, $sequence->getInitialValue());
172
173			self::assertTrue($schema->hasSequence('a_seq'));
174			self::assertInstanceOf(Sequence::class, $schema->getSequence('a_seq'));
175
176			$sequences = $schema->getSequences();
177			self::assertArrayHasKey('public.a_seq', $sequences);
178			}
179
180			public function testCreateSequenceIfNotExists() : void
181			{
182			$schema = new Schema();
183			$sequence = $schema->createSequenceIfNotExists('a_seq', 10, 20);
184
185			self::assertSame($sequence, $schema->createSequenceIfNotExists('a_seq', 10, 20));
186			}
187
188			public function testDropSequence()
189			{
190			$sequence = new Sequence('a_seq', 1, 1);
191
192			$schema = new Schema([], [$sequence]);
193
194			$schema->dropSequence('a_seq');
195			self::assertFalse($schema->hasSequence('a_seq'));
196			}
197
198			public function testDropSequenceIfExists() : void
199			{
200			$sequence = new Sequence('a_seq', 1, 1);
201
202			$schema = new Schema([], [$sequence]);
203
204			$schema->dropSequenceIfExists('a_seq');
205
206			self::assertFalse($schema->hasSequence('a_seq'));
207
208			$schema->dropSequenceIfExists('a_seq');
209			}
210
211			public function testAddSequenceTwiceThrowsException()
212			{
213			$this->expectException(SchemaException::class);
214
215			$sequence = new Sequence('a_seq', 1, 1);
216
217			$schema = new Schema([], [$sequence, $sequence]);
			0 ignored issues – show Unused Code introduced 2018-01-29 02:49 UTC by Report Bug Copy Issue Report The assignment to `$schema` is dead and can be removed. Loading history...
218			}
219
220			public function testConfigMaxIdentifierLength()
221			{
222			$schemaConfig = new SchemaConfig();
223			$schemaConfig->setMaxIdentifierLength(5);
224
225			$schema = new Schema([], [], $schemaConfig);
226			$table = $schema->createTable('smalltable');
227			$table->addColumn('long_id', 'integer');
228			$table->addIndex(['long_id']);
229
230			$index = current($table->getIndexes());
231			self::assertEquals(5, strlen($index->getName()));
232			}
233
234			public function testDeepClone()
235			{
236			$schema = new Schema();
237			$sequence = $schema->createSequence('baz');
238
239			$tableA = $schema->createTable('foo');
240			$tableA->addColumn('id', 'integer');
241
242			$tableB = $schema->createTable('bar');
243			$tableB->addColumn('id', 'integer');
244			$tableB->addColumn('foo_id', 'integer');
245			$tableB->addForeignKeyConstraint($tableA, ['foo_id'], ['id']);
246
247			$schemaNew = clone $schema;
248
249			self::assertNotSame($sequence, $schemaNew->getSequence('baz'));
250
251			self::assertNotSame($tableA, $schemaNew->getTable('foo'));
252			self::assertNotSame($tableA->getColumn('id'), $schemaNew->getTable('foo')->getColumn('id'));
253
254			self::assertNotSame($tableB, $schemaNew->getTable('bar'));
255			self::assertNotSame($tableB->getColumn('id'), $schemaNew->getTable('bar')->getColumn('id'));
256
257			$fk = $schemaNew->getTable('bar')->getForeignKeys();
258			$fk = current($fk);
259
260			$re = new ReflectionProperty($fk, '_localTable');
261			$re->setAccessible(true);
262
263			self::assertSame($schemaNew->getTable('bar'), $re->getValue($fk));
264			}
265
266			/**
267			* @group DBAL-219
268			*/
269			public function testHasTableForQuotedAsset()
270			{
271			$schema = new Schema();
272
273			$tableA = $schema->createTable('foo');
274			$tableA->addColumn('id', 'integer');
275
276			self::assertTrue($schema->hasTable('`foo`'));
277			}
278
279			/**
280			* @group DBAL-669
281			*/
282			public function testHasNamespace()
283			{
284			$schema = new Schema();
285
286			self::assertFalse($schema->hasNamespace('foo'));
287
288			$schema->createTable('foo');
289
290			self::assertFalse($schema->hasNamespace('foo'));
291
292			$schema->createTable('bar.baz');
293
294			self::assertFalse($schema->hasNamespace('baz'));
295			self::assertTrue($schema->hasNamespace('bar'));
296			self::assertFalse($schema->hasNamespace('tab'));
297
298			$schema->createTable('tab.taz');
299
300			self::assertTrue($schema->hasNamespace('tab'));
301			}
302
303			/**
304			* @group DBAL-669
305			*/
306			public function testCreatesNamespace()
307			{
308			$schema = new Schema();
309
310			self::assertFalse($schema->hasNamespace('foo'));
311
312			$schema->createNamespace('foo');
313
314			self::assertTrue($schema->hasNamespace('foo'));
315			self::assertTrue($schema->hasNamespace('FOO'));
316			self::assertTrue($schema->hasNamespace('`foo`'));
317			self::assertTrue($schema->hasNamespace('`FOO`'));
318
319			$schema->createNamespace('`bar`');
320
321			self::assertTrue($schema->hasNamespace('bar'));
322			self::assertTrue($schema->hasNamespace('BAR'));
323			self::assertTrue($schema->hasNamespace('`bar`'));
324			self::assertTrue($schema->hasNamespace('`BAR`'));
325
326			self::assertSame(['foo' => 'foo', 'bar' => '`bar`'], $schema->getNamespaces());
327			}
328
329			/**
330			* @group DBAL-669
331			*/
332			public function testThrowsExceptionOnCreatingNamespaceTwice()
333			{
334			$schema = new Schema();
335
336			$schema->createNamespace('foo');
337
338			$this->expectException(SchemaException::class);
339
340			$schema->createNamespace('foo');
341			}
342
343			/**
344			* @group DBAL-669
345			*/
346			public function testCreatesNamespaceThroughAddingTableImplicitly()
347			{
348			$schema = new Schema();
349
350			self::assertFalse($schema->hasNamespace('foo'));
351
352			$schema->createTable('baz');
353
354			self::assertFalse($schema->hasNamespace('foo'));
355			self::assertFalse($schema->hasNamespace('baz'));
356
357			$schema->createTable('foo.bar');
358
359			self::assertTrue($schema->hasNamespace('foo'));
360			self::assertFalse($schema->hasNamespace('bar'));
361
362			$schema->createTable('`baz`.bloo');
363
364			self::assertTrue($schema->hasNamespace('baz'));
365			self::assertFalse($schema->hasNamespace('bloo'));
366
367			$schema->createTable('`baz`.moo');
368
369			self::assertTrue($schema->hasNamespace('baz'));
370			self::assertFalse($schema->hasNamespace('moo'));
371			}
372
373			/**
374			* @group DBAL-669
375			*/
376			public function testCreatesNamespaceThroughAddingSequenceImplicitly()
377			{
378			$schema = new Schema();
379
380			self::assertFalse($schema->hasNamespace('foo'));
381
382			$schema->createSequence('baz');
383
384			self::assertFalse($schema->hasNamespace('foo'));
385			self::assertFalse($schema->hasNamespace('baz'));
386
387			$schema->createSequence('foo.bar');
388
389			self::assertTrue($schema->hasNamespace('foo'));
390			self::assertFalse($schema->hasNamespace('bar'));
391
392			$schema->createSequence('`baz`.bloo');
393
394			self::assertTrue($schema->hasNamespace('baz'));
395			self::assertFalse($schema->hasNamespace('bloo'));
396
397			$schema->createSequence('`baz`.moo');
398
399			self::assertTrue($schema->hasNamespace('baz'));
400			self::assertFalse($schema->hasNamespace('moo'));
401			}
402
403			public function testCreateNamespaceIfNotExists() : void
404			{
405			$schema = new Schema();
406
407			$schema->createNamespaceIfNotExists('namespace');
408
409			self::assertTrue($schema->hasNamespace('namespace'));
410			self::assertCount(1, $schema->getNamespaces());
411
412			$schema->createNamespaceIfNotExists('namespace');
413
414			self::assertCount(1, $schema->getNamespaces());
415			}
416
417			/**
418			* @group DBAL-669
419			*/
420			public function testVisitsVisitor()
421			{
422			$schema = new Schema();
423			$visitor = $this->createMock(Visitor::class);
424
425			$schema->createNamespace('foo');
426			$schema->createNamespace('bar');
427
428			$schema->createTable('baz');
429			$schema->createTable('bla.bloo');
430
431			$schema->createSequence('moo');
432			$schema->createSequence('war');
433
434			$visitor->expects($this->once())
435			->method('acceptSchema')
436			->with($schema);
437
438			$visitor->expects($this->at(1))
439			->method('acceptTable')
440			->with($schema->getTable('baz'));
441
442			$visitor->expects($this->at(2))
443			->method('acceptTable')
444			->with($schema->getTable('bla.bloo'));
445
446			$visitor->expects($this->exactly(2))
447			->method('acceptTable');
448
449			$visitor->expects($this->at(3))
450			->method('acceptSequence')
451			->with($schema->getSequence('moo'));
452
453			$visitor->expects($this->at(4))
454			->method('acceptSequence')
455			->with($schema->getSequence('war'));
456
457			$visitor->expects($this->exactly(2))
458			->method('acceptSequence');
459
460			self::assertNull($schema->visit($visitor));
			0 ignored issues – show Bug introduced 2017-11-18 19:58 UTC by Report Bug Copy Issue Report Are you sure the usage of `$schema->visit($visitor)` targeting `Doctrine\DBAL\Schema\Schema::visit()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
461			}
462
463			/**
464			* @group DBAL-669
465			*/
466			public function testVisitsNamespaceVisitor()
467			{
468			$schema = new Schema();
469			$visitor = $this->createMock(AbstractVisitor::class);
470
471			$schema->createNamespace('foo');
472			$schema->createNamespace('bar');
473
474			$schema->createTable('baz');
475			$schema->createTable('bla.bloo');
476
477			$schema->createSequence('moo');
478			$schema->createSequence('war');
479
480			$visitor->expects($this->once())
481			->method('acceptSchema')
482			->with($schema);
483
484			$visitor->expects($this->at(1))
485			->method('acceptNamespace')
486			->with('foo');
487
488			$visitor->expects($this->at(2))
489			->method('acceptNamespace')
490			->with('bar');
491
492			$visitor->expects($this->at(3))
493			->method('acceptNamespace')
494			->with('bla');
495
496			$visitor->expects($this->exactly(3))
497			->method('acceptNamespace');
498
499			$visitor->expects($this->at(4))
500			->method('acceptTable')
501			->with($schema->getTable('baz'));
502
503			$visitor->expects($this->at(5))
504			->method('acceptTable')
505			->with($schema->getTable('bla.bloo'));
506
507			$visitor->expects($this->exactly(2))
508			->method('acceptTable');
509
510			$visitor->expects($this->at(6))
511			->method('acceptSequence')
512			->with($schema->getSequence('moo'));
513
514			$visitor->expects($this->at(7))
515			->method('acceptSequence')
516			->with($schema->getSequence('war'));
517
518			$visitor->expects($this->exactly(2))
519			->method('acceptSequence');
520
521			self::assertNull($schema->visit($visitor));
			0 ignored issues – show Bug introduced 2017-11-18 19:58 UTC by Report Bug Copy Issue Report Are you sure the usage of `$schema->visit($visitor)` targeting `Doctrine\DBAL\Schema\Schema::visit()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
522			}
523			}
524

doctrine / dbal

Pull Request — master (#3535)

SchemaTest::testDropSequenceIfExists() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like