SchemaTest::testHasView() - Code Metrics - Inspection of "Schemas with views" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#3233)

by Sergey

created 2018-11-12 19:57 UTC

SchemaTest::testHasView() A

↳ Parent: SchemaTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	9
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\View;
use Doctrine\DBAL\Schema\Visitor\AbstractVisitor;
use Doctrine\DBAL\Schema\Visitor\Visitor;
use PHPUnit\Framework\TestCase;
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 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 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 testDropSequence()
    {
        $sequence = new Sequence('a_seq', 1, 1);

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

        $schema->dropSequence('a_seq');
        self::assertFalse($schema->hasSequence('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');
        $view     = $schema->createView('foz', 'SELECT * FROM `foo`');

        $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($view, $schemaNew->getView('foz'));

        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);
        self::assertSame($schemaNew->getTable('bar'), $this->readAttribute($fk, '_localTable'));
    }

    /**
     * @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
     * @expectedException \Doctrine\DBAL\Schema\SchemaException
     */
    public function testThrowsExceptionOnCreatingNamespaceTwice()
    {
        $schema = new Schema();

        $schema->createNamespace('foo');
        $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'));
    }

    /**
     * @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');

        $schema->createView('foz', 'SELECT * FROM baz');

        $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');

        $visitor->expects($this->at(8))
            ->method('acceptView')
            ->with($schema->getView('foz'));

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

}

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

    public function testConstructWithView()
    {
        $viewName = 'public.foo';
        $view     = new View($viewName, 'SELECT * FROM `bar`');

        $schema = new Schema([], [], null, [], [$view]);

        self::assertTrue($schema->hasView($viewName));

        $views = $schema->getViews();
        self::assertArrayHasKey($viewName, $views);
        self::assertSame($view, $views[$viewName]);
        self::assertSame($view, $schema->getView($viewName));
    }

    public function testViewMatchingCaseInsensitive()
    {
        $view = new View('Foo', 'SELECT * FROM `bar`');

        $schema = new Schema([], [], null, [], [$view]);
        self::assertTrue($schema->hasView('foo'));
        self::assertTrue($schema->hasView('FOO'));

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

    /**
     * @expectedException \Doctrine\DBAL\Schema\SchemaException
     */
    public function testGetUnknownViewThrowsException()
    {
        $schema = new Schema();
        $schema->getView('unknown');
    }

    /**
     * @expectedException \Doctrine\DBAL\Schema\SchemaException
     */
    public function testCreateViewTwiceThrowsException()
    {
        $viewName = 'foo';
        $view     = new View($viewName, 'SELECT * FROM `bar`');
        $views    = [$view, $view];

        new Schema([], [], null, [], $views);
    }

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

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

        $schema->createView('foo', 'SELECT * FROM `bar`');

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

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

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

        $view = $schema->createView('foo', 'SELECT * FROM `bar`');

        self::assertInstanceOf('Doctrine\DBAL\Schema\View', $view);
        self::assertEquals('foo', $view->getName());
        self::assertEquals('SELECT * FROM `bar`', $view->getSql());
        self::assertTrue($schema->hasView('foo'));
    }

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

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

        $schema->createView('foo', 'SELECT * FROM `bar`');

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


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\View;
11			use Doctrine\DBAL\Schema\Visitor\AbstractVisitor;
12			use Doctrine\DBAL\Schema\Visitor\Visitor;
13			use PHPUnit\Framework\TestCase;
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 testCreateTable()
94			{
95			$schema = new Schema();
96
97			self::assertFalse($schema->hasTable('foo'));
98
99			$table = $schema->createTable('foo');
100
101			self::assertInstanceOf(Table::class, $table);
102			self::assertEquals('foo', $table->getName());
103			self::assertTrue($schema->hasTable('foo'));
104			}
105
106			public function testAddSequences()
107			{
108			$sequence = new Sequence('a_seq', 1, 1);
109
110			$schema = new Schema([], [$sequence]);
111
112			self::assertTrue($schema->hasSequence('a_seq'));
113			self::assertInstanceOf(Sequence::class, $schema->getSequence('a_seq'));
114
115			$sequences = $schema->getSequences();
116			self::assertArrayHasKey('public.a_seq', $sequences);
117			}
118
119			public function testSequenceAccessCaseInsensitive()
120			{
121			$sequence = new Sequence('a_Seq');
122
123			$schema = new Schema([], [$sequence]);
124			self::assertTrue($schema->hasSequence('a_seq'));
125			self::assertTrue($schema->hasSequence('a_Seq'));
126			self::assertTrue($schema->hasSequence('A_SEQ'));
127
128			self::assertEquals($sequence, $schema->getSequence('a_seq'));
129			self::assertEquals($sequence, $schema->getSequence('a_Seq'));
130			self::assertEquals($sequence, $schema->getSequence('A_SEQ'));
131			}
132
133			public function testGetUnknownSequenceThrowsException()
134			{
135			$this->expectException(SchemaException::class);
136
137			$schema = new Schema();
138			$schema->getSequence('unknown');
139			}
140
141			public function testCreateSequence()
142			{
143			$schema = new Schema();
144			$sequence = $schema->createSequence('a_seq', 10, 20);
145
146			self::assertEquals('a_seq', $sequence->getName());
147			self::assertEquals(10, $sequence->getAllocationSize());
148			self::assertEquals(20, $sequence->getInitialValue());
149
150			self::assertTrue($schema->hasSequence('a_seq'));
151			self::assertInstanceOf(Sequence::class, $schema->getSequence('a_seq'));
152
153			$sequences = $schema->getSequences();
154			self::assertArrayHasKey('public.a_seq', $sequences);
155			}
156
157			public function testDropSequence()
158			{
159			$sequence = new Sequence('a_seq', 1, 1);
160
161			$schema = new Schema([], [$sequence]);
162
163			$schema->dropSequence('a_seq');
164			self::assertFalse($schema->hasSequence('a_seq'));
165			}
166
167			public function testAddSequenceTwiceThrowsException()
168			{
169			$this->expectException(SchemaException::class);
170
171			$sequence = new Sequence('a_seq', 1, 1);
172
173			$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...
174			}
175
176			public function testConfigMaxIdentifierLength()
177			{
178			$schemaConfig = new SchemaConfig();
179			$schemaConfig->setMaxIdentifierLength(5);
180
181			$schema = new Schema([], [], $schemaConfig);
182			$table = $schema->createTable('smalltable');
183			$table->addColumn('long_id', 'integer');
184			$table->addIndex(['long_id']);
185
186			$index = current($table->getIndexes());
187			self::assertEquals(5, strlen($index->getName()));
188			}
189
190			public function testDeepClone()
191			{
192			$schema = new Schema();
193			$sequence = $schema->createSequence('baz');
194			$view = $schema->createView('foz', 'SELECT * FROM `foo`');
195
196			$tableA = $schema->createTable('foo');
197			$tableA->addColumn('id', 'integer');
198
199			$tableB = $schema->createTable('bar');
200			$tableB->addColumn('id', 'integer');
201			$tableB->addColumn('foo_id', 'integer');
202			$tableB->addForeignKeyConstraint($tableA, ['foo_id'], ['id']);
203
204			$schemaNew = clone $schema;
205
206			self::assertNotSame($sequence, $schemaNew->getSequence('baz'));
207
208			self::assertNotSame($view, $schemaNew->getView('foz'));
209
210			self::assertNotSame($tableA, $schemaNew->getTable('foo'));
211			self::assertNotSame($tableA->getColumn('id'), $schemaNew->getTable('foo')->getColumn('id'));
212
213			self::assertNotSame($tableB, $schemaNew->getTable('bar'));
214			self::assertNotSame($tableB->getColumn('id'), $schemaNew->getTable('bar')->getColumn('id'));
215
216			$fk = $schemaNew->getTable('bar')->getForeignKeys();
217			$fk = current($fk);
218			self::assertSame($schemaNew->getTable('bar'), $this->readAttribute($fk, '_localTable'));
219			}
220
221			/**
222			* @group DBAL-219
223			*/
224			public function testHasTableForQuotedAsset()
225			{
226			$schema = new Schema();
227
228			$tableA = $schema->createTable('foo');
229			$tableA->addColumn('id', 'integer');
230
231			self::assertTrue($schema->hasTable('`foo`'));
232			}
233
234			/**
235			* @group DBAL-669
236			*/
237			public function testHasNamespace()
238			{
239			$schema = new Schema();
240
241			self::assertFalse($schema->hasNamespace('foo'));
242
243			$schema->createTable('foo');
244
245			self::assertFalse($schema->hasNamespace('foo'));
246
247			$schema->createTable('bar.baz');
248
249			self::assertFalse($schema->hasNamespace('baz'));
250			self::assertTrue($schema->hasNamespace('bar'));
251			self::assertFalse($schema->hasNamespace('tab'));
252
253			$schema->createTable('tab.taz');
254
255			self::assertTrue($schema->hasNamespace('tab'));
256			}
257
258			/**
259			* @group DBAL-669
260			*/
261			public function testCreatesNamespace()
262			{
263			$schema = new Schema();
264
265			self::assertFalse($schema->hasNamespace('foo'));
266
267			$schema->createNamespace('foo');
268
269			self::assertTrue($schema->hasNamespace('foo'));
270			self::assertTrue($schema->hasNamespace('FOO'));
271			self::assertTrue($schema->hasNamespace('`foo`'));
272			self::assertTrue($schema->hasNamespace('`FOO`'));
273
274			$schema->createNamespace('`bar`');
275
276			self::assertTrue($schema->hasNamespace('bar'));
277			self::assertTrue($schema->hasNamespace('BAR'));
278			self::assertTrue($schema->hasNamespace('`bar`'));
279			self::assertTrue($schema->hasNamespace('`BAR`'));
280
281			self::assertSame(['foo' => 'foo', 'bar' => '`bar`'], $schema->getNamespaces());
282			}
283
284			/**
285			* @group DBAL-669
286			* @expectedException \Doctrine\DBAL\Schema\SchemaException
287			*/
288			public function testThrowsExceptionOnCreatingNamespaceTwice()
289			{
290			$schema = new Schema();
291
292			$schema->createNamespace('foo');
293			$schema->createNamespace('foo');
294			}
295
296			/**
297			* @group DBAL-669
298			*/
299			public function testCreatesNamespaceThroughAddingTableImplicitly()
300			{
301			$schema = new Schema();
302
303			self::assertFalse($schema->hasNamespace('foo'));
304
305			$schema->createTable('baz');
306
307			self::assertFalse($schema->hasNamespace('foo'));
308			self::assertFalse($schema->hasNamespace('baz'));
309
310			$schema->createTable('foo.bar');
311
312			self::assertTrue($schema->hasNamespace('foo'));
313			self::assertFalse($schema->hasNamespace('bar'));
314
315			$schema->createTable('`baz`.bloo');
316
317			self::assertTrue($schema->hasNamespace('baz'));
318			self::assertFalse($schema->hasNamespace('bloo'));
319
320			$schema->createTable('`baz`.moo');
321
322			self::assertTrue($schema->hasNamespace('baz'));
323			self::assertFalse($schema->hasNamespace('moo'));
324			}
325
326			/**
327			* @group DBAL-669
328			*/
329			public function testCreatesNamespaceThroughAddingSequenceImplicitly()
330			{
331			$schema = new Schema();
332
333			self::assertFalse($schema->hasNamespace('foo'));
334
335			$schema->createSequence('baz');
336
337			self::assertFalse($schema->hasNamespace('foo'));
338			self::assertFalse($schema->hasNamespace('baz'));
339
340			$schema->createSequence('foo.bar');
341
342			self::assertTrue($schema->hasNamespace('foo'));
343			self::assertFalse($schema->hasNamespace('bar'));
344
345			$schema->createSequence('`baz`.bloo');
346
347			self::assertTrue($schema->hasNamespace('baz'));
348			self::assertFalse($schema->hasNamespace('bloo'));
349
350			$schema->createSequence('`baz`.moo');
351
352			self::assertTrue($schema->hasNamespace('baz'));
353			self::assertFalse($schema->hasNamespace('moo'));
354			}
355
356			/**
357			* @group DBAL-669
358			*/
359			public function testVisitsVisitor()
360			{
361			$schema = new Schema();
362			$visitor = $this->createMock(Visitor::class);
363
364			$schema->createNamespace('foo');
365			$schema->createNamespace('bar');
366
367			$schema->createTable('baz');
368			$schema->createTable('bla.bloo');
369
370			$schema->createSequence('moo');
371			$schema->createSequence('war');
372
373			$visitor->expects($this->once())
374			->method('acceptSchema')
375			->with($schema);
376
377			$visitor->expects($this->at(1))
378			->method('acceptTable')
379			->with($schema->getTable('baz'));
380
381			$visitor->expects($this->at(2))
382			->method('acceptTable')
383			->with($schema->getTable('bla.bloo'));
384
385			$visitor->expects($this->exactly(2))
386			->method('acceptTable');
387
388			$visitor->expects($this->at(3))
389			->method('acceptSequence')
390			->with($schema->getSequence('moo'));
391
392			$visitor->expects($this->at(4))
393			->method('acceptSequence')
394			->with($schema->getSequence('war'));
395
396			$visitor->expects($this->exactly(2))
397			->method('acceptSequence');
398
399			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...
400			}
401
402			/**
403			* @group DBAL-669
404			*/
405			public function testVisitsNamespaceVisitor()
406			{
407			$schema = new Schema();
408			$visitor = $this->createMock(AbstractVisitor::class);
409
410			$schema->createNamespace('foo');
411			$schema->createNamespace('bar');
412
413			$schema->createTable('baz');
414			$schema->createTable('bla.bloo');
415
416			$schema->createSequence('moo');
417			$schema->createSequence('war');
418
419			$schema->createView('foz', 'SELECT * FROM baz');
420
421			$visitor->expects($this->once())
422			->method('acceptSchema')
423			->with($schema);
424
425			$visitor->expects($this->at(1))
426			->method('acceptNamespace')
427			->with('foo');
428
429			$visitor->expects($this->at(2))
430			->method('acceptNamespace')
431			->with('bar');
432
433			$visitor->expects($this->at(3))
434			->method('acceptNamespace')
435			->with('bla');
436
437			$visitor->expects($this->exactly(3))
438			->method('acceptNamespace');
439
440			$visitor->expects($this->at(4))
441			->method('acceptTable')
442			->with($schema->getTable('baz'));
443
444			$visitor->expects($this->at(5))
445			->method('acceptTable')
446			->with($schema->getTable('bla.bloo'));
447
448			$visitor->expects($this->exactly(2))
449			->method('acceptTable');
450
451			$visitor->expects($this->at(6))
452			->method('acceptSequence')
453			->with($schema->getSequence('moo'));
454
455			$visitor->expects($this->at(7))
456			->method('acceptSequence')
457			->with($schema->getSequence('war'));
458
459			$visitor->expects($this->exactly(2))
460			->method('acceptSequence');
461
462			$visitor->expects($this->at(8))
463			->method('acceptView')
464			->with($schema->getView('foz'));
465
466			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...
467			}
468
469			public function testConstructWithView()
470			{
471			$viewName = 'public.foo';
472			$view = new View($viewName, 'SELECT * FROM `bar`');
473
474			$schema = new Schema([], [], null, [], [$view]);
475
476			self::assertTrue($schema->hasView($viewName));
477
478			$views = $schema->getViews();
479			self::assertArrayHasKey($viewName, $views);
480			self::assertSame($view, $views[$viewName]);
481			self::assertSame($view, $schema->getView($viewName));
482			}
483
484			public function testViewMatchingCaseInsensitive()
485			{
486			$view = new View('Foo', 'SELECT * FROM `bar`');
487
488			$schema = new Schema([], [], null, [], [$view]);
489			self::assertTrue($schema->hasView('foo'));
490			self::assertTrue($schema->hasView('FOO'));
491
492			self::assertSame($view, $schema->getView('FOO'));
493			self::assertSame($view, $schema->getView('foo'));
494			self::assertSame($view, $schema->getView('Foo'));
495			}
496
497			/**
498			* @expectedException \Doctrine\DBAL\Schema\SchemaException
499			*/
500			public function testGetUnknownViewThrowsException()
501			{
502			$schema = new Schema();
503			$schema->getView('unknown');
504			}
505
506			/**
507			* @expectedException \Doctrine\DBAL\Schema\SchemaException
508			*/
509			public function testCreateViewTwiceThrowsException()
510			{
511			$viewName = 'foo';
512			$view = new View($viewName, 'SELECT * FROM `bar`');
513			$views = [$view, $view];
514
515			new Schema([], [], null, [], $views);
516			}
517
518			public function testHasView()
519			{
520			$schema = new Schema();
521
522			self::assertFalse($schema->hasView('foo'));
523
524			$schema->createView('foo', 'SELECT * FROM `bar`');
525
526			self::assertTrue($schema->hasView('foo'));
527			}
528
529			public function testCreatesView()
530			{
531			$schema = new Schema();
532
533			self::assertFalse($schema->hasView('foo'));
534
535			$view = $schema->createView('foo', 'SELECT * FROM `bar`');
536
537			self::assertInstanceOf('Doctrine\DBAL\Schema\View', $view);
538			self::assertEquals('foo', $view->getName());
539			self::assertEquals('SELECT * FROM `bar`', $view->getSql());
540			self::assertTrue($schema->hasView('foo'));
541			}
542
543			public function testDropView()
544			{
545			$schema = new Schema();
546
547			$schema->dropView('foo');
548			self::assertFalse($schema->hasView('foo'));
549
550			$schema->createView('foo', 'SELECT * FROM `bar`');
551
552			$schema->dropView('foo');
553			self::assertFalse($schema->hasView('foo'));
554			}
555			}
556

doctrine / dbal

Pull Request — master (#3233)

SchemaTest::testHasView() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like