PHPUnit_Stakx_TestCase::invokeClassFunctionWithNamedParams() - Code Metrics - Inspection of "Merge pull request #120 from stakx-io/feature/anch..." - stakx-io/stakx - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 043012...3d7377 )

by Vladimir

created 2020-04-07 04:31 UTC

invokeClassFunctionWithNamedParams() A

↳ Parent: PHPUnit_Stakx_TestCase

Complexity

Conditions	4
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
nc	4
nop	3
dl	0
loc	37
rs	9.328
c	0
b	0
f	0

<?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\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\WritableFolder;
use allejo\stakx\Logger;
use allejo\stakx\Manager\AssetManager;
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\RedirectMapper;
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
{
    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();
    }

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

        }
    }

    ///
    // 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));


        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 WritableFolder($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

     * @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)
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
        {
            $filename = hash('sha256', uniqid(mt_rand(), true), false);

        }

        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 AssetManager
     */
    protected function getMockAssetManager()
    {
        return new AssetManager($this->getMockEventDistpatcher(), $this->getMockLogger());

    }

    /**
     * @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(),

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

        );
    }

    /**
     * @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($this->getMockAssetManager()),
            new RstEngine($this->getMockAssetManager()),
            new PlainTextEngine(),
        ]);

        return $markupEngine;
    }

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

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

        return $stub;
    }

    /**
     * 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');
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

        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);

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

    /**
     * @param string               $cls
     * @param string               $method
     * @param array<string, mixed> $namedParams
     *
     * @throws \ReflectionException
     *
     * @return mixed
     */
    protected function invokeClassFunctionWithNamedParams($cls, $method, $namedParams = [])
    {
        $clsReflection = new \ReflectionClass($cls);
        $fxns = $clsReflection->getMethods();

        /** @var \ReflectionMethod $fxnToCall */
        $fxnToCall = \__::chain($fxns)
            ->filter(function (\ReflectionMethod $fxn) use ($method) {
                return $fxn->getName() === $method;
            })
            ->get(0, null)
            ->value()
        ;

        if ($fxnToCall === null)
        {
            throw new \BadFunctionCallException(sprintf('No function by the name of "%s" in this class', $method));
        }

        $arguments = $fxnToCall->getParameters();
        $callUserFuncArray = [];

        /** @var \ReflectionParameter $argument */
        foreach ($arguments as $argument)
        {
            if (isset($namedParams[$argument->getName()]))
            {
                $callUserFuncArray[] = $namedParams[$argument->getName()];
            }
            else
            {
                $callUserFuncArray[] = $argument->getDefaultValue();
            }
        }

        return $fxnToCall->invoke(null, ...$callUserFuncArray);
    }

    ///
    // Misc Functions
    ///

    protected function bookCollectionProvider($jailed = false)
    {
        $cm = new CollectionManager(
            $this->getMockMarkupEngineManager(),
            $this->getMockConfiguration(),

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

            $this->getMockLogger()

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

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


1			<?php
2
3			/**
4			* @copyright 2018 Vladimir Jimenez
5			* @license https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
6			*/
7
8			namespace allejo\stakx\Test;
9
10			use allejo\stakx\AssetEngine\AssetEngineManager;
11			use allejo\stakx\Configuration;
12			use allejo\stakx\Document\FrontMatterDocument;
13			use allejo\stakx\Filesystem\File;
14			use allejo\stakx\Filesystem\Filesystem;
15			use allejo\stakx\Filesystem\FilesystemLoader as fs;
16			use allejo\stakx\Filesystem\WritableFolder;
17			use allejo\stakx\Logger;
18			use allejo\stakx\Manager\AssetManager;
19			use allejo\stakx\Manager\CollectionManager;
20			use allejo\stakx\Manager\DataManager;
21			use allejo\stakx\Manager\MenuManager;
22			use allejo\stakx\Manager\PageManager;
23			use allejo\stakx\MarkupEngine\MarkdownEngine;
24			use allejo\stakx\MarkupEngine\MarkupEngineManager;
25			use allejo\stakx\MarkupEngine\PlainTextEngine;
26			use allejo\stakx\MarkupEngine\RstEngine;
27			use allejo\stakx\RedirectMapper;
28			use allejo\stakx\RuntimeStatus;
29			use allejo\stakx\Service;
30			use allejo\stakx\Templating\Twig\TwigExtension;
31			use allejo\stakx\Templating\Twig\TwigStakxBridge;
32			use allejo\stakx\Templating\Twig\TwigStakxBridgeFactory;
33			use org\bovigo\vfs\vfsStream;
34			use org\bovigo\vfs\vfsStreamDirectory;
35			use org\bovigo\vfs\vfsStreamFile;
36			use Psr\Log\LoggerInterface;
37			use Symfony\Component\Console\Output\ConsoleOutput;
38			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
39			use Symfony\Component\Yaml\Yaml;
40

stakx-io / stakx

Push — develop ( 043012...3d7377 )

invokeClassFunctionWithNamedParams() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like