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

Failed Conditions

Pull Request — master (#3233)

by Sergey

created 2018-07-28 23:47 UTC

SchemaTest::testCreateViewTwiceThrowsException() A

↳ Parent: SchemaTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	7
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\Sequence;
use Doctrine\DBAL\Schema\Table;
use function current;
use function strlen;
use Doctrine\DBAL\Schema\View;

class SchemaTest extends \PHPUnit\Framework\TestCase
{
    public function testAddTable()
    {
        $tableName = "public.foo";
        $table = new Table($tableName);

        $schema = new Schema(array($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(array($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("Doctrine\DBAL\Schema\SchemaException");

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

    public function testCreateTableTwiceThrowsException()
    {
        $this->expectException("Doctrine\DBAL\Schema\SchemaException");

        $tableName = "foo";
        $table = new Table($tableName);
        $tables = array($table, $table);

        $schema = new Schema($tables);

    }

    public function testRenameTable()
    {
        $tableName = "foo";
        $table = new Table($tableName);
        $schema = new Schema(array($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(array($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('Doctrine\DBAL\Schema\Table', $table);
        self::assertEquals("foo", $table->getName());
        self::assertTrue($schema->hasTable("foo"));
    }

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

        $schema = new Schema(array(), array($sequence));

        self::assertTrue($schema->hasSequence("a_seq"));
        self::assertInstanceOf('Doctrine\DBAL\Schema\Sequence', $schema->getSequence("a_seq"));

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

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

        $schema = new Schema(array(), array($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("Doctrine\DBAL\Schema\SchemaException");

        $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('Doctrine\DBAL\Schema\Sequence', $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(array(), array($sequence));

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

    public function testAddSequenceTwiceThrowsException()
    {
        $this->expectException("Doctrine\DBAL\Schema\SchemaException");

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

        $schema = new Schema(array(), array($sequence, $sequence));

    }

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

        $schema = new Schema(array(), array(), $schemaConfig);
        $table = $schema->createTable("smalltable");
        $table->addColumn('long_id', 'integer');
        $table->addIndex(array('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, array('foo_id'), array('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(array('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('Doctrine\DBAL\Schema\Visitor\Visitor');

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

        $this->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('Doctrine\DBAL\Schema\Visitor\AbstractVisitor');

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

        $this->assertTrue($schema->hasView($viewName));

        $views = $schema->getViews();
        $this->assertTrue( isset($views[$viewName]) );
        $this->assertSame($view, $views[$viewName]);
        $this->assertSame($view, $schema->getView($viewName));
    }

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

        $schema = new Schema([], [], null, [], [$view]);
        $this->assertTrue($schema->hasView("foo"));
        $this->assertTrue($schema->hasView("FOO"));

        $this->assertSame($view, $schema->getView('FOO'));
        $this->assertSame($view, $schema->getView('foo'));
        $this->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 = array($view, $view);

        $schema = new Schema(array(), array(), null, array(), $views);

    }

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

        $this->assertFalse($schema->hasView("foo"));

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

        $this->assertTrue($schema->hasView("foo"));
    }

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

        $this->assertFalse($schema->hasView("foo"));

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

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

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

        $schema->dropView("foo");
        $this->assertFalse($schema->hasView("foo"));

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

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

doctrine / dbal

Pull Request — master (#3233)

SchemaTest::testCreateViewTwiceThrowsException() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like