EntitySetAnonymousTypeTest::testAddBadDocumentation() - 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

testAddBadDocumentation() A

↳ Parent: EntitySetAnonymousTypeTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	17
Code Lines	11

Duplication

Lines	17
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	17
loc	17
rs	9.4285
c	1
b	0
f	0
cc	2
eloc	11
nc	2
nop	0

<?php

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

use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\EntitySetAnonymousType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TDocumentationType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TTypeAnnotationType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TValueAnnotationType;
use AlgoWeb\ODataMetadata\Tests\TestCase;
use Mockery as m;

class EntitySetAnonymousTypeTest extends TestCase
{
    public function testSetBadName()
    {
        $expected = "Name must be a valid TSimpleIdentifier";
        $actual = null;

        $foo = new EntitySetAnonymousType();
        $name = " _ ";

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

    public function testSetBadEntityType()
    {
        $expected = "Entity type must be a valid TQualifiedName";
        $actual = null;

        $foo = new EntitySetAnonymousType();
        $name = " _ ";

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

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

        $foo = new EntitySetAnonymousType();
        $name = " _ ";

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

    public function testIsTEntitySetAttributesOKBadName()

    {
        $expectedStarts = "Name must be a valid TSimpleIdentifier";
        $expectedEnds = "AlgoWeb_ODataMetadata_MetadataV3_edm_EntityContainer_EntitySetAnonymousType";
        $actual = null;

        $foo = m::mock(EntitySetAnonymousType::class)->makePartial();
        $foo->shouldReceive('isTSimpleIdentifierValid')->andReturn(true, false)->twice();
        
        $foo->setName(" _ ");
        
        $this->assertFalse($foo->isTEntitySetAttributesOK($actual));
        $this->assertStringStartsWith($expectedStarts, $actual);
        $this->assertStringEndsWith($expectedEnds, $actual);
    }

    public function testIsTEntitySetAttributesOKBadEntityType()

    {
        $expectedStarts = "Entity type must be a valid TQualifiedName";
        $expectedEnds = "AlgoWeb_ODataMetadata_MetadataV3_edm_EntityContainer_EntitySetAnonymousType";
        $actual = null;

        $foo = m::mock(EntitySetAnonymousType::class)->makePartial();
        $foo->shouldReceive('isTQualifiedNameValid')->andReturn(true, false)->twice();

        $foo->setEntityType(" _ ");

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

    public function testIsTEntitySetAttributesOKBadGetterAccess()

    {
        $expectedStarts = "Getter access must be a valid TAccess";
        $expectedEnds = "AlgoWeb_ODataMetadata_MetadataV3_edm_EntityContainer_EntitySetAnonymousType";
        $actual = null;

        $foo = m::mock(EntitySetAnonymousType::class)->makePartial();
        $foo->shouldReceive('isTAccessOk')->andReturn(true, false)->twice();

        $foo->setGetterAccess(" _ ");

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

    public function testSetBadTypeAnnotation()

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

        $type = m::mock(TTypeAnnotationType::class)->makePartial();
        $type->shouldReceive('isOK')->andReturn(false);

        $foo = new EntitySetAnonymousType();

        try {
            $foo->setTypeAnnotation([$type]);
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 testAddBadTypeAnnotation()

    {
        $expected = '';
        $actual = null;

        $type = m::mock(TTypeAnnotationType::class)->makePartial();
        $type->shouldReceive('isOK')->andReturn(false);

        $foo = new EntitySetAnonymousType();

        try {
            $foo->addToTypeAnnotation($type);
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 testAddGoodTypeAnnotation()

    {
        $type = m::mock(TTypeAnnotationType::class)->makePartial();
        $type->shouldReceive('isOK')->andReturn(true);

        $foo = new EntitySetAnonymousType();

        $foo->addToTypeAnnotation($type);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertTrue($foo->issetTypeAnnotation(0));
        $foo->unsetTypeAnnotation(0);
        $this->assertFalse($foo->issetTypeAnnotation(0));
    }

    public function testAddBadDocumentation()

    {
        $expected = '';
        $actual = null;

        $doc = m::mock(TDocumentationType::class);
        $doc->shouldReceive('isOK')->andReturn(false);
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 EntitySetAnonymousType();

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

    public function testAddGoodDocumentation()

    {
        $doc = m::mock(TDocumentationType::class);
        $doc->shouldReceive('isOK')->andReturn(true);
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 EntitySetAnonymousType();

        $foo->addToDocumentation($doc);
        $this->assertTrue($foo->issetDocumentation(0));
        $foo->unsetDocumentation(0);
        $this->assertFalse($foo->issetDocumentation(0));
    }

    public function testSetBadDocumentation()

    {
        $expected = '';
        $actual = null;

        $doc = m::mock(TDocumentationType::class);
        $doc->shouldReceive('isOK')->andReturn(false);
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 EntitySetAnonymousType();

        try {
            $foo->setDocumentation([$doc]);
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 testSetBadValueAnnotation()

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

        $type = m::mock(TValueAnnotationType::class)->makePartial();
        $type->shouldReceive('isOK')->andReturn(false);

        $foo = new EntitySetAnonymousType();

        try {
            $foo->setValueAnnotation([$type]);
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 testAddBadValueAnnotation()

    {
        $expected = '';
        $actual = null;

        $type = m::mock(TValueAnnotationType::class)->makePartial();
        $type->shouldReceive('isOK')->andReturn(false);

        $foo = new EntitySetAnonymousType();

        try {
            $foo->addToValueAnnotation($type);
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 testAddGoodValueAnnotation()

    {
        $type = m::mock(TValueAnnotationType::class)->makePartial();
        $type->shouldReceive('isOK')->andReturn(true);

        $foo = new EntitySetAnonymousType();

        $foo->addToValueAnnotation($type);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertTrue($foo->issetValueAnnotation(0));
        $foo->unsetValueAnnotation(0);
        $this->assertFalse($foo->issetValueAnnotation(0));
    }

    public function testIsOkTooManyDocumentation()

    {
        $expected = 'Supplied array not a valid array: '
                    .'AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\EntitySetAnonymousType';
        $actual = null;

        $doc = m::mock(TDocumentationType::class);
        $doc->shouldReceive('isOK')->andReturn(true);
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 EntitySetAnonymousType();
        $foo->addToDocumentation($doc);
        $foo->addToDocumentation($doc);

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

    public function testIsOKBadTypeAnnotations()

    {
        $expected = '';
        $actual = null;

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

        $foo = new EntitySetAnonymousType();
        $foo->addToTypeAnnotation($type);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

    public function testIsOKBadValueAnnotations()

    {
        $expected = '';
        $actual = null;

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

        $foo = new EntitySetAnonymousType();
        $foo->addToValueAnnotation($type);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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


Push — master ( 861401...d44c24 )

testAddBadDocumentation() A

Complexity

Size

Duplication

Importance

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\EntitySetAnonymousType;
6			use AlgoWeb\ODataMetadata\MetadataV3\edm\TDocumentationType;
7			use AlgoWeb\ODataMetadata\MetadataV3\edm\TTypeAnnotationType;
8			use AlgoWeb\ODataMetadata\MetadataV3\edm\TValueAnnotationType;
9			use AlgoWeb\ODataMetadata\Tests\TestCase;
10			use Mockery as m;
11
12			class EntitySetAnonymousTypeTest extends TestCase
13			{
14			public function testSetBadName()
15			{
16			$expected = "Name must be a valid TSimpleIdentifier";
17			$actual = null;
18
19			$foo = new EntitySetAnonymousType();
20			$name = " _ ";
21
22			try {
23			$foo->setName($name);
24			} catch (\InvalidArgumentException $e) {
25			$actual = $e->getMessage();
26			}
27			$this->assertEquals($expected, $actual);
28			}
29
30			public function testSetBadEntityType()
31			{
32			$expected = "Entity type must be a valid TQualifiedName";
33			$actual = null;
34
35			$foo = new EntitySetAnonymousType();
36			$name = " _ ";
37
38			try {
39			$foo->setEntityType($name);
40			} catch (\InvalidArgumentException $e) {

Algo-Web / ODataMetadata

Push — master ( 861401...d44c24 )

testAddBadDocumentation() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like