allejo\stakx\Test\PHPUnit_Stakx_TestCase

Complexity

Total Complexity

36

Size/Duplication

Total Lines	423
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	18

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	13	1
A	tearDown()	0	7	2
A	assertStringContains()	0	4	1
A	assertFileContains()	0	8	2
A	createAssetFolder()	0	6	1
A	createPhysicalFile()	0	7	1
A	createVirtualFile()	0	10	1
A	createDocumentOfType()	0	6	1
A	createFrontMatterDocumentOfType()	0	11	2
A	createMultipleFrontMatterDocumentsOfType()	0	19	6
A	createFileObjectFromPath()	0	4	1
A	getMockAssetEngineManager()	0	4	1
A	getMockConfiguration()	0	12	1
A	getMockPageManager()	0	11	1
A	getMockMenuManager()	0	11	1
A	getMockCollectionManager()	0	11	1
A	getMockDataManager()	0	11	1
A	getMockTwigExtension()	0	6	1
A	getMockTemplateBridge()	0	8	1
A	getMockMarkupEngineManager()	0	14	1
A	getMockEventDistpatcher()	0	4	1
A	getMockLogger()	0	4	1
A	getReadableLogger()	0	8	1
A	getTestRoot()	0	4	1
A	buildFrontMatterTemplate()	0	6	2
A	bookCollectionProvider()	0	18	2

<?php

/**
 * @copyright 2018 Vladimir Jimenez
 * @license   https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Test;

use allejo\stakx\AssetEngine\AssetEngineInterface;
use allejo\stakx\AssetEngine\AssetEngineManager;
use allejo\stakx\Configuration;
use allejo\stakx\Document\FrontMatterDocument;
use allejo\stakx\Filesystem\File;
use allejo\stakx\Filesystem\Filesystem;
use allejo\stakx\Filesystem\FilesystemLoader as fs;
use allejo\stakx\Filesystem\Folder;
use allejo\stakx\Logger;
use allejo\stakx\Manager\CollectionManager;
use allejo\stakx\Manager\DataManager;
use allejo\stakx\Manager\MenuManager;
use allejo\stakx\Manager\PageManager;
use allejo\stakx\MarkupEngine\MarkdownEngine;
use allejo\stakx\MarkupEngine\MarkupEngineManager;
use allejo\stakx\MarkupEngine\PlainTextEngine;
use allejo\stakx\MarkupEngine\RstEngine;
use allejo\stakx\RuntimeStatus;
use allejo\stakx\Service;
use allejo\stakx\Templating\Twig\TwigExtension;
use allejo\stakx\Templating\Twig\TwigStakxBridge;
use allejo\stakx\Templating\Twig\TwigStakxBridgeFactory;
use org\bovigo\vfs\vfsStream;
use org\bovigo\vfs\vfsStreamDirectory;
use org\bovigo\vfs\vfsStreamFile;
use Psr\Log\LoggerInterface;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Yaml\Yaml;

abstract class PHPUnit_Stakx_TestCase extends \PHPUnit_Framework_TestCase

This class is not in CamelCase format.

{
    const FM_OBJ_TEMPLATE = "---\n%s\n---\n\n%s";

    /** @var string */
    protected $assetFolder;
    /** @var vfsStreamFile */
    protected $dummyFile;
    /** @var vfsStreamDirectory */
    protected $rootDir;

    public function setUp()
    {
        $this->dummyFile = vfsStream::newFile('stakx.html.twig');
        $this->rootDir = vfsStream::setup();

        Service::resetRuntimeFlags();

        Service::setWorkingDirectory(null);
        Service::setRuntimeFlag(RuntimeStatus::USING_HIGHLIGHTER);

        // Inspect the VFS as an array
        // vfsStream::inspect(new vfsStreamStructureVisitor())->getStructure();

63% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    public function tearDown()
    {
        if ($this->assetFolder !== null)
        {
            fs::remove($this->assetFolder);

The method remove() does not exist on allejo\stakx\Filesystem\FilesystemLoader. Did you maybe mean removeExtension()?

        }
    }

    ///
    // Assertion Functions
    ///

    /**
     * @param string $needle
     * @param string $haystack
     * @param string $message
     */
    protected function assertStringContains($needle, $haystack, $message = '')
    {
        $this->assertNotFalse(strpos($haystack, $needle), $message);
    }

    /**
     * @param string $fileContent
     * @param string $filePath
     * @param string $message
     */
    protected function assertFileContains($fileContent, $filePath, $message = '')
    {
        (substr($filePath, -1, 1) == '/') && $filePath .= 'index.html';

        $contents = file_get_contents($filePath);

        $this->assertStringContains($fileContent, $contents, $message);
    }

    ///
    // Filesystem Functions
    ///

    /**
     * Create a temporary folder where temporary file writes will be made to.
     *
     * @param string $folderName
     */
    protected function createAssetFolder($folderName)
    {
        $this->assetFolder = fs::getRelativePath(fs::appendPath(__DIR__, $folderName));

It seems like \allejo\stakx\Filesystem\FilesystemLoader::getRelativePath(\allejo\stakx\Filesystem\FilesystemLoader::appendPath(__DIR__, $folderName)) of type object<string> is incompatible with the declared type string of property $assetFolder.

        fs::mkdir($this->assetFolder);
    }

    /**
     * Write a file to the asset folder.
     *
     * This file will be written to the actual filesystem and not the virtual filesystem. This file will be deleted at
     * each tearDown().
     *
     * @param string $fileName
     * @param string $content
     *
     * @return string Path to the temporary file; relative to the project's root
     */
    protected function createPhysicalFile($fileName, $content)
    {
        $folder = new Folder($this->assetFolder);
        $folder->writeFile($fileName, $content);

        return fs::appendPath($this->assetFolder, $fileName);
    }

    /**
     * Write a file to the virtual filesystem.
     *
     * This file will be deleted at each tearDown().
     *
     * @param string $filename
     * @param string $content
     *
     * @return string the URL of the file on the virtual filesystem
     */
    protected function createVirtualFile($filename, $content)
    {
        $file = vfsStream::newFile($filename);
        $file
            ->setContent($content)
            ->at($this->rootDir)
        ;

        return $file->url();
    }

    /**
     * Create an object of a given type.
     *
     * This will create a virtual file and then create an object of the specified type for the created file.
     *
     * @param string $classType
     * @param string $filename
     * @param string $content
     *
     * @return object An instance of $classType
     */
    protected function createDocumentOfType($classType, $filename, $content)
    {
        $file = $this->createVirtualFile($filename, $content);

        return new $classType(new File($file));
    }

    /**
     * Create an object of a given type following the Front Matter format.
     *
     * @param string $classType
     * @param string $filename

Should the type for parameter $filename not be string|null?

     * @param array  $frontMatter
     * @param string $content
     *
     * @return object An instance of $classType
     */
    protected function createFrontMatterDocumentOfType($classType, $filename = null, $frontMatter = [], $content = 'Body Text')
    {
        $body = $this->buildFrontMatterTemplate($frontMatter, $content);

        if (!$filename)

The expression $filename of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

        {
            $filename = hash('sha256', uniqid(mt_rand(), true), false);

Consider using a different name than the parameter $filename. This often makes code more readable.

        }

        return $this->createDocumentOfType($classType, $filename, $body);
    }

    /**
     * Create multiple virtual files from a given array of information.
     *
     * ```php
     * $elements = [
     *     [
     *         'filename' => '<string>',
     *         'frontmatter' => [],
     *         'body' => '<string>',
     *     ],
     * ];
     * ```
     *
     * @param string $classType
     * @param array  $elements
     *
     * @return array
     */
    protected function createMultipleFrontMatterDocumentsOfType($classType, $elements)
    {
        $results = [];

        foreach ($elements as $element)
        {
            $filename = (isset($element['filename'])) ? $element['filename'] : null;
            $frontMatter = (!isset($element['frontmatter']) || empty($element['frontmatter'])) ? [] : $element['frontmatter'];
            $body = (isset($element['body'])) ? $element['body'] : 'Body Text';

            /** @var FrontMatterDocument $item */
            $item = $this->createFrontMatterDocumentOfType($classType, $filename, $frontMatter, $body);
            $item->evaluateFrontMatter();

            $results[] = $item;
        }

        return $results;
    }

    /**
     * Create a File object from a given path.
     *
     * @deprecated
     *
     * @param string $filePath
     *
     * @return File
     */
    protected function createFileObjectFromPath($filePath)
    {
        return new File($filePath);
    }

    ///
    // Mock Objects
    ///

    /**
     * @return AssetEngineManager|\PHPUnit_Framework_MockObject_MockBuilder
     */
    protected function getMockAssetEngineManager()
    {
        return new AssetEngineManager();
    }

    /**
     * @return Configuration|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockConfiguration()
    {
        $stub = $this->getMockBuilder(Configuration::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $stub->method('getConfiguration')->willReturn([]);
        $stub->method('getTwigAutoescape')->willReturn(false);

        return $stub;
    }

    /**
     * @return PageManager|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockPageManager()
    {
        $stub = $this->getMockBuilder(PageManager::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $stub->method('getJailedStaticPageViews')->willReturn([]);

        return $stub;
    }

    /**
     * @return MenuManager|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockMenuManager()
    {
        $stub = $this->getMockBuilder(MenuManager::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $stub->method('getSiteMenu')->willReturn([]);

        return $stub;
    }

    /**
     * @return CollectionManager|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockCollectionManager()
    {
        $stub = $this->getMockBuilder(CollectionManager::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $stub->method('getJailedCollections')->willReturn([]);

        return $stub;
    }

    /**
     * @return DataManager|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockDataManager()
    {
        $stub = $this->getMockBuilder(DataManager::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $stub->method('getJailedDataItems')->willReturn([]);

        return $stub;
    }

    /**
     * @return TwigExtension
     */
    protected function getMockTwigExtension()
    {
        // too lazy to actually mock all the methods... just create an actual instance of and dub it a "mock" to match
        // all the other mock methods. if this causes problems: sorry, future me!
        return new TwigExtension($this->getMockMarkupEngineManager());
    }

    /**
     * @return TwigStakxBridge
     */
    protected function getMockTemplateBridge()
    {
        return TwigStakxBridgeFactory::createTwigEnvironment(
            $this->getMockConfiguration(),

It seems like $this->getMockConfiguration() targeting allejo\stakx\Test\PHPUnit_Stakx_TestCase::getMockConfiguration() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, allejo\stakx\Templating\Twig\TwigStakxBridgeFactory::createTwigEnvironment() does only seem to accept object<allejo\stakx\Configuration>, maybe add an additional type check?

            $this->getMockTwigExtension(),
            $this->getMockLogger()

It seems like $this->getMockLogger() targeting allejo\stakx\Test\PHPUnit_Stakx_TestCase::getMockLogger() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, allejo\stakx\Templating\Twig\TwigStakxBridgeFactory::createTwigEnvironment() does only seem to accept object<Psr\Log\LoggerInterface>, maybe add an additional type check?

        );
    }

    /**
     * @return MarkupEngineManager
     */
    protected function getMockMarkupEngineManager()
    {
        // Just trying to keep the naming convention the same, but create an actual markup engine manager since it's
        // necessary in a lot of the unit tests
        $markupEngine = new MarkupEngineManager();

        $markupEngine->addMarkupEngines([
            new MarkdownEngine(),
            new RstEngine(),
            new PlainTextEngine(),
        ]);

        return $markupEngine;
    }

    /**
     * Get a mock EventDispatcher.
     *
     * @return EventDispatcherInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockEventDistpatcher()
    {
        return $this->getMock(EventDispatcherInterface::class);
    }

    /**
     * Get a mock logger.
     *
     * @return LoggerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected function getMockLogger()
    {
        return $this->getMock(LoggerInterface::class);
    }

    /**
     * Get a real logger instance that will save output to the console.
     *
     * @return Logger
     */
    protected function getReadableLogger()
    {
        stream_filter_register('intercept', StreamInterceptor::class);
        $stakxLogger = new Logger(new ConsoleOutput());
        stream_filter_append($stakxLogger->getOutputInterface()->getStream(), 'intercept');

It seems like you code against a concrete implementation and not the interface Symfony\Component\Console\Output\OutputInterface as the method getStream() does only exist in the following implementations of said interface: Symfony\Component\Console\Output\ConsoleOutput, Symfony\Component\Console\Output\StreamOutput.

        return $stakxLogger;
    }

    ///
    // Utility Functions
    ///

    /**
     * Get the directory of the unit tests.
     *
     * @return string
     */
    protected static function getTestRoot()
    {
        return __DIR__;
    }

    /**
     * Generate a FrontMatter-ready syntax to be used as a file's content.
     *
     * @param array  $frontMatter
     * @param string $body
     *
     * @return string
     */
    protected function buildFrontMatterTemplate(array $frontMatter = [], $body = 'Body text')
    {
        $fm = (empty($frontMatter)) ? '' : Yaml::dump($frontMatter, 2);

Avoid variables with short names like $fm. Configured minimum length is 3.

        return sprintf(self::FM_OBJ_TEMPLATE, $fm, $body);
    }

    ///
    // Misc Functions
    ///

    protected function bookCollectionProvider($jailed = false)
    {
        $cm = new CollectionManager(

Avoid variables with short names like $cm. Configured minimum length is 3.

            $this->getMockMarkupEngineManager(),
            $this->getMockConfiguration(),

It seems like $this->getMockConfiguration() targeting allejo\stakx\Test\PHPUnit_Stakx_TestCase::getMockConfiguration() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, allejo\stakx\Manager\CollectionManager::__construct() does only seem to accept object<allejo\stakx\Configuration>, maybe add an additional type check?

            $this->getMockTemplateBridge(),
            $this->getMockEventDistpatcher(),

It seems like $this->getMockEventDistpatcher() targeting allejo\stakx\Test\PHPUnit_Stakx_TestCase::getMockEventDistpatcher() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, allejo\stakx\Manager\CollectionManager::__construct() does only seem to accept object<Symfony\Component\EventDispatcher\EventDispatcherInterface>, maybe add an additional type check?

            $this->getMockLogger()

It seems like $this->getMockLogger() targeting allejo\stakx\Test\PHPUnit_Stakx_TestCase::getMockLogger() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, allejo\stakx\Manager\CollectionManager::__construct() does only seem to accept object<Psr\Log\LoggerInterface>, maybe add an additional type check?

        );
        $cm->parseCollections([
            [
                'name' => 'books',
                'folder' => 'tests/allejo/stakx/Test/assets/MyBookCollection/',
            ],
        ]);

        return (!$jailed) ? $cm->getCollections() : $cm->getJailedCollections();
    }
}