SchemaDiffTest::createSchemaDiff() - Code Metrics - Inspection of "Added Codecov uploader to Travis CI configuration" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#3610)

by Sergei

created 2019-06-16 23:39 UTC

SchemaDiffTest::createSchemaDiff() A

↳ Parent: SchemaDiffTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.6333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Doctrine\Tests\DBAL\Schema;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\ForeignKeyConstraint;
use Doctrine\DBAL\Schema\SchemaDiff;
use Doctrine\DBAL\Schema\Sequence;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Schema\TableDiff;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class SchemaDiffTest extends TestCase
{
    public function testSchemaDiffToSql() : void
    {
        $diff     = $this->createSchemaDiff();
        $platform = $this->createPlatform(true);

        $sql = $diff->toSql($platform);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $expected = ['create_schema', 'drop_orphan_fk', 'alter_seq', 'drop_seq', 'create_seq', 'create_table', 'create_foreign_key', 'drop_table', 'alter_table'];

        self::assertEquals($expected, $sql);
    }

    public function testSchemaDiffToSaveSql() : void
    {
        $diff     = $this->createSchemaDiff();
        $platform = $this->createPlatform(false);

        $sql = $diff->toSaveSql($platform);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $expected = ['create_schema', 'alter_seq', 'create_seq', 'create_table', 'create_foreign_key', 'alter_table'];

        self::assertEquals($expected, $sql);
    }

    /**
     * @return AbstractPlatform|MockObject
     */
    private function createPlatform(bool $unsafe)
    {
        /** @var AbstractPlatform|MockObject $platform */
        $platform = $this->createMock(AbstractPlatform::class);
        $platform->expects($this->exactly(1))
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('getCreateSchemaSQL')
            ->with('foo_ns')
            ->will($this->returnValue('create_schema'));
        if ($unsafe) {
            $platform->expects($this->exactly(1))
                 ->method('getDropSequenceSql')
                 ->with($this->isInstanceOf(Sequence::class))
                 ->will($this->returnValue('drop_seq'));
        }
        $platform->expects($this->exactly(1))
                 ->method('getAlterSequenceSql')
                 ->with($this->isInstanceOf(Sequence::class))
                 ->will($this->returnValue('alter_seq'));
        $platform->expects($this->exactly(1))
                 ->method('getCreateSequenceSql')
                 ->with($this->isInstanceOf(Sequence::class))
                 ->will($this->returnValue('create_seq'));
        if ($unsafe) {
            $platform->expects($this->exactly(1))
                     ->method('getDropTableSql')
                     ->with($this->isInstanceOf(Table::class))
                     ->will($this->returnValue('drop_table'));
        }
        $platform->expects($this->exactly(1))
                 ->method('getCreateTableSql')
                 ->with($this->isInstanceOf(Table::class))
                 ->will($this->returnValue(['create_table']));
        $platform->expects($this->exactly(1))
                 ->method('getCreateForeignKeySQL')
                 ->with($this->isInstanceOf(ForeignKeyConstraint::class))
                 ->will($this->returnValue('create_foreign_key'));
        $platform->expects($this->exactly(1))
                 ->method('getAlterTableSql')
                 ->with($this->isInstanceOf(TableDiff::class))
                 ->will($this->returnValue(['alter_table']));
        if ($unsafe) {
            $platform->expects($this->exactly(1))
                     ->method('getDropForeignKeySql')
                     ->with(
                         $this->isInstanceOf(ForeignKeyConstraint::class),
                         $this->isInstanceOf(Table::class)
                     )
                     ->will($this->returnValue('drop_orphan_fk'));
        }
        $platform->expects($this->exactly(1))
                ->method('supportsSchemas')
                ->will($this->returnValue(true));
        $platform->expects($this->exactly(1))
                ->method('supportsSequences')
                ->will($this->returnValue(true));
        $platform->expects($this->exactly(2))
                ->method('supportsForeignKeyConstraints')
                ->will($this->returnValue(true));

        return $platform;
    }

    public function createSchemaDiff() : SchemaDiff
    {
        $diff                              = new SchemaDiff();
        $diff->newNamespaces['foo_ns']     = 'foo_ns';
        $diff->removedNamespaces['bar_ns'] = 'bar_ns';
        $diff->changedSequences['foo_seq'] = new Sequence('foo_seq');
        $diff->newSequences['bar_seq']     = new Sequence('bar_seq');
        $diff->removedSequences['baz_seq'] = new Sequence('baz_seq');
        $diff->newTables['foo_table']      = new Table('foo_table');
        $diff->removedTables['bar_table']  = new Table('bar_table');
        $diff->changedTables['baz_table']  = new TableDiff('baz_table');
        $diff->newTables['foo_table']->addColumn('foreign_id', 'integer');
        $diff->newTables['foo_table']->addForeignKeyConstraint('foreign_table', ['foreign_id'], ['id']);
        $fk = new ForeignKeyConstraint(['id'], 'foreign_table', ['id']);
        $fk->setLocalTable(new Table('local_table'));
        $diff->orphanedForeignKeys[] = $fk;

        return $diff;
    }
}


1			<?php
2
3			namespace Doctrine\Tests\DBAL\Schema;
4
5			use Doctrine\DBAL\Platforms\AbstractPlatform;
6			use Doctrine\DBAL\Schema\ForeignKeyConstraint;
7			use Doctrine\DBAL\Schema\SchemaDiff;
8			use Doctrine\DBAL\Schema\Sequence;
9			use Doctrine\DBAL\Schema\Table;
10			use Doctrine\DBAL\Schema\TableDiff;
11			use PHPUnit\Framework\MockObject\MockObject;
12			use PHPUnit\Framework\TestCase;
13
14			class SchemaDiffTest extends TestCase
15			{
16			public function testSchemaDiffToSql() : void
17			{
18			$diff = $this->createSchemaDiff();
19			$platform = $this->createPlatform(true);
20
21			$sql = $diff->toSql($platform);
			0 ignored issues – show Bug introduced 2019-06-16 23:45 UTC by Report Bug Copy Issue Report It seems like `$platform` defined by `$this->createPlatform(true)` on line `19` can also be of type `object<PHPUnit\Framework\MockObject\MockObject>`; however, `Doctrine\DBAL\Schema\SchemaDiff::toSql()` does only seem to accept `object<Doctrine\DBAL\Platforms\AbstractPlatform>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
22
23			$expected = ['create_schema', 'drop_orphan_fk', 'alter_seq', 'drop_seq', 'create_seq', 'create_table', 'create_foreign_key', 'drop_table', 'alter_table'];
24
25			self::assertEquals($expected, $sql);
26			}
27
28			public function testSchemaDiffToSaveSql() : void
29			{
30			$diff = $this->createSchemaDiff();
31			$platform = $this->createPlatform(false);
32
33			$sql = $diff->toSaveSql($platform);
			0 ignored issues – show Bug introduced 2019-06-16 23:45 UTC by Report Bug Copy Issue Report It seems like `$platform` defined by `$this->createPlatform(false)` on line `31` can also be of type `object<PHPUnit\Framework\MockObject\MockObject>`; however, `Doctrine\DBAL\Schema\SchemaDiff::toSaveSql()` does only seem to accept `object<Doctrine\DBAL\Platforms\AbstractPlatform>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
34
35			$expected = ['create_schema', 'alter_seq', 'create_seq', 'create_table', 'create_foreign_key', 'alter_table'];
36
37			self::assertEquals($expected, $sql);
38			}
39
40			/**
41			* @return AbstractPlatform\|MockObject
42			*/
43			private function createPlatform(bool $unsafe)
44			{
45			/** @var AbstractPlatform\|MockObject $platform */
46			$platform = $this->createMock(AbstractPlatform::class);
47			$platform->expects($this->exactly(1))
			0 ignored issues – show Bug introduced 2019-06-16 23:45 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit\Framework\MockObject\MockObject`, but not in `Doctrine\DBAL\Platforms\AbstractPlatform`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
48			->method('getCreateSchemaSQL')
49			->with('foo_ns')
50			->will($this->returnValue('create_schema'));
51			if ($unsafe) {
52			$platform->expects($this->exactly(1))
53			->method('getDropSequenceSql')
54			->with($this->isInstanceOf(Sequence::class))
55			->will($this->returnValue('drop_seq'));
56			}
57			$platform->expects($this->exactly(1))
58			->method('getAlterSequenceSql')
59			->with($this->isInstanceOf(Sequence::class))
60			->will($this->returnValue('alter_seq'));
61			$platform->expects($this->exactly(1))
62			->method('getCreateSequenceSql')
63			->with($this->isInstanceOf(Sequence::class))
64			->will($this->returnValue('create_seq'));
65			if ($unsafe) {
66			$platform->expects($this->exactly(1))
67			->method('getDropTableSql')
68			->with($this->isInstanceOf(Table::class))
69			->will($this->returnValue('drop_table'));
70			}
71			$platform->expects($this->exactly(1))
72			->method('getCreateTableSql')
73			->with($this->isInstanceOf(Table::class))
74			->will($this->returnValue(['create_table']));
75			$platform->expects($this->exactly(1))
76			->method('getCreateForeignKeySQL')
77			->with($this->isInstanceOf(ForeignKeyConstraint::class))
78			->will($this->returnValue('create_foreign_key'));
79			$platform->expects($this->exactly(1))
80			->method('getAlterTableSql')
81			->with($this->isInstanceOf(TableDiff::class))
82			->will($this->returnValue(['alter_table']));
83			if ($unsafe) {
84			$platform->expects($this->exactly(1))
85			->method('getDropForeignKeySql')
86			->with(
87			$this->isInstanceOf(ForeignKeyConstraint::class),
88			$this->isInstanceOf(Table::class)
89			)
90			->will($this->returnValue('drop_orphan_fk'));
91			}
92			$platform->expects($this->exactly(1))
93			->method('supportsSchemas')
94			->will($this->returnValue(true));
95			$platform->expects($this->exactly(1))
96			->method('supportsSequences')
97			->will($this->returnValue(true));
98			$platform->expects($this->exactly(2))
99			->method('supportsForeignKeyConstraints')
100			->will($this->returnValue(true));
101
102			return $platform;
103			}
104
105			public function createSchemaDiff() : SchemaDiff
106			{
107			$diff = new SchemaDiff();
108			$diff->newNamespaces['foo_ns'] = 'foo_ns';
109			$diff->removedNamespaces['bar_ns'] = 'bar_ns';
110			$diff->changedSequences['foo_seq'] = new Sequence('foo_seq');
111			$diff->newSequences['bar_seq'] = new Sequence('bar_seq');
112			$diff->removedSequences['baz_seq'] = new Sequence('baz_seq');
113			$diff->newTables['foo_table'] = new Table('foo_table');
114			$diff->removedTables['bar_table'] = new Table('bar_table');
115			$diff->changedTables['baz_table'] = new TableDiff('baz_table');
116			$diff->newTables['foo_table']->addColumn('foreign_id', 'integer');
117			$diff->newTables['foo_table']->addForeignKeyConstraint('foreign_table', ['foreign_id'], ['id']);
118			$fk = new ForeignKeyConstraint(['id'], 'foreign_table', ['id']);
119			$fk->setLocalTable(new Table('local_table'));
120			$diff->orphanedForeignKeys[] = $fk;
121
122			return $diff;
123			}
124			}
125

doctrine / dbal

Pull Request — master (#3610)

SchemaDiffTest::createSchemaDiff() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like