ComparatorTest::testSkipsReflectingUndefinedApi() - Code Metrics - Inspection of "#42 Discover and load dependencies via composer on..." - Roave/BackwardCompatibilityCheck - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#48)

by Marco
created 2018-04-26 12:05 UTC
ComparatorTest::testSkipsReflectingUndefinedApi() A

↳ Parent: ComparatorTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	10
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	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\InterfaceBased\InterfaceBased;
use Roave\ApiCompare\Comparator\BackwardsCompatibility\TraitBased\TraitBased;

/**
 * @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 TraitBased|MockObject */
    private $traitBasedComparison;

    /** @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->traitBasedComparison     = $this->createMock(TraitBased::class);
        $this->comparator               = new Comparator(
            $this->classBasedComparison,
            $this->interfaceBasedComparison,
            $this->traitBasedComparison
        );
    }

    public function testWillRunSubComparators() : void
    {
        $this->classBasedComparatorWillBeCalled();
        $this->interfaceBasedComparatorWillNotBeCalled();
        $this->traitBasedComparatorWillNotBeCalled();

        self::assertEqualsIgnoringOrder(
            Changes::fromArray([
                Change::changed('class change', true),
            ]),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke('<?php class A {}'),
                                               __invoke('<?php class A {}'),
                self::$stringReflectorFactory->__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->interfaceBasedComparatorWillNotBeCalled();
        $this->traitBasedComparatorWillNotBeCalled();

        self::assertEqualsIgnoringOrder(
            Changes::fromArray([
                Change::changed('class change', true),
            ]),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke('<?php class A {}'),
                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->classBasedComparatorWillNotBeCalled();
        $this->interfaceBasedComparatorWillBeCalled();
        $this->traitBasedComparatorWillNotBeCalled();

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

    public function testWillRunTraitComparators() : void
    {
        $this->classBasedComparatorWillNotBeCalled();
        $this->interfaceBasedComparatorWillNotBeCalled();
        $this->traitBasedComparatorWillBeCalled();

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

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

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

        self::assertEqualsIgnoringOrder(
            Changes::new(),
            $this->comparator->compare(
                self::$stringReflectorFactory->__invoke('<?php '),
                self::$stringReflectorFactory->__invoke('<?php class A { private function foo() {} }'),
                self::$stringReflectorFactory->__invoke('<?php ')
            )
        );
    }

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

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

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

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

Roave / BackwardCompatibilityCheck

Pull Request — master (#48)

ComparatorTest::testSkipsReflectingUndefinedApi() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
