JolichtTest\MarkdownCms\Action\SingleBlogEntryActionTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	13	1
A	testGetTemplateRenderer()	0	4	1
A	testGetContentCreator()	0	4	1
A	testGetMarkdownDocumentParser()	0	4	1
A	testGetMarkdownCmsConfig()	0	4	1
A	testInvoke()	0	61	1

<?php
/**
 * Lichtenwallner  (https://lichtenwallner.at)
 *
 * @see https://github.com/jolicht/markdown-cms for the canonical source repository
 * @license https://github.com/jolicht/markdown-cms/blob/master/LICENSE MIT
 * @copyright Copyright (c) Johannes Lichtenwallner
 */
declare(strict_types = 1);
namespace JolichtTest\MarkdownCms\Action;

use PHPUnit\Framework\TestCase;
use Jolicht\MarkdownCms\Action\SingleBlogEntryAction;
use Zend\Expressive\Template\TemplateRendererInterface;
use Jolicht\MarkdownCms\ContentType\ContentCreator;
use Jolicht\MarkdownCms\Markdown\MarkdownDocumentParser;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Jolicht\MarkdownCms\Markdown\MarkdownDocument;
use Jolicht\MarkdownCms\ContentType\ContentTypeInterface;
use Prophecy\Argument;
use Zend\Diactoros\Response\HtmlResponse;

class SingleBlogEntryActionTest extends TestCase
{
    private $action, $templateRenderer, $contentCreator, $markdownDocumentParser, $markdownCmsConfig;

It is generally advisable to only define one property per statement.

    protected function setUp()
    {
        $this->templateRenderer = $this->createMock(TemplateRendererInterface::class);
        $this->contentCreator = $this->createMock(ContentCreator::class);
        $this->markdownDocumentParser = $this->createMock(MarkdownDocumentParser::class);
        $this->markdownCmsConfig = [
            'options' => [

            ]
        ];
        $this->action = new SingleBlogEntryAction(
            $this->templateRenderer, $this->contentCreator, $this->markdownDocumentParser, $this->markdownCmsConfig);
    }

    public function testGetTemplateRenderer()
    {
        $this->assertSame($this->templateRenderer, $this->action->getTemplateRenderer());
    }

    public function testGetContentCreator()
    {
        $this->assertSame($this->contentCreator, $this->action->getContentCreator());
    }

    public function testGetMarkdownDocumentParser()
    {
        $this->assertSame($this->markdownDocumentParser, $this->action->getMarkdownDocumentParser());
    }

    public function testGetMarkdownCmsConfig()
    {
        $this->assertSame($this->markdownCmsConfig, $this->action->getMarkdownCmsConfig());
    }

    public function testInvoke()
    {
        $templateRenderer = $this->prophesize(TemplateRendererInterface::class);
        $contentCreator = $this->prophesize(ContentCreator::class);
        $markdownDocumentParser = $this->prophesize(MarkdownDocumentParser::class);
        $markdownCmsConfig = [
            'options' => [
                'content_dir' => __DIR__ . '/_files',
            ],
            'content' => [
                'src' => [
                    'testId' => 'test.md'
                ]
            ]
        ];

        $action = new SingleBlogEntryAction(
            $templateRenderer->reveal(), $contentCreator->reveal(), $markdownDocumentParser->reveal(),
            $markdownCmsConfig
        );

        $request = $this->prophesize(ServerRequestInterface::class);
        $request
            ->getAttribute('id')
            ->willReturn('testId');

        $markdownDocument = $this->prophesize(MarkdownDocument::class);

        $markdownDocumentParser
            ->__invoke('testContent')
            ->willReturn($markdownDocument->reveal());

        $contentType = $this->prophesize(ContentTypeInterface::class);
        $contentType->getTemplate()
            ->willReturn('testTemplate');

        $contentCreator
            ->__invoke($markdownDocument->reveal())
            ->willReturn($contentType->reveal());



        $serverParams = [
            'REQUEST_SCHEME' => 'http',
            'SERVER_NAME' => 'testServerName'
        ];
        $request
            ->getServerParams()
            ->willReturn($serverParams);

        $templateRenderer
            ->render('testTemplate', Argument::type('array'))
            ->willReturn('');

        $response = $action(
            $request->reveal(),
            $this->prophesize(ResponseInterface::class)->reveal()
        );

        $this->assertInstanceOf(HtmlResponse::class, $response);
    }
}