FunctionImportAnonymousTypeTest::testAddGoodParameter() - Code Metrics - Inspection of "Merge pull request #117 from c-harris/CoverEntityC..." - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 861401...d44c24 )

by Alex

created 2017-06-27 17:42 UTC

testAddGoodParameter() A

↳ Parent: FunctionImportAnonymousTypeTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	10

Duplication

Lines	13
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	13
loc	13
rs	9.4285
c	1
b	0
f	0
cc	1
eloc	10
nc	1
nop	0

<?php

namespace AlgoWeb\ODataMetadata\Tests\v3\edm\EntityContainer;

use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\FunctionImportAnonymousType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TDocumentationType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportParameterType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType;
use AlgoWeb\ODataMetadata\Tests\TestCase;
use Mockery as m;

class FunctionImportAnonymousTypeTest extends TestCase
{
    public function testIsComposableRoundTripTrue()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setIsComposable('foo');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertTrue($foo->getIsComposable());
    }

    public function testIsComposableRoundTripFalse()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setIsComposable(null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertFalse($foo->getIsComposable());
    }

    public function testIsSideEffectingRoundTripTrue()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setIsSideEffecting('foo');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertTrue($foo->getIsSideEffecting());
    }

    public function testIsSideEffectingRoundTripFalse()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setIsSideEffecting(null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertFalse($foo->getIsSideEffecting());
    }

    public function testIsBindableRoundTripTrue()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setIsBindable('foo');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertTrue($foo->getIsBindable());
    }

    public function testIsBindableRoundTripFalse()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setIsBindable(null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertFalse($foo->getIsBindable());
    }

    public function testMethodAccessRoundTrip()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->setMethodAccess('Public');
        $this->assertEquals('Public', $foo->getMethodAccess());
    }

    public function testSetMethodAccessBadData()
    {
        $expected = "Method access must be a valid TAccess";
        $actual = null;

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->setMethodAccess("cheezburger");
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetEntitySetBadData()
    {
        $expected = "";
        $actual = null;

        $entitySet = m::mock(TOperandType::class)->makePartial();
        $entitySet->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->setEntitySet($entitySet);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetEntitySetRoundTrip()
    {
        $entitySet = m::mock(TOperandType::class)->makePartial();
        $entitySet->shouldReceive('isOK')->andReturn(true)->twice();

        $foo = new FunctionImportAnonymousType();

        $foo->setEntitySet($entitySet);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = $foo->getEntitySet();
        $this->assertTrue($result->isOK());
    }

    public function testAddToReturnTypeBadData()
    {
        $expected = "";
        $actual = null;

        $entitySet = m::mock(TFunctionImportReturnTypeType::class)->makePartial();
        $entitySet->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->addToReturnType($entitySet);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testUnsetMissingReturnTypeIndex()
    {
        $foo = new FunctionImportAnonymousType();

        $foo->unsetReturnType(0);
        $this->assertFalse($foo->issetReturnType(0));
    }

    public function testGetReturnTypeEmptyArray()
    {
        $foo = new FunctionImportAnonymousType();
        $this->assertEquals(0, count($foo->getReturnType()));
    }

    public function testSetReturnTypeBadData()

    {
        $expected = "";
        $actual = null;

        $entitySet = m::mock(TFunctionImportReturnTypeType::class)->makePartial();
        $entitySet->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->setReturnType([$entitySet]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetNameBadData()
    {
        $expected = "Name must be a valid TSimpleIdentifier";
        $actual = null;

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->setName(" _ ");
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testIsTFunctionImportAttributesValid()
    {
        $expected = "Name must be a valid TSimpleIdentifier:"
                    ." AlgoWeb\\ODataMetadata\\MetadataV3\\edm\\EntityContainer\\FunctionImportAnonymousType";
        $actual = null;

        $foo = new FunctionImportAnonymousType();
        $foo->isTFunctionImportAttributesValid($actual);
        $this->assertEquals($expected, $actual);
    }

    public function testIsComposableAndSideEffecting()
    {
        $expected = "Cannot both be composable and side-effecting";
        $actual = null;

        $foo = new FunctionImportAnonymousType();
        $foo->setName("Name");
        $foo->setIsComposable(true);
        $foo->setIsSideEffecting(true);

        $foo->isTFunctionImportAttributesValid($actual);
        $this->assertEquals($expected, $actual);
        $this->assertEquals("Name", $foo->getName());
    }

    public function testIsTFunctionImportAttributesValidWithAccessSet()
    {
        $foo = new FunctionImportAnonymousType();
        $foo->setName("Name");
        $foo->setMethodAccess('Public');

        $msg = null;
        $this->assertTrue($foo->isTFunctionImportAttributesValid($msg));
        $this->assertNull($msg);
    }

    public function testIsTFunctionImportAttributesValidWithBadEntitySet()
    {
        $expectedStarts = "Entity set must be either null or an instance of TOperandType:";
        $expectedEnds = "AlgoWeb\\ODataMetadata\\MetadataV3\\edm\\EntityContainer\\FunctionImportAnonymousType";
        $actual = null;

        $entitySet = m::mock(TOperandType::class)->makePartial();
        $entitySet->shouldReceive('isOK')->andReturn(true, false)->twice();

        $foo = new FunctionImportAnonymousType();
        $foo->setName("Name");
        $foo->setMethodAccess('Public');
        $foo->setEntitySet($entitySet);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertFalse($foo->isTFunctionImportAttributesValid($actual));
        $this->assertStringStartsWith($expectedStarts, $actual);
        $this->assertStringEndsWith($expectedEnds, $actual);
    }

    public function testIsTFunctionImportAttributesValidWithBadReturnType()

    {
        $expected = "";
        $actual = null;

        $entitySet = m::mock(TFunctionImportReturnTypeType::class)->makePartial();
        $entitySet->shouldReceive('isOK')->andReturn(true, false)->once();

        $foo = new FunctionImportAnonymousType();
        $foo->setName("Name");
        $foo->setMethodAccess('Public');
        $foo->addToReturnType($entitySet);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertFalse($foo->isTFunctionImportAttributesValid($actual));
        $this->assertEquals($expected, $actual);
    }

    public function testSetBadDocumentation()

    {
        $expected = "";
        $actual = null;

        $documentation = m::mock(TDocumentationType::class);
        $documentation->shouldReceive('isOK')->andReturn(false)->once();
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.
}

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->setDocumentation($documentation);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testAddBadParameter()

    {
        $expected = "";
        $actual = null;

        $function = m::mock(TFunctionImportParameterType::class);
        $function->shouldReceive('isOK')->andReturn(false)->once();
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.
}

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->addToParameter($function);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testAddGoodParameter()

    {
        $function = m::mock(TFunctionImportParameterType::class);
        $function->shouldReceive('isOK')->andReturn(true)->once();
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.
}

        $foo = new FunctionImportAnonymousType();
        $foo->addToParameter($function);
        $this->assertTrue($foo->issetParameter(0));
        $this->assertFalse($foo->issetParameter(1));
        $this->assertEquals(1, count($foo->getParameter()));
        $foo->unsetParameter(0);
        $this->assertEquals(0, count($foo->getParameter()));
    }

    public function testSetBadParameterArray()

    {
        $expected = "";
        $actual = null;

        $function = m::mock(TFunctionImportParameterType::class);
        $function->shouldReceive('isOK')->andReturn(false)->once();
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.
}

        $foo = new FunctionImportAnonymousType();

        try {
            $foo->setParameter([$function]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testIsOkUnderParameterNameCollision()
    {
        $expected = "Name collision in parameters array";
        $actual = null;

        $function = m::mock(TFunctionImportParameterType::class)->makePartial();
        $function->shouldReceive('isOK')->andReturn(true)->once();
        $function->shouldReceive('getName')->andReturn('noname');
        $this->assertTrue($function instanceof TFunctionImportParameterType);

        $func2 = m::mock(TFunctionImportParameterType::class)->makePartial();
        $func2->shouldReceive('isOK')->andReturn(true)->once();
        $func2->shouldReceive('getName')->andReturn('name');
        $this->assertTrue($func2 instanceof TFunctionImportParameterType);

        $func3 = m::mock(TFunctionImportParameterType::class)->makePartial();
        $func3->shouldReceive('isOK')->andReturn(true)->once();
        $func3->shouldReceive('getName')->andReturn('name');
        $this->assertTrue($func3 instanceof TFunctionImportParameterType);

        $foo = m::mock(FunctionImportAnonymousType::class)->makePartial()->shouldAllowMockingProtectedMethods();
        $foo->shouldReceive('isObjectNullOrOK')->andReturn(true);
        $foo->shouldReceive('isValidArrayOK')->andReturn(true);
        $foo->shouldReceive('isTFunctionImportAttributesValid')->andReturn(true);
        $foo->setParameter([]);
        $foo->addToParameter($function);
        $foo->addToParameter($func2);
        $foo->addToParameter($func3);

        $this->assertFalse($foo->isOK($actual));
        $this->assertEquals($expected, $actual);
    }

    public function testIsNotOkFromBadDocumentation()

    {
        $expected = "";
        $actual = null;

        $documentation = m::mock(TDocumentationType::class);
        $documentation->shouldReceive('isOK')->andReturn(true, false)->once();
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.
}

        $foo = new FunctionImportAnonymousType();
        $foo->setDocumentation($documentation);

        $this->assertFalse($foo->isOK($actual));
        $this->assertEquals($expected, $actual);
    }
}


Push — master ( 861401...d44c24 )

testAddGoodParameter() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace AlgoWeb\ODataMetadata\Tests\v3\edm\EntityContainer;
4
5			use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\FunctionImportAnonymousType;
6			use AlgoWeb\ODataMetadata\MetadataV3\edm\TDocumentationType;
7			use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportParameterType;
8			use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType;
9			use AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType;
10			use AlgoWeb\ODataMetadata\Tests\TestCase;
11			use Mockery as m;
12
13			class FunctionImportAnonymousTypeTest extends TestCase
14			{
15			public function testIsComposableRoundTripTrue()
16			{
17			$foo = new FunctionImportAnonymousType();
18
19			$foo->setIsComposable('foo');
			1 ignored issue – show Documentation introduced 2017-06-12 14:12 UTC by Report Bug Copy Issue Report `'foo'` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
20			$this->assertTrue($foo->getIsComposable());
21			}
22
23			public function testIsComposableRoundTripFalse()
24			{
25			$foo = new FunctionImportAnonymousType();
26
27			$foo->setIsComposable(null);
			1 ignored issue – show Documentation introduced 2017-06-12 14:12 UTC by Report Bug Copy Issue Report `null` is of type `null`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
28			$this->assertFalse($foo->getIsComposable());
29			}
30
31			public function testIsSideEffectingRoundTripTrue()
32			{
33			$foo = new FunctionImportAnonymousType();
34
35			$foo->setIsSideEffecting('foo');
			1 ignored issue – show Documentation introduced 2017-06-12 14:12 UTC by Report Bug Copy Issue Report `'foo'` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
36			$this->assertTrue($foo->getIsSideEffecting());
37			}

Algo-Web / ODataMetadata

Push — master ( 861401...d44c24 )

testAddGoodParameter() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like