SplFileInfoRepresentationTest::testConstructLinkedFile() - Code Metrics - Inspection of "SplFileInfoRepresentationTest" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — test ( 71734b...8babba )

by Jonathan

created 2018-04-06 19:11 UTC

testConstructLinkedFile() B

↳ Parent: SplFileInfoRepresentationTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	26
Code Lines	20

Duplication

Lines	26
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	20
nc	2
nop	0
dl	26
loc	26
rs	8.8571
c	1
b	0
f	0

<?php

namespace Kint\Test\Object\Representation;

use DateTime;
use Kint\Object\Representation\SplFileInfoRepresentation;
use Kint\Test\KintTestCase;
use SplFileInfo;
use UnexpectedValueException;

class SplFileInfoRepresentationTest extends KintTestCase
{
    protected $socket;

    public function setUp()
    {
        symlink(__DIR__, __DIR__.'/testDirLink');
        symlink(__FILE__, __DIR__.'/testFileLink');
        symlink(__DIR__.'/testDirLink', __DIR__.'/testDirLink2');
        symlink(__DIR__.'/testFileLink', __DIR__.'/testFileLink2');
        posix_mkfifo(__DIR__.'/mkfifo', 0777);
        $this->socket = socket_create(AF_UNIX, SOCK_STREAM, 0);
    }

    public function tearDown()
    {
        unlink(__DIR__.'/testDirLink2');
        unlink(__DIR__.'/testFileLink2');
        unlink(__DIR__.'/testDirLink');
        unlink(__DIR__.'/testFileLink');
        unlink(__DIR__.'/mkfifo');
        socket_close($this->socket);
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructFile()

    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));


        $this->assertSame(filesize(__FILE__), $r->size);
        $this->assertSame(filectime(__FILE__), $r->ctime);
        $this->assertSame(filemtime(__FILE__), $r->mtime);
        $this->assertSame(fileperms(__FILE__), $r->perms);
        $this->assertSame(fileowner(__FILE__), $r->owner);
        $this->assertSame(filegroup(__FILE__), $r->group);
        $this->assertSame('File', $r->typename);
        $this->assertSame('-', $r->typeflag);
        $this->assertSame(__FILE__, $r->path);
        $this->assertSame(__FILE__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype(__FILE__) === 'file') {
            $this->assertTrue($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException(__FILE__.' type is not "file"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructFileLink()

    {
        $f = __DIR__.'/testFileLink2';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('File symlink', $r->typename);
        $this->assertSame('l', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__FILE__, $r->realpath);
        $this->assertSame(__DIR__.'/testFileLink', $r->linktarget);

        if (filetype($f) === 'link') {
            $this->assertTrue($r->is_link);
            $this->assertTrue($r->is_file);
            $this->assertFalse($r->is_dir);
        } else {
            throw new UnexpectedValueException($f.' type is not "link"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructLinkedFile()

    {
        $f = __DIR__.'/testDirLink/'.basename(__FILE__);


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('File', $r->typename);
        $this->assertSame('-', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__FILE__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'file') {
            $this->assertTrue($r->is_file);
            $this->assertFalse($r->is_link);
            $this->assertFalse($r->is_dir);
        } else {
            throw new UnexpectedValueException($f.' type is not "file"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructDir()

    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__DIR__));


        $this->assertSame(filesize(__DIR__), $r->size);
        $this->assertSame(filectime(__DIR__), $r->ctime);
        $this->assertSame(filemtime(__DIR__), $r->mtime);
        $this->assertSame(fileperms(__DIR__), $r->perms);
        $this->assertSame(fileowner(__DIR__), $r->owner);
        $this->assertSame(filegroup(__DIR__), $r->group);
        $this->assertSame('Directory', $r->typename);
        $this->assertSame('d', $r->typeflag);
        $this->assertSame(__DIR__, $r->path);
        $this->assertSame(__DIR__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype(__DIR__) === 'dir') {
            $this->assertTrue($r->is_dir);
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException(__DIR__.' type is not "dir"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructDirLink()

    {
        $f = __DIR__.'/testDirLink2';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Directory symlink', $r->typename);
        $this->assertSame('l', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__DIR__, $r->realpath);
        $this->assertSame(__DIR__.'/testDirLink', $r->linktarget);

        if (filetype($f) === 'link') {
            $this->assertTrue($r->is_link);
            $this->assertTrue($r->is_dir);
            $this->assertFalse($r->is_file);
        } else {
            throw new UnexpectedValueException($f.' type is not "link"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructLinkedDir()

    {
        $f = __DIR__.'/testDirLink/../'.basename(__DIR__);


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Directory', $r->typename);
        $this->assertSame('d', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__DIR__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'dir') {
            $this->assertTrue($r->is_dir);
            $this->assertFalse($r->is_link);
            $this->assertFalse($r->is_file);
        } else {
            throw new UnexpectedValueException($f.' type is not "dir"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructCharacterSpecial()

    {
        $f = '/dev/null';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Character device', $r->typename);
        $this->assertSame('c', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'char') {
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "char"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructBlockSpecial()

    {
        $f = '/dev/loop0';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Block device', $r->typename);
        $this->assertSame('b', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'block') {
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "block"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructSocket()

    {
        $f = '/proc/'.getmypid().'/fd/3';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Socket', $r->typename);
        $this->assertSame('s', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertFalse($r->realpath);
        $this->assertRegExp('/^socket:\[[0-9]+\]$/', $r->linktarget);

        if (filetype($f) === 'link') {
            $this->assertTrue($r->is_link);
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
        } else {
            throw new UnexpectedValueException($f.' type is not "link"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructPipe()

    {
        $f = __DIR__.'/mkfifo';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Named pipe', $r->typename);
        $this->assertSame('p', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'fifo') {
            $this->assertFalse($r->is_link);
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
        } else {
            throw new UnexpectedValueException($f.' type is not "fifo"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructNone()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__.'/nonexistant'));


        $this->assertNull($r->size);
        $this->assertNull($r->ctime);
        $this->assertNull($r->mtime);
        $this->assertNull($r->perms);
        $this->assertNull($r->owner);
        $this->assertNull($r->group);
        $this->assertSame('Unknown file', $r->typename);
        $this->assertSame('-', $r->typeflag);
        $this->assertNull($r->path);
        $this->assertNull($r->realpath);
        $this->assertNull($r->linktarget);
        $this->assertFalse($r->is_dir);
        $this->assertFalse($r->is_file);
        $this->assertFalse($r->is_link);
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::getLabel
     */
    public function testGetLabel()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));


        $r->typename = 'test123';
        $r->size = 1100;

        $this->assertSame('test123 (1.07KB)', $r->getLabel());
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::getSize
     */
    public function testGetSize()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));


        $r->size = 0;
        $this->assertNull($r->getSize());

        $r->size = 42;
        $this->assertSame('42B', $r->getSize());

        $r->size = 1024;
        $this->assertSame('1KB', $r->getSize());

        $r->size = 1100;
        $this->assertSame('1.07KB', $r->getSize());

        $r->size = 1024 * 1024;
        $this->assertSame('1MB', $r->getSize());
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::getMTime
     */
    public function testGetMTime()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));

        $r->mtime = 0;

        $this->assertSame('Jan 01 1970', $r->getMTime());

        $dt = new DateTime('midnight +1 hour +23 minutes');

        $r->mtime = $dt->format('U');

        $this->assertSame(date('M d').' 01:23', $r->getMTime());
    }
}


1		<?php
2
3		namespace Kint\Test\Object\Representation;
4
5		use DateTime;
6		use Kint\Object\Representation\SplFileInfoRepresentation;
7		use Kint\Test\KintTestCase;
8		use SplFileInfo;
9		use UnexpectedValueException;
10
11		class SplFileInfoRepresentationTest extends KintTestCase
12		{
13		protected $socket;
14
15		public function setUp()
16		{
17		symlink(__DIR__, __DIR__.'/testDirLink');
18		symlink(__FILE__, __DIR__.'/testFileLink');
19		symlink(__DIR__.'/testDirLink', __DIR__.'/testDirLink2');
20		symlink(__DIR__.'/testFileLink', __DIR__.'/testFileLink2');
21		posix_mkfifo(__DIR__.'/mkfifo', 0777);
22		$this->socket = socket_create(AF_UNIX, SOCK_STREAM, 0);
23		}
24
25		public function tearDown()
26		{
27		unlink(__DIR__.'/testDirLink2');
28		unlink(__DIR__.'/testFileLink2');
29		unlink(__DIR__.'/testDirLink');
30		unlink(__DIR__.'/testFileLink');
31		unlink(__DIR__.'/mkfifo');
32		socket_close($this->socket);
33		}
34
35		/**
36		* @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
37		*/
38	View Code Duplication	public function testConstructFile()
		0 ignored issues – show Duplication introduced 2018-04-06 19:15 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
39		{

jnvsor / kint

Push — test ( 71734b...8babba )

testConstructLinkedFile() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like