GitElephant\TestCase

Complexity

Total Complexity

30

Size/Duplication

Total Lines	288
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes	2
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getRepository()	0	11	3
A	getCaller()	0	8	2
A	initRepository()	0	20	4
A	tearDown()	0	12	2
A	addFile()	0	15	4
A	removeFile()	0	5	1
A	updateFile()	0	5	1
A	renameFile()	0	12	2
A	addFolder()	0	5	1
A	addSubmodule()	0	4	1
A	getMock()	0	7	1
A	getMockCaller()	0	14	1
A	getMockContainer()	0	4	1
A	addCommandToMockContainer()	0	8	1
A	addOutputToMockRepo()	0	7	1
A	getMockCommand()	0	10	1
A	getMockRepository()	0	11	1
A	getMockBinary()	0	4	1
B	doCommitTest()	0	27	1

<?php

/**
 * This file is part of the GitElephant package.
 *
 * (c) Matteo Giachino <matteog@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Just for fun...
 */

namespace GitElephant;

use \GitElephant\Command\MvCommand;
use \GitElephant\Repository;
use \GitElephant\GitBinary;
use \GitElephant\Command\Caller\Caller;
use \GitElephant\Objects\Commit;
use \Symfony\Component\Finder\Finder;
use \Symfony\Component\Filesystem\Filesystem;
use \Mockery as m;

/**
 * Class TestCase
 *
 * @package GitElephant
 */
class TestCase extends \PHPUnit\Framework\TestCase
{
    /**
     * @var \GitElephant\Command\Caller\CallerInterface
     */
    protected $caller;

    /**
     * @var Repository
     */
    protected $repository;

    /**
     * @var string
     */
    protected $path;

    /**
     * @var Finder
     */
    protected $finder;

    /**
     * @param null $name
     *
     * @return \GitElephant\Repository
     */
    protected function getRepository($name = null)
    {
        if ($this->repository == null) {
            $this->initRepository($name);
        }
        if (is_null($name)) {
            return $this->repository;
        } else {
            return $this->repository[$name];
        }
    }

    /**
     * @return \GitElephant\Command\Caller\Caller
     */
    protected function getCaller()
    {
        if ($this->caller == null) {
            $this->initRepository();
        }

        return $this->caller;
    }

    /**
     * @param null|string $name  the folder name
     * @param int         $index the repository index (for getting them back)
     *
     * @return void
     */
    protected function initRepository($name = null, $index = null)
    {
        $tempDir = realpath(sys_get_temp_dir());
        $tempName = null === $name ? tempnam($tempDir, 'gitelephant') : $tempDir.DIRECTORY_SEPARATOR.$name;
        $this->path = $tempName;
        @unlink($this->path);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        $fs = new Filesystem();
        $fs->mkdir($this->path);
        $this->caller = new Caller(new GitBinary(), $this->path);
        if (is_null($index)) {
            $this->repository = Repository::open($this->path);
            $this->assertInstanceOf('GitElephant\Repository', $this->repository);
        } else {
            if (!is_array($this->repository)) {
                $this->repository = array();

It seems like array() of type array is incompatible with the declared type object<GitElephant\Repository> of property $repository.

            }
            $this->repository[$index] = Repository::open($this->path);
            $this->assertInstanceOf('GitElephant\Repository', $this->repository[$index]);
        }
    }

    protected function tearDown()
    {
        $fs = new Filesystem();
        if (is_array($this->repository)) {
            array_map(function (Repository $repo) use ($fs) {
                $fs->remove($repo->getPath());
            }, $this->repository);
        } else {
            $fs->remove($this->path);
        }
        m::close();
    }

    /**
     * @param string      $name       file name
     * @param string|null $folder     folder name
     * @param null        $content    content
     * @param Repository  $repository repository to add file to
     *
     * @return void
     */
    protected function addFile($name, $folder = null, $content = null, $repository = null)
    {
        if (is_null($repository)) {
            $path = $this->path;
        } else {
            $path = $repository->getPath();
        }
        $filename = $folder == null ?

It seems like you are loosely comparing $folder of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $path.DIRECTORY_SEPARATOR.$name :
            $path.DIRECTORY_SEPARATOR.$folder.DIRECTORY_SEPARATOR.$name;
        $handle = fopen($filename, 'w');
        $fileContent = $content == null ? 'test content' : $content;
        $this->assertTrue(false !== fwrite($handle, $fileContent), sprintf('unable to write the file %s', $name));
        fclose($handle);
    }

    /**
     * remove file from repo
     *
     * @param string $name
     */
    protected function removeFile($name)
    {
        $filename = $this->path.DIRECTORY_SEPARATOR.$name;
        $this->assertTrue(unlink($filename));
    }

    /**
     * update a file in the repository
     *
     * @param string $name    file name
     * @param string $content content
     */
    protected function updateFile($name, $content)
    {
        $filename = $this->path.DIRECTORY_SEPARATOR.$name;
        $this->assertTrue(false !== file_put_contents($filename, $content));
    }

    /**
     * rename a file in the repository
     *
     * @param string $originName file name
     * @param string $targetName new file name
     * @param bool   $gitMv      use git mv, otherwise uses php rename function (with the Filesystem component)
     */
    protected function renameFile($originName, $targetName, $gitMv = true)
    {
        if ($gitMv) {
            $this->getRepository()->getCaller()->execute(MvCommand::getInstance()->rename($originName, $targetName));

            return;
        }
        $origin = $this->path.DIRECTORY_SEPARATOR.$originName;
        $target = $this->path.DIRECTORY_SEPARATOR.$targetName;
        $fs = new Filesystem();
        $fs->rename($origin, $target);
    }

    /**
     * @param string $name name
     *
     * @return void
     */
    protected function addFolder($name)
    {
        $fs = new Filesystem();
        $fs->mkdir($this->path.DIRECTORY_SEPARATOR.$name);
    }

    protected function addSubmodule($url, $path)
    {
        $this->getRepository()->addSubmodule($url, $path);
    }

    /**
     * @param $classname
     *
     * @return \PHPUnit\Framework\MockObject\MockObject
     */
    protected function getMock($classname)
    {
        return $this
            ->getMockBuilder($classname)
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * mock the caller
     *
     * @param string $command command
     * @param string $output  output
     *
     * @return \PHPUnit\Framework\MockObject\MockObject
     */
    protected function getMockCaller($command, $output)

The parameter $command is not used and could be removed.

    {
        $mock = $this->getMock('GitElephant\Command\Caller\CallerInterface');
        $mock
            ->expects($this->any())
            ->method('execute')
            ->will($this->returnValue($mock));
        $mock
            ->expects($this->any())
            ->method('getOutputLines')
            ->will($this->returnValue($output));

        return $mock;
    }

    protected function getMockContainer()
    {
        return $this->getMock('GitElephant\Command\CommandContainer');
    }

    protected function addCommandToMockContainer(\PHPUnit\Framework\MockObject\MockObject $container, $commandName)
    {
        $container
            ->expects($this->any())
            ->method('get')
            ->with($this->equalTo($commandName))
            ->will($this->returnValue($this->getMockCommand()));
    }

    protected function addOutputToMockRepo(\PHPUnit\Framework\MockObject\MockObject $repo, $output)
    {
        $repo
            ->expects($this->any())
            ->method('getCaller')
            ->will($this->returnValue($this->getMockCaller('', $output)));
    }

    protected function getMockCommand()
    {
        $command = $this->getMock('Command', array('showCommit'));

The call to TestCase::getMock() has too many arguments starting with array('showCommit').

        $command
            ->expects($this->any())
            ->method('showCommit')
            ->will($this->returnValue(''));

        return $command;
    }

    protected function getMockRepository()
    {
        return $this->getMock(
            'GitElephant\Repository',
            array(),

The call to TestCase::getMock() has too many arguments starting with array().

            array(
                $this->repository->getPath(),
                $this->getMockBinary()
            )
        );
    }

    protected function getMockBinary()
    {
        return $this->getMock('GitElephant\GitBinary');
    }

    protected function doCommitTest(
        Commit $commit,
        $sha,
        $tree,
        $author,
        $committer,
        $emailAuthor,
        $emailCommitter,
        $datetimeAuthor,
        $datetimeCommitter,
        $message
    ) {
        $this->assertInstanceOf('GitElephant\Objects\Commit', $commit);
        $this->assertEquals($sha, $commit->getSha());
        $this->assertEquals($tree, $commit->getTree());
        $this->assertInstanceOf('GitElephant\Objects\Author', $commit->getAuthor());
        $this->assertEquals($author, $commit->getAuthor()->getName());
        $this->assertEquals($emailAuthor, $commit->getAuthor()->getEmail());
        $this->assertInstanceOf('GitElephant\Objects\Author', $commit->getCommitter());
        $this->assertEquals($committer, $commit->getCommitter()->getName());
        $this->assertEquals($emailCommitter, $commit->getCommitter()->getEmail());
        $this->assertInstanceOf('\Datetime', $commit->getDatetimeAuthor());
        $this->assertEquals($datetimeAuthor, $commit->getDatetimeAuthor()->format('U'));
        $this->assertInstanceOf('\Datetime', $commit->getDatetimeCommitter());
        $this->assertEquals($datetimeCommitter, $commit->getDatetimeCommitter()->format('U'));
        $this->assertEquals($message, $commit->getMessage()->getShortMessage());
    }
}