GitElephant\TestCase

Complexity

Total Complexity

28

Size/Duplication

Total Lines	280
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	removeFile()	0	5	1
A	updateFile()	0	5	1
A	doCommitTest()	0	27	1
A	getRepository()	0	11	3
A	getCaller()	0	8	2
A	initRepository()	0	22	4
A	tearDown()	0	12	2
A	addFile()	0	11	4
A	renameFile()	0	14	2
A	addFolder()	0	5	1
A	addSubmodule()	0	4	1
A	getMock()	0	7	1
A	getMockCaller()	0	14	1
A	addCommandToMockContainer()	0	8	1
A	addOutputToMockRepo()	0	7	1
A	getMockCommand()	0	10	1
A	getMockRepository()	0	13	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 \Mockery as m;
use \GitElephant\Repository;
use \GitElephant\Objects\Author;
use \GitElephant\Objects\Commit;
use \GitElephant\Command\MvCommand;
use \Symfony\Component\Finder\Finder;
use \GitElephant\Command\Caller\Caller;
use \PHPUnit\Framework\MockObject\MockObject;
use \Symfony\Component\Filesystem\Filesystem;
use GitElephant\Command\Caller\CallerInterface;

/**
 * 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 string $name
     *
     * @return \GitElephant\Repository
     */
    protected function getRepository(string $name = null)
    {
        if ($this->repository == null) {
            $this->initRepository($name);
        }
        if (is_null($name)) {
            return $this->repository;
        } else {
            return $this->repository[$name];
        }
    }

    /**
     * @return CallerInterface the real/not mocked caller
     */
    protected function getCaller(): CallerInterface
    {
        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(string $name = null, int $index = null): void
    {
        $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(null, $this->path);
        if (is_null($index)) {
            $this->repository = Repository::open($this->path);
            $this->assertInstanceOf(Repository::class, $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(Repository::class, $this->repository[$index]);
        }
    }

    protected function tearDown(): void
    {
        $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(string $name, string $folder = null, string $content = null, Repository $repository = null): void
    {
        $path = is_null($repository) ? $this->path : $repository->getPath();
        $filename = $folder == null

It seems like you are loosely comparing $folder of type null|string 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(string $name): void
    {
        $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(string $name, string $content): void
    {
        $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(string $originName, string $targetName, bool $gitMv = true): void
    {
        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): void
    {
        $fs = new Filesystem();
        $fs->mkdir($this->path . DIRECTORY_SEPARATOR . $name);
    }

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

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

    /**
     * mock the caller
     *
     * @param string $command command
     * @param string $output  output
     *
     * @return MockObject
     */
    protected function getMockCaller($command, $output): MockObject
    {
        $mock = $this->createMock(CallerInterface::class);
        $mock
            ->expects($this->any())
            ->method('execute')
            ->willReturn($mock);
        $mock
            ->expects($this->any())
            ->method('getOutputLines')
            ->willReturn($output);

        return $mock;
    }

    protected function addCommandToMockContainer(MockObject $container, string $commandName): void
    {
        $container
            ->expects($this->any())
            ->method('get')
            ->with($this->equalTo($commandName))
            ->willReturn($this->getMockCommand());
    }

    protected function addOutputToMockRepo(MockObject $repo, array $output): void
    {
        $repo
            ->expects($this->any())
            ->method('getCaller')
            ->willReturn($this->getMockCaller('', $output));
    }

    protected function getMockCommand(): MockObject
    {
        $command = $this->getMock('Command', array('showCommit'));
        $command
            ->expects($this->any())
            ->method('showCommit')
            ->willReturn('');

        return $command;
    }

    protected function getMockRepository(): MockObject
    {
        $mockRepo = $this->getMock(
            Repository::class,
            array(),
            array(
                $this->repository->getPath(),
                null,
            )
        );
        
        return $mockRepo;
    }

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