Yiisoft\Yii\Debug\Tests\DumperTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	253
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	asJsonObjectMapDataProvider()	0	22	1
A	assertEqualsWithoutLE()	0	5	1
A	testAsJson()	0	4	1
A	testAsJsonObjectsMap()	0	4	1
B	jsonDataProvider()	0	185	1

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Debug\Tests;

use PHPUnit\Framework\TestCase;
use stdClass;
use Yiisoft\Yii\Debug as D;
use Yiisoft\Yii\Debug\Dumper;

final class DumperTest extends TestCase
{
    /**
     * @dataProvider asJsonObjectMapDataProvider
     *
     * @param mixed $var
     * @param string $expectedResult
     *
     * @group JOM
     */
    public function testAsJsonObjectsMap($var, $expectedResult): void
    {
        $exportResult = Dumper::create($var)->asJsonObjectsMap();
        $this->assertEquals($expectedResult, $exportResult);
    }

    public function asJsonObjectMapDataProvider(): array
    {
        $user = new stdClass();
        $user->id = 1;
        $objectId = spl_object_id($user);

        $decoratedUser = clone $user;
        $decoratedUser->name = 'Name';
        $decoratedUser->originalUser = $user;
        $decoratedObjectId = spl_object_id($decoratedUser);

        return [
            [
                $user,
                <<<S
                [{"stdClass#{$objectId}":{"public \$id":1}}]
                S,
            ],
            [
                $decoratedUser,
                <<<S
                [{"stdClass#{$decoratedObjectId}":{"public \$id":1,"public \$name":"Name","public \$originalUser":"object@stdClass#{$objectId}"}},{"stdClass#{$objectId}":{"public \$id":1}}]
                S,
            ],
        ];
    }

    /**
     * @dataProvider jsonDataProvider()
     */
    public function testAsJson($variable, string $result): void
    {
        $output = Dumper::create($variable)->asJson();
        $this->assertEqualsWithoutLE($result, $output);
    }

    public function jsonDataProvider(): array
    {
        $objectWithClosureInProperty = new stdClass();
        // @formatter:off
        $objectWithClosureInProperty->a = fn () => 1;
        // @formatter:on
        $objectWithClosureInPropertyId = spl_object_id($objectWithClosureInProperty);
        $objectWithClosureInPropertyClosureId = spl_object_id($objectWithClosureInProperty->a);

$objectWithClosureInProperty->a of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        $emptyObject = new stdClass();
        $emptyObjectId = spl_object_id($emptyObject);

        // @formatter:off
        $shortFunctionObject = fn () => 1;
        // @formatter:on
        $shortFunctionObjectId = spl_object_id($shortFunctionObject);

$shortFunctionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $staticShortFunctionObject = static fn () => 1;
        // @formatter:on
        $staticShortFunctionObjectId = spl_object_id($staticShortFunctionObject);

$staticShortFunctionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $functionObject = function () {
            return 1;
        };
        // @formatter:on
        $functionObjectId = spl_object_id($functionObject);

$functionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $staticFunctionObject = static function () {
            return 1;
        };
        // @formatter:on
        $staticFunctionObjectId = spl_object_id($staticFunctionObject);

$staticFunctionObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $closureWithNullCollisionOperatorObject = fn () => $_ENV['var'] ?? null;
        // @formatter:on
        $closureWithNullCollisionOperatorObjectId = spl_object_id($closureWithNullCollisionOperatorObject);

$closureWithNullCollisionOperatorObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $closureWithUsualClassNameObject = fn (Dumper $date) => new \DateTimeZone('');

The parameter $date is not used and could be removed.

        // @formatter:on
        $closureWithUsualClassNameObjectId = spl_object_id($closureWithUsualClassNameObject);

$closureWithUsualClassNameObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $closureWithAliasedClassNameObject = fn (Dumper $date) => new \DateTimeZone('');

The parameter $date is not used and could be removed.

        // @formatter:on
        $closureWithAliasedClassNameObjectId = spl_object_id($closureWithAliasedClassNameObject);

$closureWithAliasedClassNameObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $closureWithAliasedNamespaceObject = fn (D\Dumper $date) => new \DateTimeZone('');

The parameter $date is not used and could be removed.

        // @formatter:on
        $closureWithAliasedNamespaceObjectId = spl_object_id($closureWithAliasedNamespaceObject);

$closureWithAliasedNamespaceObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        // @formatter:off
        $closureInArrayObject = fn () => new \DateTimeZone('');
        // @formatter:on
        $closureInArrayObjectId = spl_object_id($closureInArrayObject);

$closureInArrayObject of type callable is incompatible with the type object expected by parameter $object of spl_object_id().

        return [
            'empty object' => [
                $emptyObject,
                <<<S
                {"stdClass#{$emptyObjectId}":"{stateless object}"}
                S,
            ],
            'short function' => [
                $shortFunctionObject,
                <<<S
                {"Closure#{$shortFunctionObjectId}":"fn () => 1"}
                S,
            ],
            'short static function' => [
                $staticShortFunctionObject,
                <<<S
                {"Closure#{$staticShortFunctionObjectId}":"static fn () => 1"}
                S,
            ],
            'function' => [
                $functionObject,
                <<<S
                {"Closure#{$functionObjectId}":"function () {\\n            return 1;\\n        }"}
                S,
            ],
            'static function' => [
                $staticFunctionObject,
                <<<S
                {"Closure#{$staticFunctionObjectId}":"static function () {\\n            return 1;\\n        }"}
                S,
            ],
            'string' => [
                'Hello, Yii!',
                '"Hello, Yii!"',
            ],
            'empty string' => [
                '',
                '""',
            ],
            'null' => [
                null,
                'null',
            ],
            'integer' => [
                1,
                '1',
            ],
            'integer with separator' => [
                1_23_456,

The constant Yiisoft\Yii\Debug\Tests\1_23_456 was not found. Maybe you did not declare it correctly or list all dependencies?

                '123456',
            ],
            'boolean' => [
                true,
                'true',
            ],
            'resource' => [
                fopen('php://input', 'rb'),
                '{"timed_out":false,"blocked":true,"eof":false,"wrapper_type":"PHP","stream_type":"Input","mode":"rb","unread_bytes":0,"seekable":true,"uri":"php:\/\/input"}',
            ],
            'empty array' => [
                [],
                '[]',
            ],
            'array of 3 elements, automatic keys' => [
                [
                    'one',
                    'two',
                    'three',
                ],
                '["one","two","three"]',
            ],
            'array of 3 elements, custom keys' => [
                [
                    2 => 'one',
                    'two' => 'two',
                    0 => 'three',
                ],
                '{"2":"one","two":"two","0":"three"}',
            ],
            'closure in array' => [
                // @formatter:off
                [$closureInArrayObject],
                // @formatter:on
                <<<S
                [{"Closure#{$closureInArrayObjectId}":"fn () => new \\\DateTimeZone('')"}]
                S,
            ],
            'original class name' => [
                $closureWithUsualClassNameObject,
                <<<S
                {"Closure#{$closureWithUsualClassNameObjectId}":"fn (\\\Yiisoft\\\Yii\\\Debug\\\Dumper \$date) => new \\\DateTimeZone('')"}
                S,
            ],
            'class alias' => [
                $closureWithAliasedClassNameObject,
                <<<S
                {"Closure#{$closureWithAliasedClassNameObjectId}":"fn (\\\Yiisoft\\\Yii\\\Debug\\\Dumper \$date) => new \\\DateTimeZone('')"}
                S,
            ],
            'namespace alias' => [
                $closureWithAliasedNamespaceObject,
                <<<S
                {"Closure#{$closureWithAliasedNamespaceObjectId}":"fn (\\\Yiisoft\\\Yii\\\Debug\\\Dumper \$date) => new \\\DateTimeZone('')"}
                S,
            ],
            'closure with null-collision operator' => [
                $closureWithNullCollisionOperatorObject,
                <<<S
                {"Closure#{$closureWithNullCollisionOperatorObjectId}":"fn () => \$_ENV['var'] ?? null"}
                S,
            ],
            'utf8 supported' => [
                '🤣',
                '"🤣"',
            ],
            'closure in property supported' => [
                $objectWithClosureInProperty,
                <<<S
                {"stdClass#{$objectWithClosureInPropertyId}":{"public \$a":{"Closure#{$objectWithClosureInPropertyClosureId}":"fn () => 1"}}}
                S,
            ],
            'binary string' => [
                pack('H*', md5('binary string')),
                '"ɍ��^��\u00191\u0017�]�-f�"',
            ],
        ];
    }

    /**
     * Asserting two strings equality ignoring line endings.
     *
     * @param string $expected
     * @param string $actual
     * @param string $message
     */
    protected function assertEqualsWithoutLE(string $expected, string $actual, string $message = ''): void
    {
        $expected = str_replace(["\r\n", '\r\n'], ["\n", '\n'], $expected);
        $actual = str_replace(["\r\n", '\r\n'], ["\n", '\n'], $actual);
        $this->assertEquals($expected, $actual, $message);
    }
}