TypeFunctionsTest::typeDescriptionProvider() - Code Metrics - Inspection of "Added function get_type_description" - jasny/php-functions - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 1fe131...339793 )

by Arnold
created 2018-09-21 07:03 UTC
TypeFunctionsTest::typeDescriptionProvider() A

↳ Parent: TypeFunctionsTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	14
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	11
nc	1
nop	0
dl	0
loc	14
rs	9.9
c	0
b	0
f	0
<?php

namespace Jasny\Tests;

use function Jasny\get_type_description;
use PHPStan\Testing\TestCase;

use function Jasny\expect_type;
use function Jasny\is_associative_array;
use function Jasny\is_numeric_array;
use function Jasny\objectify;
use function Jasny\arrayify;

/**
 * Test type functions
 * @coversNothing
 */
class TypeFunctionsTest extends TestCase
{
    const NONE = 0;
    const NUMERIC = 1;
    const ASSOC = 2;
    
    public function varProvider()
    {
        return [
            [['foo', 'bar'], self::NUMERIC],
            [['a' => 'foo', 'b' => 'bar'], self::ASSOC],
            [[1 => 'foo', 'bar'], self::ASSOC],
            [['foo', 'b' => 'bar'], self::ASSOC],
            [['foo', 2 => 'bar'], self::ASSOC],
            [[], self::NUMERIC],
            ['foo', self::NONE],
            [(object)['a' => 'b'], self::NONE]
        ];
    }
    
    /**
     * @covers Jasny\is_associative_array
     * @dataProvider varProvider
     * 
     * @param mixed $var
     * @param int   $type
     */
    public function testIsAssociativeArray($var, $type)
    {
        $this->assertEquals($type === self::ASSOC, is_associative_array($var));
    }
    
    /**
     * @covers Jasny\is_numeric_array
     * @dataProvider varProvider
     * 
     * @param mixed $var
     * @param int   $type
     */
    public function testIsNumericArray($var, $type)
    {
        $this->assertEquals($type === self::NUMERIC, is_numeric_array($var));
    }
    
    
    public function objectifyProvider()
    {
        return [
            [
                'foo',
                'foo'
            ],
            [
                ['a' => 'foo'],
                (object)['a' => 'foo']
            ],
            [
                ['foo', 'bar', 'zoo'],
                ['foo', 'bar', 'zoo']
            ],
            [
                ['a' => ['b' => ['c' => 'foo']]],
                (object)['a' => (object)['b' => (object)['c' => 'foo']]]
            ],
            [
                (object)['a' => ['b' => ['c' => 'foo']]],
                (object)['a' => (object)['b' => (object)['c' => 'foo']]]
            ],
            [
                ['a' => 'foo', 'b' => ['bar', 'zoo'], 'c' => true],
                (object)['a' => 'foo', 'b' => ['bar', 'zoo'], 'c' => true]
            ],
            [
                [1 => 'a', 'b'],
                (object)['1' => 'a', '2' => 'b']
            ],
            [
                [],
                []
            ]
        ];
    }
    
    /**
     * @covers Jasny\objectify
     * @dataProvider objectifyProvider
     * 
     * @param mixed $var
     * @param mixed $expect
     */
    public function testObjectify($var, $expect)
    {
        $this->assertEquals($expect, objectify($var));
    }
    
    
    public function arrayifyProvider()
    {
        return [
            [
                'foo',
                'foo'
            ],
            [
                (object)['a' => 'foo'],
                ['a' => 'foo']
            ],
            [
                (object)['a' => (object)['b' => (object)['c' => 'foo']]],
                ['a' => ['b' => ['c' => 'foo']]],
            ],
            [
                ['a' => (object)['b' => (object)['c' => 'foo']]],
                ['a' => ['b' => ['c' => 'foo']]]
            ],
            [
                (object)['date' => new \DateTime('2000-01-01')],
                ['date' => new \DateTime('2000-01-01')]
            ],
            [
                new \stdClass(),
                []
            ]
        ];
    }
    
    /**
     * @covers Jasny\arrayify
     * @dataProvider arrayifyProvider
     * 
     * @param mixed $var
     * @param mixed $expect
     */
    public function testArrayify($var, $expect)
    {
        $this->assertEquals($expect, arrayify($var));
    }

    
    public function circularReferenceProvider()
    {
        $object = new \stdClass();
        $object->items = [
            'foo',
            $object
        ];
        
        return [
            [$object]
        ];
    }
    
    /**
     * @covers Jasny\objectify
     * @dataProvider circularReferenceProvider
     * 
     * @expectedException \OverflowException
     * @expectedExceptionMessage Maximum recursion depth reached. Possible circular reference.
     */
    public function testObjectifyCircularReference(\stdClass $object)
    {
        objectify($object);
    }
    
    /**
     * @covers Jasny\arrayify
     * @dataProvider circularReferenceProvider
     * 
     * @expectedException \OverflowException
     * @expectedExceptionMessage Maximum recursion depth reached. Possible circular reference.
     */
    public function testArrayifyCircularReference(\stdClass $object)
    {
        arrayify($object);
    }

    public function typeDescriptionProvider()
    {
        $closedResource = fopen('php://memory', 'r+');
        fclose($closedResource);
        fclose(/** @scrutinizer ignore-type */ $closedResource);

        return [
            [10, 'integer'],
            [10.2, 'float'],
            [true, 'boolean'],
            [[], 'array'],
            [(object)[], 'stdClass object'],
            [new \DateTime(), 'DateTime object'],
            [fopen('data://text/plain,hello', 'r'), 'stream resource'],
            [$closedResource, 'resource (closed)']
        ];
    }

    /**
     * @covers Jasny\get_type_description
     * @dataProvider typeDescriptionProvider
     */
    public function testGetTypeDescription($var, $expected)
    {
        $type = get_type_description($var);

        $this->assertSame($expected, $type);
    }

    
    public function expectTypeProvider()
    {
        $closedResource = fopen('php://memory', 'r+');
        fclose($closedResource);
        fclose(/** @scrutinizer ignore-type */ $closedResource);

        return [
            [10, 'int'],
            [true, 'bool'],
            [[], 'array'],
            [(object)[], 'stdClass'],
            [10, ['int', 'boolean']],
            ['foo', 'int', "Expected int, string given"],
            ['foo', ['int', 'boolean'], "Expected int or boolean, string given"],
            [(object)[], 'Foo', "Expected Foo object, stdClass object given"],
            [fopen('data://text/plain,hello', 'r'), 'string', "Expected string, stream resource given"],
            [$closedResource, 'string', "Expected string, resource (closed) given"]
        ];
    }
    
    /**
     * @covers Jasny\expect_type
     * @dataProvider expectTypeProvider
     * 
     * @param mixed           $var
     * @param string|string[] $type
     * @param string|false    $error
     */
    public function testExpectType($var, $type, $error = false)
    {
        if ($error) {
            $this->expectException(\InvalidArgumentException::class);
            $this->expectExceptionMessage($error);
        }
        
        expect_type($var, $type, \InvalidArgumentException::class);

        $this->assertTrue(true); // No warnings
    }
    
    /**
     * @covers Jasny\expect_type
     * 
     * @expectedException Exception
     * @expectedExceptionMessage Lorem ipsum string black
     */
    public function testExpectTypeExplicitMessage()
    {
        expect_type('foo', 'int', \Exception::class, "Lorem ipsum %s black");
    }
}

jasny / php-functions

Push — master ( 1fe131...339793 )

TypeFunctionsTest::typeDescriptionProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
