RelyingPartyCollectionTest::couldBeConstructedWithoutAnyArguments() - Code Metrics - aerialship/SamlSPBundle - Measure and Improve Code Quality continuously with Scrutinizer

couldBeConstructedWithoutAnyArguments() A
last analyzed 2016-01-11 06:31 UTC

↳ Parent: RelyingPartyCollectionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

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


couldBeConstructedWithoutAnyArguments() A
last analyzed 2016-01-11 06:31 UTC

Complexity

Size

Duplication

Importance

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 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

couldBeConstructedWithoutAnyArguments() A last analyzed 2016-01-11 06:31 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

couldBeConstructedWithoutAnyArguments() A
last analyzed 2016-01-11 06:31 UTC