Issues in RelyingPartyCollectionTest.php - New Issues - Inspection of "Merge pull request #110 from tmilos/limit_symfony_..." - aerialship/SamlSPBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d5bbb9...ab4758 )

by Milos

created 2016-01-03 08:15 UTC

Tests/RelyingParty/RelyingPartyCollectionTest.php (28 issues)

Labels

Bug 28

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace AerialShip\SamlSPBundle\Tests\RelyingParty;

use AerialShip\SamlSPBundle\RelyingParty\RelyingPartyCollection;

class RelyingPartyCollectionTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @test
     */
    public function shouldImplementsRelyingPartyInterface()
    {
        $rc = new \ReflectionClass('AerialShip\SamlSPBundle\RelyingParty\RelyingPartyCollection');
        $this->assertTrue($rc->implementsInterface('AerialShip\SamlSPBundle\RelyingParty\RelyingPartyInterface'));
    }

    /**
     * @test
     */
    public function couldBeConstructedWithoutAnyArguments()
    {
        new RelyingPartyCollection();
    }


    /**
     * @test
     */
    public function shouldAllowPrependRelyingParty()
    {
        $collection = new RelyingPartyCollection;
        $collection->prepend($this->createRelyingPartyMock());

    }

    /**
     * @test
     */
    public function shouldAllowAppendRelyingParty()
    {
        $collection = new RelyingPartyCollection;
        $collection->append($this->createRelyingPartyMock());

    }

    /**
     * @test
     */
    public function shouldNotSupportIfCollectionEmpty()
    {
        $collection = new RelyingPartyCollection;
        $this->assertFalse($collection->supports($this->createRequestMock()));

    }


    /**
     * @test
     */
    public function shouldNotSupportIfAnyRelyingPartyInCollectionNotSupport()
    {
        $relyingPartyOneMock = $this->createRelyingPartyMock();
        $relyingPartyOneMock
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.
}
                ->expects($this->once())
                ->method('supports')
                ->will($this->returnValue(false))
        ;

        $relyingPartyTwoMock = $this->createRelyingPartyMock();
        $relyingPartyTwoMock
                ->expects($this->once())
                ->method('supports')
                ->will($this->returnValue(false))
        ;

        $collection = new RelyingPartyCollection;

        $collection->append($relyingPartyOneMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $collection->prepend($relyingPartyTwoMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $this->assertFalse($collection->supports($this->createRequestMock()));

    }

    /**
     * @test
     */
    public function shouldSupportIfRelyingPartyInCollectionSupport()
    {
        $relyingPartyOneMock = $this->createRelyingPartyMock();
        $relyingPartyOneMock
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.
}
                ->expects($this->once())
                ->method('supports')
                ->will($this->returnValue(false))
        ;

        $relyingPartyTwoMock = $this->createRelyingPartyMock();
        $relyingPartyTwoMock
                ->expects($this->once())
                ->method('supports')
                ->will($this->returnValue(true))
        ;

        $collection = new RelyingPartyCollection;

        $collection->append($relyingPartyOneMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $collection->append($relyingPartyTwoMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $this->assertTrue($collection->supports($this->createRequestMock()));

    }


    /**
     * @test
     */
    public function shouldStopOnFirstSupportedRelyingPartyWhileCheckingWhetherCollectionSupportOrNot()
    {
        $relyingPartyOneMock = $this->createRelyingPartyMock();
        $relyingPartyOneMock
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.
}
                ->expects($this->once())
                ->method('supports')
                ->will($this->returnValue(true))
        ;

        $relyingPartyTwoMock = $this->createRelyingPartyMock();
        $relyingPartyTwoMock
                ->expects($this->never())
                ->method('supports')
        ;

        $collection = new RelyingPartyCollection;

        $collection->append($relyingPartyOneMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $collection->append($relyingPartyTwoMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $this->assertTrue($collection->supports($this->createRequestMock()));

    }

    /**
     * @test
     *
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage The relying party does not support the request
     */
    public function throwIfTryManageEmptyCollection()
    {
        $collection = new RelyingPartyCollection;
        $this->assertFalse($collection->supports($this->createRequestMock()));

        $collection->manage($this->createRequestMock());

    }

    /**
     * @test
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage The relying party does not support the request
     */
    public function throwIfTryManageRequestNotSupportedByAnyRelyingPartyInCollection()
    {
        $relyingPartyOneMock = $this->createRelyingPartyMock();
        $relyingPartyOneMock
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.
}
                ->expects($this->atLeastOnce())
                ->method('supports')
                ->will($this->returnValue(false))
        ;

        $relyingPartyTwoMock = $this->createRelyingPartyMock();
        $relyingPartyTwoMock
                ->expects($this->atLeastOnce())
                ->method('supports')
                ->will($this->returnValue(false))
        ;

        $collection = new RelyingPartyCollection;

        $collection->append($relyingPartyOneMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $collection->append($relyingPartyTwoMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $this->assertFalse($collection->supports($this->createRequestMock()));


        $collection->manage($this->createRequestMock());

    }


    /**
     * @test
     */
    public function shouldProxyManagingToRelyingPartyWhichSupportRequest()
    {
        $expectedRequest = $this->createRequestMock();

        $relyingPartyOneMock = $this->createRelyingPartyMock();
        $relyingPartyOneMock
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.
}
                ->expects($this->any())
                ->method('supports')
                ->will($this->returnValue(true))
        ;
        $relyingPartyOneMock
                ->expects($this->once())
                ->method('manage')
                ->with($expectedRequest)
        ;

        $collection = new RelyingPartyCollection;

        $collection->append($relyingPartyOneMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $collection->manage($expectedRequest);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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


    /**
     * @test
     */
    public function shouldReturnResultOfRelyingPartyWhichSupportRequestOnManaging()
    {
        $expectedResult = 'the_relying_party_result';

        $relyingPartyOneMock = $this->createRelyingPartyMock();
        $relyingPartyOneMock
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.
}
                ->expects($this->any())
                ->method('supports')
                ->will($this->returnValue(true))
        ;
        $relyingPartyOneMock
                ->expects($this->once())
                ->method('manage')
                ->will($this->returnValue($expectedResult))
        ;

        $collection = new RelyingPartyCollection;

        $collection->append($relyingPartyOneMock);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $this->assertSame($expectedResult, $collection->manage($this->createRequestMock()));

    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|\Symfony\Component\HttpFoundation\Request
     */
    public function createRequestMock()
    {
        return $this->getMock('Symfony\Component\HttpFoundation\Request', array(), array(), '', false, false);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|\AerialShip\SamlSPBundle\RelyingParty\RelyingPartyInterface
     */
    public function createRelyingPartyMock()
    {
        return $this->getMock('AerialShip\SamlSPBundle\RelyingParty\RelyingPartyInterface');
    }
}


Push — master ( d5bbb9...ab4758 )

Tests/RelyingParty/RelyingPartyCollectionTest.php (28 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace AerialShip\SamlSPBundle\Tests\RelyingParty;
4
5			use AerialShip\SamlSPBundle\RelyingParty\RelyingPartyCollection;
6
7			class RelyingPartyCollectionTest extends \PHPUnit_Framework_TestCase
8			{
9			/**
10			* @test
11			*/
12			public function shouldImplementsRelyingPartyInterface()
13			{
14			$rc = new \ReflectionClass('AerialShip\SamlSPBundle\RelyingParty\RelyingPartyCollection');
15			$this->assertTrue($rc->implementsInterface('AerialShip\SamlSPBundle\RelyingParty\RelyingPartyInterface'));
16			}
17
18			/**
19			* @test
20			*/
21			public function couldBeConstructedWithoutAnyArguments()
22			{
23			new RelyingPartyCollection();
24			}
25
26
27			/**
28			* @test
29			*/
30			public function shouldAllowPrependRelyingParty()
31			{
32			$collection = new RelyingPartyCollection;
33			$collection->prepend($this->createRelyingPartyMock());
			0 ignored issues – show Bug introduced 2016-01-03 08:18 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `$this->createRelyingPartyMock()` targeting `AerialShip\SamlSPBundle\...reateRelyingPartyMock()` can also be of type `object<PHPUnit_Framework_MockObject_MockObject>`; however, `AerialShip\SamlSPBundle\...tyCollection::prepend()` does only seem to accept `object<AerialShip\SamlSP...\RelyingPartyInterface>`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
34			}
35
36			/**
37			* @test
38			*/
39			public function shouldAllowAppendRelyingParty()

aerialship / SamlSPBundle

Push — master ( d5bbb9...ab4758 )

Tests/RelyingParty/RelyingPartyCollectionTest.php (28 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like