eZ\Publish\Core\IO\Tests\IOMetadataHandler\FlysystemTest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	248
Duplicated Lines	16.13 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	5	1
B	testCreate()	0	31	1
A	testDelete()	0	5	1
B	testLoad()	0	25	1
A	testLoadNotFound()	10	10	1
A	testExists()	10	10	1
A	testExistsNot()	10	10	1
A	testGetMimeType()	10	10	1
A	testDeleteDirectory()	0	5	1
A	testLoadNoTimestamp()	0	17	1
A	testCount()	0	18	1
B	providerLoadList()	0	38	1
B	testLoadList()	0	34	3

<?php

/**
 * This file is part of the eZ Publish Kernel package.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\IO\Tests\IOMetadataHandler;

use eZ\Publish\Core\IO\IOMetadataHandler\Flysystem;
use eZ\Publish\SPI\IO\BinaryFile as SPIBinaryFile;
use eZ\Publish\SPI\IO\BinaryFileCreateStruct as SPIBinaryFileCreateStruct;
use League\Flysystem\FileNotFoundException;
use PHPUnit_Framework_TestCase;
use DateTime;

class FlysystemTest extends PHPUnit_Framework_TestCase
{
    /** @var \eZ\Publish\Core\IO\IOMetadataHandler|\PHPUnit_Framework_MockObject_MockObject */
    private $handler;

    /** @var \League\Flysystem\FilesystemInterface|\PHPUnit_Framework_MockObject_MockObject */
    private $filesystem;

    public function setUp()
    {
        $this->filesystem = $this->getMock('League\Flysystem\FilesystemInterface');
        $this->handler = new Flysystem($this->filesystem);
    }

    public function testCreate()
    {
        // good example of bad responsibilities... since create also loads, we test the same thing twice
        $spiCreateStruct = new SPIBinaryFileCreateStruct();
        $spiCreateStruct->id = 'prefix/my/file.png';
        $spiCreateStruct->size = 123;
        $spiCreateStruct->mtime = new DateTime('@1307155200');

        $expectedSpiBinaryFile = new SPIBinaryFile();
        $expectedSpiBinaryFile->id = 'prefix/my/file.png';
        $expectedSpiBinaryFile->size = 123;
        $expectedSpiBinaryFile->mtime = new DateTime('@1307155200');

        $this->filesystem
            ->expects($this->once())
            ->method('getMetadata')
            ->with($spiCreateStruct->id)
            ->will(
                $this->returnValue(
                    array(
                        'timestamp' => 1307155200,
                        'size' => 123,
                    )
                )
            );

        $spiBinaryFile = $this->handler->create($spiCreateStruct);

        $this->assertInstanceOf('eZ\Publish\SPI\IO\BinaryFile', $spiBinaryFile);
        $this->assertEquals($expectedSpiBinaryFile, $spiBinaryFile);
    }

    public function testDelete()
    {
        $this->filesystem->expects($this->never())->method('delete');
        $this->handler->delete('prefix/my/file.png');
    }

    public function testLoad()
    {
        $expectedSpiBinaryFile = new SPIBinaryFile();
        $expectedSpiBinaryFile->id = 'prefix/my/file.png';
        $expectedSpiBinaryFile->size = 123;
        $expectedSpiBinaryFile->mtime = new DateTime('@1307155200');

        $this->filesystem
            ->expects($this->once())
            ->method('getMetadata')
            ->with('prefix/my/file.png')
            ->will(
                $this->returnValue(
                    array(
                        'timestamp' => 1307155200,
                        'size' => 123,
                    )
                )
            );

        $spiBinaryFile = $this->handler->load('prefix/my/file.png');

        $this->assertInstanceOf('eZ\Publish\SPI\IO\BinaryFile', $spiBinaryFile);
        $this->assertEquals($expectedSpiBinaryFile, $spiBinaryFile);
    }

    /**
     * The timestamp index can be unset with some handlers, like AWS/S3.
     */
    public function testLoadNoTimestamp()
    {
        $this->filesystem
            ->expects($this->once())
            ->method('getMetadata')
            ->with('prefix/my/file.png')
            ->will(
                $this->returnValue(
                    array(
                        'size' => 123,
                    )
                )
            );

        $spiBinaryFile = $this->handler->load('prefix/my/file.png');
        $this->assertNull($spiBinaryFile->mtime);
    }

    /**
     * @expectedException \eZ\Publish\Core\IO\Exception\BinaryFileNotFoundException
     */
    public function testLoadNotFound()
    {
        $this->filesystem
            ->expects($this->once())
            ->method('getMetadata')
            ->with('prefix/my/file.png')
            ->will($this->throwException(new FileNotFoundException('prefix/my/file.png')));

        $this->handler->load('prefix/my/file.png');
    }

    public function testExists()
    {
        $this->filesystem
            ->expects($this->once())
            ->method('has')
            ->with('prefix/my/file.png')
            ->will($this->returnValue(true));

        self::assertTrue($this->handler->exists('prefix/my/file.png'));
    }

    public function testExistsNot()
    {
        $this->filesystem
            ->expects($this->once())
            ->method('has')
            ->with('prefix/my/file.png')
            ->will($this->returnValue(false));

        self::assertFalse($this->handler->exists('prefix/my/file.png'));
    }

    public function testGetMimeType()
    {
        $this->filesystem
            ->expects($this->once())
            ->method('getMimeType')
            ->with('file.txt')
            ->will($this->returnValue('text/plain'));

        self::assertEquals('text/plain', $this->handler->getMimeType('file.txt'));
    }

    public function testDeleteDirectory()
    {
        $this->filesystem->expects($this->never())->method('deleteDir');
        $this->handler->deleteDirectory('some/path');
    }

    public function testCount()
    {
        $this->filesystem
            ->expects($this->once())
            ->method('listContents')
            ->with('', true)
            ->will($this->returnValue(
                [
                    ['path' => 'file1', 'size' => 42],
                    ['path' => 'dir1'],
                    ['path' => 'file2', 'size' => 892753],
                    ['path' => 'dir2'],
                    ['path' => 'file3', 'size' => 0],
                ]
            ));

        self::assertEquals(3, $this->handler->count());
    }

    public function providerLoadList()
    {
        return [
            [
                null,
                null,
                [
                    ['path' => 'file1', 'size' => 42, 'timestamp' => 0],
                    ['path' => 'file2', 'size' => 892753, 'timestamp' => 42],
                    ['path' => 'file3', 'size' => 0, 'timestamp' => 982374987],
                ],
            ],
            [
                0,
                0,
                [],
            ],
            [
                1,
                null,
                [
                    ['path' => 'file1', 'size' => 42, 'timestamp' => 0],
                ],
            ],
            [
                1,
                2,
                [
                    ['path' => 'file3', 'size' => 0, 'timestamp' => 982374987],
                ],
            ],
            [
                1,
                100,
                [],
            ],
        ];
    }

    /**
     * @dataProvider providerLoadList
     */
    public function testLoadList($limit, $offset, $resultList)
    {
        $expectedSpiBinaryFiles = [];
        foreach ($resultList as $result) {
            $expectedSpiBinaryFile = new SPIBinaryFile();
            $expectedSpiBinaryFile->id = $result['path'];
            $expectedSpiBinaryFile->size = $result['size'];
            $expectedSpiBinaryFile->mtime = new DateTime('@' . $result['timestamp']);

            $expectedSpiBinaryFiles[] = $expectedSpiBinaryFile;
        }

        $this->filesystem
            ->expects($this->once())
            ->method('listContents')
            ->with('', true)
            ->will($this->returnValue(
                [
                    ['path' => 'file1', 'size' => 42, 'timestamp' => 0],
                    ['path' => 'dir1'],
                    ['path' => 'file2', 'size' => 892753, 'timestamp' => 42],
                    ['path' => 'dir2'],
                    ['path' => 'file3', 'size' => 0, 'timestamp' => 982374987],
                ]
            ));

        $loadedList = $this->handler->loadList($limit, $offset);
        $this->assertEquals(count($loadedList), count($resultList));

        foreach ($loadedList as $key => $spiBinaryFile) {
            $this->assertInstanceOf('eZ\Publish\SPI\IO\BinaryFile', $spiBinaryFile);
            $this->assertEquals($expectedSpiBinaryFiles[$key], $spiBinaryFile);
        }
    }
}