Graze\DataFile\Test\Integration\Modify\ReplaceTextTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	206
Duplicated Lines	37.86 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	testInstanceOf()	0	4	1
A	testCanModifyAcceptsLocalFile()	0	15	1
A	testReplaceTextReplacesASingleEntry()	0	10	1
A	testReplaceTextReplacesMultipleEntries()	0	10	1
A	testReplaceTextReplacesMultipleEntriesWorksInCompound()	0	10	1
A	testCallingReplaceTextWithArraysThatHaveMismatchedCountsThrowsAnException()	9	9	1
A	testAddingAPostfixToTheEndOfTheFile()	10	10	1
A	testCallingWithBlankPostfixWillReplaceInLine()	10	10	1
A	testSettingKeepOldFileToFalseWillDeleteTheOldFile()	10	10	1
A	testCallingModifyReplacesText()	10	10	1
A	testCallingModifyWillPassThroughOptions()	0	20	1
A	testCallingModifyWithNoFromTextThrowsInvalidArgumentsException()	9	9	1
A	testCallingModifyWithNoToTextThrowsInvalidArgumentsException()	9	9	1
A	testCallingReplaceTextOnAFileWithoutAnExtensionWorks()	11	11	1
A	testCallingModifyWithANonLocalFileWillThrowAnException()	0	10	1
A	testWhenTheProcessFailsAnExceptionIsThrownOnFindEncoding()	0	14	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;

use Graze\DataFile\Helper\Process\ProcessFactory;
use Graze\DataFile\Modify\FileModifierInterface;
use Graze\DataFile\Modify\ReplaceText;
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 ReplaceTextTest extends AbstractFileTestCase
{
    /**
     * @var ReplaceText
     */
    protected $replacer;

    /**
     * @var ProcessFactory|MockInterface
     */
    protected $processFactory;

    public function setUp()
    {
        $this->processFactory = m::mock(ProcessFactory::class)->makePartial();
        $this->replacer = new ReplaceText();
        $this->replacer->setProcessFactory($this->processFactory);
    }

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

    public function testCanModifyAcceptsLocalFile()
    {
        $localFile = m::mock(LocalFile::class);
        $localFile->shouldReceive('exists')->andReturn(true, false);

        static::assertTrue($this->replacer->canModify($localFile));
        static::assertFalse(
            $this->replacer->canModify($localFile),
            "CanExtend should return false if the file does not exist"
        );

        $randomThing = m::mock(FileNodeInterface::class);

        static::assertFalse($this->replacer->canModify($randomThing));
    }

    public function testReplaceTextReplacesASingleEntry()
    {
        $file = new LocalFile(static::$dir . 'simple_replace.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, 'text', 'pants');

        static::assertNotNull($newFile);
        static::assertEquals(['some pants that pants should be replaced'], $newFile->getContents());
    }

    public function testReplaceTextReplacesMultipleEntries()
    {
        $file = new LocalFile(static::$dir . 'multiple_replace.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, ['text', 'some'], ['pants', 'many']);

        static::assertNotNull($newFile);
        static::assertEquals(['many pants that pants should be replaced'], $newFile->getContents());
    }

    public function testReplaceTextReplacesMultipleEntriesWorksInCompound()
    {
        $file = new LocalFile(static::$dir . 'multiple_compound_replace.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, ['text', 'pants that'], ['pants', 'fish like']);

        static::assertNotNull($newFile);
        static::assertEquals(['some fish like pants should be replaced'], $newFile->getContents());
    }

    public function testCallingReplaceTextWithArraysThatHaveMismatchedCountsThrowsAnException()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'multiple_replace_failure.test');
        $file->put('some text that text should be replaced');

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

        $this->replacer->replaceText($file, ['text', 'pants that'], ['pants']);
    }

    public function testAddingAPostfixToTheEndOfTheFile()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'postfix_test.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, 'text', 'pants', ['postfix' => 'pfixtest']);

        static::assertNotNull($newFile);
        static::assertEquals('postfix_test-pfixtest.test', $newFile->getFilename());
    }

    public function testCallingWithBlankPostfixWillReplaceInLine()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'inline_replace.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, 'text', 'pants', ['postfix' => '']);

        static::assertNotNull($newFile);
        static::assertEquals($file->getFilename(), $newFile->getFilename());
    }

    public function testSettingKeepOldFileToFalseWillDeleteTheOldFile()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'inline_replace.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, 'text', 'pants', ['keepOldFile' => false]);

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

    public function testCallingModifyReplacesText()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'simple_replace.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->modify($file, ['fromText' => 'text', 'toText' => 'pants']);

        static::assertNotNull($newFile);
        static::assertEquals(['some pants that pants should be replaced'], $newFile->getContents());
    }

    public function testCallingModifyWillPassThroughOptions()
    {
        $file = new LocalFile(static::$dir . 'option_pass_through.test');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->modify(
            $file,
            [
                'fromText'    => 'text',
                'toText'      => 'pants',
                'postfix'     => 'pass',
                'keepOldFile' => false,
            ]
        );

        static::assertTrue($newFile->exists());
        static::assertFalse($file->exists());
        static::assertNotNull($newFile);
        static::assertEquals('option_pass_through-pass.test', $newFile->getFilename());
    }

    public function testCallingModifyWithNoFromTextThrowsInvalidArgumentsException()

This method seems to be duplicated in your project.

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

        $file = new LocalFile(static::$dir . 'simple_replace.test');
        $file->put('some text that text should be replaced');

        $this->replacer->modify($file, ['toText' => 'pants']);
    }

    public function testCallingModifyWithNoToTextThrowsInvalidArgumentsException()

This method seems to be duplicated in your project.

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

        $file = new LocalFile(static::$dir . 'simple_replace.test');
        $file->put('some text that text should be replaced');

        $this->replacer->modify($file, ['fromText' => 'pants']);
    }

    public function testCallingModifyWithANonLocalFileWillThrowAnException()
    {
        $file = m::mock(FileNodeInterface::class);
        $file->shouldReceive('__toString')
             ->andReturn('some/file/here');

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

        $this->replacer->modify($file, ['fromText' => 'pants', 'toText' => 'more pants']);
    }

    public function testCallingReplaceTextOnAFileWithoutAnExtensionWorks()

This method seems to be duplicated in your project.

    {
        $file = new LocalFile(static::$dir . 'file_no_ext');
        $file->put('some text that text should be replaced');

        $newFile = $this->replacer->replaceText($file, 'text', 'pants');

        static::assertTrue($newFile->exists());
        static::assertNotNull($newFile);
        static::assertEquals(['some pants that pants should be replaced'], $newFile->getContents());
    }

    public function testWhenTheProcessFailsAnExceptionIsThrownOnFindEncoding()
    {
        $process = m::mock(Process::class)->makePartial();
        $process->shouldReceive('isSuccessful')->andReturn(false);
        $this->processFactory->shouldReceive('createProcess')
                             ->andReturn($process);

        $file = new LocalFile(static::$dir . 'failed_replace_text.test');
        $file->put('some text that text should be replaced');

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

        $this->replacer->replaceText($file, 'text', 'pants');
    }
}