ReFormatTest::testCanReFormatWithANonLocalInputFileAndOutputFormat() - Code Metrics - graze/data-file - Measure and Improve Code Quality continuously with Scrutinizer

testCanReFormatWithANonLocalInputFileAndOutputFormat() B
last analyzed 2016-09-21 14:43 UTC

↳ Parent: ReFormatTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	38
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	38
c	0
b	0
f	0
rs	8.8571
cc	1
eloc	27
nc	1
nop	0

<?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\Modify;

use ArrayIterator;
use Graze\DataFile\Format\FormatAwareInterface;
use Graze\DataFile\Format\FormatInterface;
use Graze\DataFile\Format\Formatter\FormatterFactoryInterface;
use Graze\DataFile\Format\Parser\ParserFactoryInterface;
use Graze\DataFile\Format\Parser\ParserInterface;
use Graze\DataFile\Helper\Builder\BuilderInterface;
use Graze\DataFile\IO\FileReader;
use Graze\DataFile\IO\FileWriter;
use Graze\DataFile\Modify\FileModifierInterface;
use Graze\DataFile\Modify\ReFormat;
use Graze\DataFile\Node\FileNodeInterface;
use Graze\DataFile\Node\LocalFile;
use Graze\DataFile\Node\LocalFileNodeInterface;
use Graze\DataFile\Test\TestCase;
use InvalidArgumentException;
use Mockery as m;
use Mockery\MockInterface;

class ReFormatTest extends TestCase
{
    /** @var ParserFactoryInterface|MockInterface */
    private $parserFactory;
    /** @var FormatterFactoryInterface|MockInterface */
    private $formatterFactory;
    /** @var ReFormat */
    private $reFormatter;
    /** @var BuilderInterface|MockInterface */
    private $builder;

    public function setUp()
    {
        parent::setUp();

        $this->builder = m::mock(BuilderInterface::class);
        $this->parserFactory = m::mock(ParserFactoryInterface::class);
        $this->formatterFactory = m::mock(FormatterFactoryInterface::class);
        $this->reFormatter = new ReFormat($this->formatterFactory, $this->parserFactory, $this->builder);
    }

    public function testInstanceOf()
    {
        static::assertInstanceOf(FileModifierInterface::class, $this->reFormatter);
    }

    public function testCanModifyAcceptsFileNodeInterfaceWithAFormat()

    {
        $file = m::mock(FileNodeInterface::class, FormatAwareInterface::class);
        $file->shouldReceive('exists')
             ->andReturn(true);

        $format = m::mock(FormatInterface::class);
        $parser = m::mock(ParserInterface::class);
        $this->parserFactory->shouldReceive('getParser')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                            ->with($format)
                            ->andReturn($parser);

        $file->shouldReceive('getFormat')
             ->andReturn($format);

        static::assertTrue($this->reFormatter->canModify($file));
    }

    public function testCanModifyDoesNotAcceptAFormatThatCanNotBeParsed()

    {
        $file = m::mock(FileNodeInterface::class, FormatAwareInterface::class);
        $file->shouldReceive('exists')
             ->andReturn(true);

        $format = m::mock(FormatInterface::class);
        $this->parserFactory->shouldReceive('getParser')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                            ->with($format)
                            ->andReturn(null);

        $file->shouldReceive('getFormat')
             ->andReturn($format);

        static::assertFalse($this->reFormatter->canModify($file));
    }

    public function testCanReFormatWithANonLocalInputFileAndOutputFormat()
    {
        $file = m::mock(FileNodeInterface::class, FormatAwareInterface::class);
        $target = m::mock(LocalFile::class);

        $file->shouldReceive('exists')
             ->andReturn(true);

        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(LocalFile::class, m::type('string'))
                      ->andReturn($target);

        $format = m::mock(FormatInterface::class);

        $target->shouldReceive('setFormat')
               ->with($format)
               ->andReturn($target);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
                      ->with(FileReader::class, $file, null, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $target, $format, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        static::assertSame($target, $this->reFormatter->reFormat($file, $format));
    }

    public function testCanReFormatALocalInputFile()

    {
        $file = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);
        $target = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);

        $file->shouldReceive('getPath')
             ->andReturn('/tmp/file.txt');
        $file->shouldReceive('exists')
             ->andReturn(true);

        $file->shouldReceive('getClone')
             ->andReturn($target);
        $target->shouldReceive('setPath')
               ->with('/tmp/file-format.txt')
               ->andReturn($target);

        $format = m::mock(FormatInterface::class);

        $target->shouldReceive('setFormat')
               ->with($format)
               ->andReturn($target);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(FileReader::class, $file, null, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $target, $format, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        static::assertSame($target, $this->reFormatter->reFormat($file, $format));
    }

    public function testCanReformatWithIntputAndOutputFiles()

    {
        $file = m::mock(FileNodeInterface::class, FormatAwareInterface::class);
        $target = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);

        $file->shouldReceive('exists')
             ->andReturn(true);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(FileReader::class, $file, null, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $target, null, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        static::assertSame($target, $this->reFormatter->reFormat($file, null, $target));
    }

    public function testInputAndOutputFormatsArePassedToReaderAndWriter()
    {
        $input = m::mock(FileNodeInterface::class);
        $output = m::mock(FileNodeInterface::class);
        $inputFormat = m::mock(FormatInterface::class);
        $outputFormat = m::mock(FormatInterface::class);

        $input->shouldReceive('exists')
              ->andReturn(true);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(FileReader::class, $input, $inputFormat, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $output, $outputFormat, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        static::assertSame($output, $this->reFormatter->reFormat($input, $outputFormat, $output, $inputFormat));
    }

    public function testModifyWithOutOutputOrFormatSpecified()
    {
        $file = m::mock(FileNodeInterface::class);

        static::expectException(InvalidArgumentException::class);

        $this->reFormatter->modify($file);
    }

    public function testModifyWithOutputFileSet()

    {
        $file = m::mock(FileNodeInterface::class, FormatAwareInterface::class);
        $target = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);

        $file->shouldReceive('exists')
             ->andReturn(true);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(FileReader::class, $file, null, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $target, null, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        static::assertSame($target, $this->reFormatter->modify($file, ['output' => $target]));
    }

    public function testModifyWithFormatOption()

    {
        $file = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);
        $target = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);

        $file->shouldReceive('getPath')
             ->andReturn('/tmp/file.txt');
        $file->shouldReceive('exists')
             ->andReturn(true);

        $file->shouldReceive('getClone')
             ->andReturn($target);
        $target->shouldReceive('setPath')
               ->with('/tmp/file-format.txt')
               ->andReturn($target);

        $format = m::mock(FormatInterface::class);

        $target->shouldReceive('setFormat')
               ->with($format)
               ->andReturn($target);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(FileReader::class, $file, null, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $target, $format, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        static::assertSame($target, $this->reFormatter->modify($file, ['format' => $format]));
    }

    public function testReFormatWithDeleteOldFile()
    {
        $file = m::mock(FileNodeInterface::class, FormatAwareInterface::class);
        $target = m::mock(LocalFileNodeInterface::class, FormatAwareInterface::class);

        $reader = m::mock(FileReader::class);
        $this->builder->shouldReceive('build')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                      ->with(FileReader::class, $file, null, $this->parserFactory)
                      ->andReturn($reader);
        $writer = m::mock(FileWriter::class);
        $this->builder->shouldReceive('build')
                      ->with(FileWriter::Class, $target, null, $this->formatterFactory)
                      ->andReturn($writer);

        $iterator = new ArrayIterator(['first', 'second']);

        $reader->shouldReceive('fetch')
               ->andReturn($iterator);

        $writer->shouldReceive('insertAll')
               ->with($iterator)
               ->once();

        $file->shouldReceive('exists')
             ->andReturn(true);
        $file->shouldReceive('delete')
             ->once();

        static::assertSame($target, $this->reFormatter->reFormat($file, null, $target, null, ['keepOldFile' => false]));
    }
}


testCanReFormatWithANonLocalInputFileAndOutputFormat() B
last analyzed 2016-09-21 14:43 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* This file is part of graze/data-file
4			*
5			* Copyright (c) 2016 Nature Delivered Ltd. <https://www.graze.com>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*
10			* @license https://github.com/graze/data-file/blob/master/LICENSE.md
11			* @link https://github.com/graze/data-file
12			*/
13
14			namespace Graze\DataFile\Test\Unit\Modify;
15
16			use ArrayIterator;
17			use Graze\DataFile\Format\FormatAwareInterface;
18			use Graze\DataFile\Format\FormatInterface;
19			use Graze\DataFile\Format\Formatter\FormatterFactoryInterface;
20			use Graze\DataFile\Format\Parser\ParserFactoryInterface;
21			use Graze\DataFile\Format\Parser\ParserInterface;
22			use Graze\DataFile\Helper\Builder\BuilderInterface;
23			use Graze\DataFile\IO\FileReader;
24			use Graze\DataFile\IO\FileWriter;
25			use Graze\DataFile\Modify\FileModifierInterface;
26			use Graze\DataFile\Modify\ReFormat;
27			use Graze\DataFile\Node\FileNodeInterface;
28			use Graze\DataFile\Node\LocalFile;
29			use Graze\DataFile\Node\LocalFileNodeInterface;
30			use Graze\DataFile\Test\TestCase;
31			use InvalidArgumentException;
32			use Mockery as m;
33			use Mockery\MockInterface;
34
35			class ReFormatTest extends TestCase
36			{
37			/** @var ParserFactoryInterface\|MockInterface */
38			private $parserFactory;
39			/** @var FormatterFactoryInterface\|MockInterface */
40			private $formatterFactory;

graze / data-file

testCanReFormatWithANonLocalInputFileAndOutputFormat() B last analyzed 2016-09-21 14:43 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

testCanReFormatWithANonLocalInputFileAndOutputFormat() B
last analyzed 2016-09-21 14:43 UTC