ComparatorTest::testMakingAClassFinal() - Code Metrics - Inspection of "Verify method, function, property, constant and in..." - Roave/BackwardCompatibilityCheck - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#38)

by Marco
created 2018-04-18 12:09 UTC
ComparatorTest::testMakingAClassFinal() A

↳ Parent: ComparatorTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	7
nc	1
nop	0
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace RoaveTest\ApiCompare;

use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Roave\ApiCompare\Change;
use Roave\ApiCompare\Changes;
use Roave\ApiCompare\Comparator;
use Roave\ApiCompare\Comparator\BackwardsCompatibility\ClassBased\ClassBased;
use Roave\ApiCompare\Comparator\BackwardsCompatibility\ClassConstantBased\ConstantBased;
use Roave\ApiCompare\Comparator\BackwardsCompatibility\InterfaceBased\InterfaceBased;
use Roave\ApiCompare\Comparator\BackwardsCompatibility\MethodBased\MethodBased;
use Roave\ApiCompare\Comparator\BackwardsCompatibility\PropertyBased\PropertyBased;

/**
 * @covers \Roave\ApiCompare\Comparator
 */
final class ComparatorTest extends TestCase
{
    /** @var StringReflectorFactory|null */
    private static $stringReflectorFactory;

    /** @var ClassBased|MockObject */
    private $classBasedComparison;

    /** @var InterfaceBased|MockObject */
    private $interfaceBasedComparison;

    /** @var MethodBased|MockObject */
    private $methodBasedComparison;

    /** @var PropertyBased|MockObject */
    private $propertyBasedComparison;

    /** @var ConstantBased|MockObject */
    private $constantBasedComparison;

    /** @var Comparator */
    private $comparator;

    public static function setUpBeforeClass() : void
    {
        self::$stringReflectorFactory = new StringReflectorFactory();
    }

    protected function setUp() : void
    {
        parent::setUp();

        $this->classBasedComparison     = $this->createMock(ClassBased::class);
        $this->interfaceBasedComparison = $this->createMock(InterfaceBased::class);
        $this->methodBasedComparison    = $this->createMock(MethodBased::class);
        $this->propertyBasedComparison  = $this->createMock(PropertyBased::class);
        $this->constantBasedComparison  = $this->createMock(ConstantBased::class);
        $this->comparator               = new Comparator(
            $this->classBasedComparison,
            $this->interfaceBasedComparison,
            $this->methodBasedComparison,
            $this->propertyBasedComparison,
            $this->constantBasedComparison
        );
    }

    public function testWillRunSubComparators() : void
    {
        $this->classBasedComparatorWillBeCalled();
        $this->methodBasedComparatorWillBeCalled();
        $this->propertyBasedComparatorWillBeCalled();
        $this->constantBasedComparatorWillBeCalled();
        $this->interfaceBasedComparatorWillNotBeCalled();

        self::assertEqualsIgnoringOrder(
            Changes::fromArray([
                Change::changed('class change', true),
                Change::changed('constant change', true),
                Change::changed('property change', true),
                Change::changed('method change', true),
            ]),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke(
                                               __invoke(
                    <<<'PHP'
<?php

class A {
    const A_CONSTANT = 'foo';
    public $aProperty;
    public function aMethod() {}
}
PHP
                ),
                self::$stringReflectorFactory->__invoke(
                    <<<'PHP'
<?php

class A {
    const A_CONSTANT = 'foo';
    public $aProperty;
    public function aMethod() {}
}
PHP
                )
            )
        );
    }

    public function testWillNotRunSubComparatorsIfSymbolsWereDeleted() : void
    {
        $this->classBasedComparatorWillBeCalled();
        $this->methodBasedComparatorWillNotBeCalled();
        $this->propertyBasedComparatorWillNotBeCalled();
        $this->constantBasedComparatorWillNotBeCalled();
        $this->interfaceBasedComparatorWillNotBeCalled();

        self::assertEqualsIgnoringOrder(
            Changes::fromArray([
                Change::changed('class change', true),
            ]),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke(
                    <<<'PHP'
<?php

class A {
    const A_CONSTANT = 'foo';
    public $aProperty;
    public function aMethod() {}
}
PHP
                ),
                self::$stringReflectorFactory->__invoke(
                    <<<'PHP'
<?php

class A {}
PHP
                )
            )
        );
    }

    public function testWillRunInterfaceComparators() : void
    {
        $this->classBasedComparatorWillBeCalled();
        $this->methodBasedComparatorWillNotBeCalled();
        $this->propertyBasedComparatorWillNotBeCalled();
        $this->constantBasedComparatorWillNotBeCalled();
        $this->interfaceBasedComparatorWillBeCalled();

        self::assertEqualsIgnoringOrder(
            Changes::fromArray([
                Change::changed('class change', true),
                Change::changed('interface change', true),
            ]),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke('<?php interface A {}'),
                self::$stringReflectorFactory->__invoke('<?php interface A {}')
            )
        );
    }

    /**
     * @param mixed $expected
     * @param mixed $actual
     */
    private static function assertEqualsIgnoringOrder($expected, $actual) : void
    {
        self::assertEquals($expected, $actual, '', 0.0, 10, true);
    }

    public function testRemovingAClassCausesABreak() : void
    {
        $this->classBasedComparatorWillNotBeCalled();
        $this->methodBasedComparatorWillNotBeCalled();

        self::assertEqualsIgnoringOrder(
            Changes::fromArray([
                Change::removed('Class A has been deleted', true),
            ]),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke('<?php class A { private function foo() {} }'),
                self::$stringReflectorFactory->__invoke('<?php ')
            )
        );
    }

    private function classBasedComparatorWillBeCalled() : void
    {
        $this
            ->classBasedComparison
            ->expects(self::atLeastOnce())
              expects(self::atLeastOnce())
            ->method('compare')
            ->willReturn(Changes::fromArray([
                Change::changed('class change', true),
            ]));
    }

    private function classBasedComparatorWillNotBeCalled() : void
    {
        $this
            ->classBasedComparison
            ->expects(self::never())
            ->method('compare');
    }

    private function methodBasedComparatorWillBeCalled() : void
    {
        $this
            ->methodBasedComparison
            ->expects(self::atLeastOnce())
              expects(self::atLeastOnce())
            ->method('compare')
            ->willReturn(Changes::fromArray([
                Change::changed('method change', true),
            ]));
    }

    private function methodBasedComparatorWillNotBeCalled() : void
    {
        $this
            ->methodBasedComparison
            ->expects(self::never())
            ->method('compare');
    }

    private function propertyBasedComparatorWillBeCalled() : void
    {
        $this
            ->propertyBasedComparison
            ->expects(self::atLeastOnce())
              expects(self::atLeastOnce())
            ->method('compare')
            ->willReturn(Changes::fromArray([
                Change::changed('property change', true),
            ]));
    }

    private function propertyBasedComparatorWillNotBeCalled() : void
    {
        $this
            ->propertyBasedComparison
            ->expects(self::never())
            ->method('compare');
    }

    private function constantBasedComparatorWillBeCalled() : void
    {
        $this
            ->constantBasedComparison
            ->expects(self::atLeastOnce())
              expects(self::atLeastOnce())
            ->method('compare')
            ->willReturn(Changes::fromArray([
                Change::changed('constant change', true),
            ]));
    }

    private function constantBasedComparatorWillNotBeCalled() : void
    {
        $this
            ->constantBasedComparison
            ->expects(self::never())
            ->method('compare');
    }

    private function interfaceBasedComparatorWillBeCalled() : void
    {
        $this
            ->interfaceBasedComparison
            ->expects(self::atLeastOnce())
              expects(self::atLeastOnce())
            ->method('compare')
            ->willReturn(Changes::fromArray([
                Change::changed('interface change', true),
            ]));
    }

    private function interfaceBasedComparatorWillNotBeCalled() : void
    {
        $this
            ->interfaceBasedComparison
            ->expects(self::never())
            ->method('compare');
    }
}

Roave / BackwardCompatibilityCheck

Pull Request — master (#38)

ComparatorTest::testMakingAClassFinal() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
