Graze\DataFile\Test\Integration\Modify\Compress\ZipTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	161
Duplicated Lines	42.24 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	testInstanceOfCompressorInterface()	0	5	1
A	testFileGetsCompressedAsZip()	0	18	1
A	setUp()	0	6	1
A	testFileGetsDecompressedFromZip()	20	20	1
A	testCallingZipWithAFileThatDoesNotExistsThrowsAnException()	8	8	1
A	testCallingUnzipWithAFileThatDoesNotExistsThrowsAnException()	8	8	1
A	testWhenTheProcessFailsAnExceptionIsthrownOnZip()	0	21	1
A	testWhenTheProcessFailsAnExceptionIsthrownOnUnzip()	0	21	1
A	testPassingTheKeepOldFileOptionWillKeepTheFile()	16	16	1
A	testPassingFalseToKeepOldFileOptionWillKeepTheFile()	16	16	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\Integration\Modify\Compress;

use Graze\DataFile\Helper\Builder\Builder;
use Graze\DataFile\Helper\Builder\BuilderInterface;
use Graze\DataFile\Modify\Compress\CompressionFactory;
use Graze\DataFile\Modify\Compress\CompressorInterface;
use Graze\DataFile\Modify\Compress\DeCompressorInterface;
use Graze\DataFile\Modify\Compress\Zip;
use Graze\DataFile\Node\FileNodeInterface;
use Graze\DataFile\Node\LocalFile;
use Graze\DataFile\Test\AbstractFileTestCase;
use InvalidArgumentException;
use Mockery as m;
use Mockery\MockInterface;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;

class ZipTest extends AbstractFileTestCase
{
    /**
     * @var Zip
     */
    protected $zip;

    /**
     * @var BuilderInterface|MockInterface
     */
    private $builder;

    public function setUp()
    {
        $this->builder = m::mock(Builder::class)->makePartial();
        $this->zip = new Zip();
        $this->zip->setBuilder($this->builder);

$this->builder is of type object<Mockery\Mock>, but the function expects a object<Graze\DataFile\Helper\Builder\BuilderInterface>.

    }

    public function testInstanceOfCompressorInterface()
    {
        static::assertInstanceOf(CompressorInterface::class, $this->zip);
        static::assertInstanceOf(DeCompressorInterface::class, $this->zip);
    }

    public function testFileGetsCompressedAsZip()
    {
        $file = new LocalFile(static::$dir . 'uncompressed_zip.test');

        $file->put('random stuff and things!');

        $compressedFile = $this->zip->compress($file);

        static::assertNotNull($compressedFile);
        static::assertInstanceOf(FileNodeInterface::class, $compressedFile);
        static::assertEquals(static::$dir . 'uncompressed_zip.zip', $compressedFile->getPath());
        static::assertTrue($compressedFile->exists());
        static::assertEquals(Zip::NAME, $compressedFile->getCompression());

        $cmd = "file {$compressedFile->getPath()} | grep " . escapeshellarg('\bzip\b') . " | wc -l";
        $result = exec($cmd);
        static::assertEquals(1, $result, "File is not compressed as zip");
    }

    public function testFileGetsDecompressedFromZip()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'get_decompressed_uncompressed_zip.test');
        $file->put('random stuff and things!');

        $compressedFile = $this->zip->compress($file);

        static::assertTrue($compressedFile->exists());
        $uncompressedFile = $this->zip->decompress($compressedFile);

        static::assertNotNull($uncompressedFile);
        static::assertInstanceOf(FileNodeInterface::class, $uncompressedFile);
        static::assertEquals(static::$dir . 'get_decompressed_uncompressed_zip', $uncompressedFile->getPath());
        static::assertTrue($uncompressedFile->exists());
        static::assertEquals(CompressionFactory::TYPE_NONE, $uncompressedFile->getCompression());

        $cmd = "file {$uncompressedFile->getPath()} | grep " . escapeshellarg('\bzip\b') . " | wc -l";
        $result = exec($cmd);
        static::assertEquals(0, $result, "File should not be compressed");
    }

    public function testCallingZipWithAFileThatDoesNotExistsThrowsAnException()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'invalid_zip.test');

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

        $this->zip->compress($file);
    }

    public function testCallingUnzipWithAFileThatDoesNotExistsThrowsAnException()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'invalid_zip.zip');

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

        $this->zip->decompress($file);
    }

    public function testWhenTheProcessFailsAnExceptionIsthrownOnZip()
    {
        $process = m::mock(Process::class)->makePartial();
        $this->builder->shouldReceive('build')

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\DataFile\Helper\Builder\BuilderInterface.

                      ->andReturn($process);
        $process->shouldReceive('run')->once();
        $process->shouldReceive('isSuccessful')->andReturn(false);
        $process->shouldReceive('getCommandLine')->andReturn('');
        $process->shouldReceive('getExitCode')->andReturn(1);
        $process->shouldReceive('getExitCodeText')->andReturn('bla');
        $process->shouldReceive('getWorkingDirectory')->andReturn('/something/');
        $process->shouldReceive('isOutputDisabled')->andReturn('true');

        $file = new LocalFile(static::$dir . 'failed_zip_process.test');

        $file->put('random stuff and things 2!');

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

        $this->zip->compress($file);
    }

    public function testWhenTheProcessFailsAnExceptionIsthrownOnUnzip()
    {
        $process = m::mock(Process::class)->makePartial();
        $this->builder->shouldReceive('build')

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\DataFile\Helper\Builder\BuilderInterface.

                      ->andReturn($process);
        $process->shouldReceive('run')->once();
        $process->shouldReceive('isSuccessful')->andReturn(false);
        $process->shouldReceive('getCommandLine')->andReturn('');
        $process->shouldReceive('getExitCode')->andReturn(1);
        $process->shouldReceive('getExitCodeText')->andReturn('bla');
        $process->shouldReceive('getWorkingDirectory')->andReturn('/something/');
        $process->shouldReceive('isOutputDisabled')->andReturn('true');

        $file = new LocalFile(static::$dir . 'failed_unzip_process.test');

        $file->put('random stuff and things 2!');

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

        $this->zip->decompress($file);
    }

    public function testPassingTheKeepOldFileOptionWillKeepTheFile()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'keep_file_zip.test');

        $file->put('random stuff and things!');

        $compressedFile = $this->zip->compress($file, ['keepOldFile' => true]);

        static::assertTrue($file->exists());
        static::assertTrue($compressedFile->exists());

        $uncompresssedFile = $this->zip->decompress($compressedFile, ['keepOldFile' => true]);

        static::assertTrue($compressedFile->exists());
        static::assertTrue($uncompresssedFile->exists());
    }

    public function testPassingFalseToKeepOldFileOptionWillKeepTheFile()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'delete_file_zip.test');

        $file->put('random stuff and things!');

        $compressedFile = $this->zip->compress($file, ['keepOldFile' => false]);

        static::assertFalse($file->exists());
        static::assertTrue($compressedFile->exists());

        $uncompresssedFile = $this->zip->decompress($compressedFile, ['keepOldFile' => false]);

        static::assertFalse($compressedFile->exists());
        static::assertTrue($uncompresssedFile->exists());
    }
}