CompareClassesTest::testWillRunSubComparators() - Code Metrics - Inspection of "Add uniqueness to GitCheckoutRevisionToTemporaryPa..." - Roave/BackwardCompatibilityCheck - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#58)

by James
created 2018-05-02 09:04 UTC
CompareClassesTest::testWillRunSubComparators() A

↳ Parent: CompareClassesTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	23
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	15
nc	1
nop	0
dl	0
loc	23
rs	9.0856
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace RoaveTest\BackwardCompatibility;

use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Roave\BackwardCompatibility\Change;
use Roave\BackwardCompatibility\Changes;
use Roave\BackwardCompatibility\CompareClasses;
use Roave\BackwardCompatibility\DetectChanges\BCBreak\ClassBased\ClassBased;
use Roave\BackwardCompatibility\DetectChanges\BCBreak\InterfaceBased\InterfaceBased;
use Roave\BackwardCompatibility\DetectChanges\BCBreak\TraitBased\TraitBased;

/**
 * @covers \Roave\BackwardCompatibility\CompareClasses
 */
final class CompareClassesTest extends TestCase
{
    /** @var StringReflectorFactory|null */
    private static $stringReflectorFactory;

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

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

    /** @var TraitBased|MockObject */
    private $traitBasedComparison;

    /** @var CompareClasses */
    private $compareClasses;

    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->compareClasses           = new CompareClasses(
            $this->classBasedComparison,
            $this->interfaceBasedComparison,
            $this->traitBasedComparison
        );
    }

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

        self::assertEqualsIgnoringOrder(
            Changes::fromList(Change::changed('class change', true)),
            $this->compareClasses->__invoke(
                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::fromList(Change::changed('class change', true)),
            $this->compareClasses->__invoke(
                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::fromList(Change::changed('interface change', true)),
            $this->compareClasses->__invoke(
                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::fromList(Change::changed('trait change', true)),
            $this->compareClasses->__invoke(
                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::empty(),
            $this->compareClasses->__invoke(
                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::fromList(Change::removed('Class A has been deleted', true)),
            $this->compareClasses->__invoke(
                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('__invoke')
            ->willReturn(Changes::fromList(Change::changed('class change', true)));
    }

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

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

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

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

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

Roave / BackwardCompatibilityCheck

Pull Request — master (#58)

CompareClassesTest::testWillRunSubComparators() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
