Spiral\Tests\Debug\DumperTest

Complexity

Total Complexity

1

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$1 ➔ __debugInfo()	0	4	1
A	hp$0 ➔ testErrorLog()	0	9	1
	testInvertedRenderer()	0	22	?
A	hp$5 ➔ testConsoleRenderer()	0	22	1
A	hp$0 ➔ testClosure()	0	10	1
A	testString()	0	6	1
	testAnonClass()	0	13	?
	testClosure()	0	10	?
A	hp$1 ➔ testDebugInfo()	0	18	1
A	testOutput()	0	9	1
A	testResource()	0	6	1
A	makeDumper()	0	8	1
	testSetRenderer()	0	6	?
	testDebugInfo()	0	18	?
	testHtmlRenderer()	0	21	?
A	hp$3 ➔ testHtmlRenderer()	0	21	1
	testConsoleRenderer()	0	22	?
	testErrorLog()	0	9	?
	testToLog()	0	7	?
A	hp$4 ➔ testInvertedRenderer()	0	22	1
A	hp$0 ➔ testToLogException()	0	6	1
A	hp$2 ➔ testSetRenderer()	0	6	1
A	testScalar()	0	6	1
A	hp$2 ➔ testinternal()	0	15	1
A	hp$0 ➔ testToLog()	0	7	1
A	hp$0 ➔ testTargetException()	0	6	1
	testToLogException()	0	6	?
A	testHTML()	0	6	1
A	hp$0 ➔ testAnonClass()	0	13	1
	testinternal()	0	15	?
	testTargetException()	0	6	?
A	testArray()	0	9	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Tests\Debug;

use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Spiral\Debug\Dumper;
use Spiral\Debug\Exception\DumperException;
use Spiral\Debug\Renderer\ConsoleRenderer;
use Spiral\Debug\Renderer\HtmlRenderer;
use Spiral\Debug\Renderer\PlainRenderer;

class DumperTest extends TestCase
{
    public function testOutput(): void
    {
        $d = $this->makeDumper();

        ob_start();
        $d->dump(1);
        $result = ob_get_clean();

        $this->assertSame($d->dump(1, Dumper::RETURN), $result);
    }

    private function makeDumper(LoggerInterface $logger = null)
    {
        $d = new Dumper($logger);
        $d->setRenderer(Dumper::OUTPUT, new PlainRenderer());
        $d->setRenderer(Dumper::RETURN, new PlainRenderer());
        $d->setRenderer(Dumper::OUTPUT_CLI_COLORS, new PlainRenderer());

        return $d;
    }

    public function testScalar(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump(123, Dumper::RETURN);

        $this->assertStringContainsString('123', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

    }

    public function testString(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump('hello world', Dumper::RETURN);

        $this->assertStringContainsString('hello world', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

    }

    public function testResource(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump(STDOUT, Dumper::RETURN);

        $this->assertStringContainsString('resource', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

    }

    public function testHTML(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump('hello <br/>world', Dumper::RETURN);

        $this->assertStringContainsString('hello &lt;br/&gt;world', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

    }

    public function testArray(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump(['G', 'B', 'N'], Dumper::RETURN);

        $this->assertStringContainsString('array', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('G', $result);
        $this->assertStringContainsString('B', $result);
        $this->assertStringContainsString('N', $result);
    }

    public function testAnonClass(): void
    {
        $d = $this->makeDumper();

        $result = $d->dump(new class() {
            private $name = 'Test';

The private property $name is not used, and could be removed.

        }, Dumper::RETURN);

        $this->assertStringContainsString('object', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('private', $result);
        $this->assertStringContainsString('name', $result);
        $this->assertStringContainsString('string(4)', $result);
        $this->assertStringContainsString('test', $result);
    }

    public function testClosure(): void
    {
        $d = $this->makeDumper();

        $result = $d->dump(static function (): void {
            echo 'hello world';
        }, Dumper::RETURN);

        $this->assertStringContainsString('Closure', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('DumperTest.php', $result);
    }

    public function testToLog(): void
    {
        $mock = $this->createMock(LoggerInterface::class);
        $d = $this->makeDumper($mock);

        $mock->method('debug')->with($d->dump('abc', Dumper::RETURN));
        $this->assertNull($d->dump('abc', Dumper::LOGGER));
    }

    public function testErrorLog(): void
    {
        $d = $this->makeDumper();

        ini_set('error_log', 'errors.log');
        $this->assertNull($d->dump('abc', Dumper::ERROR_LOG));

        $this->assertStringContainsString('abc', file_get_contents('errors.log'));
        unlink('errors.log');
    }

    public function testToLogException(): void
    {
        $this->expectException(DumperException::class);

        $d = $this->makeDumper();
        $this->assertNull($d->dump('abc', Dumper::LOGGER));
    }

    public function testTargetException(): void
    {
        $this->expectException(DumperException::class);

        $d = $this->makeDumper();
        $this->assertNull($d->dump('abc', 9));

Are you sure the usage of $d->dump('abc', 9) targeting Spiral\Debug\Dumper::dump() seems to always return null.

    }

    public function testDebugInfo(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump(new class() {
            protected $inner = '_kk_';

            public function __debugInfo()
            {
                return [
                    '_magic_' => '_value_',
                ];
            }
        }, Dumper::RETURN);

        $this->assertStringContainsString('_magic_', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('_value_', $result);
        $this->assertStringNotContainsString('inner', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringNotContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringNotContainsString('_kk_', $result);
    }

    public function testinternal(): void
    {
        $d = $this->makeDumper();
        $result = $d->dump(new class() {
            protected $visible = '_kk_';

            /** @internal */
            protected $internal = '_ok_';
        }, Dumper::RETURN);

        $this->assertStringContainsString('visible', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('_kk_', $result);

        $this->assertStringNotContainsString('internal', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringNotContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringNotContainsString('_ok_', $result);
    }

    public function testSetRenderer(): void
    {
        $this->expectException(DumperException::class);

        $d = $this->makeDumper();
        $d->setRenderer(8, new HtmlRenderer());
    }

    public function testHtmlRenderer(): void
    {
        $d = $this->makeDumper();
        $d->setRenderer(Dumper::RETURN, new HtmlRenderer());

        $result = $d->dump(new class() {
            protected static $static = 'yes';

            private $value = 123;

The private property $value is not used, and could be removed.

            protected $visible = '_kk_';

            /** @internal */
            protected $internal = '_ok_';
        }, Dumper::RETURN);

        $this->assertStringContainsString('visible', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('_kk_', $result);

        $this->assertStringNotContainsString('internal', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringNotContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringNotContainsString('_ok_', $result);
    }

    public function testInvertedRenderer(): void
    {
        $d = $this->makeDumper();
        $d->setRenderer(Dumper::RETURN, new HtmlRenderer(HtmlRenderer::INVERTED));
        $d->setMaxLevel(5);

        $result = $d->dump(new class() {
            private $value = 123;

The private property $value is not used, and could be removed.

            protected $visible = '_kk_';

            public $data = ['name' => 'value'];

            /** @internal */
            protected $internal = '_ok_';
        }, Dumper::RETURN);

        $this->assertStringContainsString('visible', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('_kk_', $result);

        $this->assertStringNotContainsString('internal', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringNotContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringNotContainsString('_ok_', $result);
    }

    public function testConsoleRenderer(): void
    {
        $d = $this->makeDumper();
        $d->setRenderer(Dumper::RETURN, new ConsoleRenderer());
        $d->setMaxLevel(5);

        $result = $d->dump(new class() {
            private $value = 123;

The private property $value is not used, and could be removed.

            protected $visible = '_kk_';

            public $data = ['name' => 'value'];

            /** @internal */
            protected $internal = '_ok_';
        }, Dumper::RETURN);

        $this->assertStringContainsString('visible', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringContainsString('_kk_', $result);

        $this->assertStringNotContainsString('internal', $result);

It seems like $result can also be of type null; however, parameter $haystack of PHPUnit\Framework\Assert::assertStringNotContainsString() does only seem to accept string, maybe add an additional type check?

        $this->assertStringNotContainsString('_ok_', $result);
    }
}