Graze\DataFile\Test\Unit\Node\FileNodeTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	2
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testSetFileSystemUpdatesTheFileSystem()	0	23	1
A	getFilesystem()	0	9	1
A	testInstanceOf()	0	10	1
A	testEmptyFileWillReturnEmptyArrayForGetContents()	0	11	1
A	testWhenCopyFailsItRaisesAnException()	0	15	1

<?php
/**
 * This file is part of graze/data-file
 *
 * Copyright (c) 2016 Nature Delivered Ltd. <https://www.graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license https://github.com/graze/data-file/blob/master/LICENSE.md
 * @link    https://github.com/graze/data-file
 */

namespace Graze\DataFile\Test\Unit\Node;

use Graze\DataFile\Format\FormatAwareInterface;
use Graze\DataFile\Modify\Compress\CompressionAwareInterface;
use Graze\DataFile\Modify\Encoding\EncodingAwareInterface;
use Graze\DataFile\Modify\Exception\CopyFailedException;
use Graze\DataFile\Node\FileNode;
use Graze\DataFile\Node\FileNodeInterface;
use Graze\DataFile\Test\TestCase;
use League\Flysystem\AdapterInterface;
use League\Flysystem\Filesystem;
use Mockery as m;

class FileNodeTest extends TestCase
{
    /**
     * @return mixed Really a Filesystem|MockInterface but coding standards get confused
     */
    private function getFilesystem()
    {
        $fileSystem = m::mock(Filesystem::class);
        $fileSystem->shouldReceive('getAdapter')
                   ->andReturn(m::mock(AdapterInterface::class));
        $fileSystem->shouldReceive('getConfig')
                   ->andReturn(null);
        return $fileSystem;
    }

    public function testInstanceOf()
    {
        $fileSystem = $this->getFilesystem();
        $file = new FileNode($fileSystem, 'not/nop');

        static::assertInstanceOf(FileNodeInterface::class, $file);
        static::assertInstanceOf(FormatAwareInterface::class, $file);
        static::assertInstanceOf(CompressionAwareInterface::class, $file);
        static::assertInstanceOf(EncodingAwareInterface::class, $file);
    }

    public function testEmptyFileWillReturnEmptyArrayForGetContents()
    {
        $fileSystem = $this->getFilesystem();
        $file = new FileNode($fileSystem, 'not/exists');

        $fileSystem->shouldReceive('has')
                   ->with('not/exists')
                   ->andReturn(false);

        static::assertEquals([], $file->getContents());
    }

    public function testWhenCopyFailsItRaisesAnException()
    {
        $fileSystem = $this->getFilesystem();
        $localFile = new FileNode($fileSystem, 'some/random');

        $newPath = new FileNode($fileSystem, 'some/target');

        $fileSystem->shouldReceive('copy')
                   ->with($localFile->getPath(), $newPath->getPath())
                   ->andReturn(false);

        $this->expectException(CopyFailedException::class);

        $localFile->copy($newPath->getPath());
    }

    public function testSetFileSystemUpdatesTheFileSystem()
    {
        $first = $this->getFilesystem();
        $second = $this->getFilesystem();

        $file = new FileNode($first, 'file/check');

        $first->shouldReceive('has')
              ->with('file/check')
              ->once()
              ->andReturn(true);

        static::assertTrue($file->getFilesystem()->has('file/check'));

        $second->shouldReceive('has')
               ->with('file/check')
               ->once()
               ->andReturn(false);

        static::assertSame($file, $file->setFilesystem($second));

        static::assertFalse($file->getFilesystem()->has('file/check'));
    }
}