CoreTest\Controller\AbstractControllerTestCase

Complexity

Total Complexity

19

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

9 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	19	1
A	assertResponseStatusCode()	0	6	1
A	getResponseHeader()	0	8	1
A	assertRedirect()	0	10	2
A	assertNotRedirect()	0	13	2
A	assertRedirectTo()	0	19	3
A	assertNotRedirectTo()	0	18	3
A	assertRedirectRegex()	0	19	3
A	assertNotRedirectRegex()	0	18	3

<?php
/**
 * YAWIK
 *
 * @filesource
 * @copyright (c) 2013-2015 Cross Solution (http://cross-solution.de)
 * @license       MIT
 */

namespace CoreTest\Controller;

use Test\Bootstrap;
use Zend\Http\Response;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\Mvc\MvcEvent;
use Zend\Mvc\Router\RouteMatch;
use Zend\Mvc\Router\SimpleRouteStack;
use Zend\Mvc\Service\RouterFactory;
use PHPUnit_Framework_ExpectationFailedException;

abstract class AbstractControllerTestCase extends \PHPUnit_Framework_TestCase
{
    /**
     * @var RouteMatch
     */
    protected $routeMatch;

    /**
     * @var MvcEvent
     */
    protected $event;

    /**
     * @var AbstractActionController
     */
    protected $controller;

    public function init($controllerName, $actionName = 'index', $lang = 'en')
    {
        $this->routeMatch = new RouteMatch(
            array(
                'controller' => $controllerName,
                'action' => $actionName,
                'lang' => $lang
            )
        );
        $this->event = new MvcEvent();
        $this->event->setRouteMatch($this->routeMatch);

        /** @var SimpleRouteStack $router */
        $routerFactory = new RouterFactory();
        $router        = $routerFactory->createService(clone Bootstrap::getServiceManager());
        $router->setDefaultParam('lang', $lang);

        $this->event->setRouter($router);
    }

    protected function assertResponseStatusCode($code)
    {
        /** @var Response $response */
        $response = $this->controller->getResponse();
        $this->assertSame($code, $response->getStatusCode());
    }

    /**
     * Get response header by key
     *
     * @param string $header
     *
     * @return \Zend\Http\Header\HeaderInterface|false

Should the return type not be boolean|\Zend\Http\Header\HeaderInterface|\ArrayIterator?

     */
    protected function getResponseHeader($header)
    {
        /** @var Response $response */
        $response = $this->controller->getResponse();
        $headers = $response->getHeaders();
        $responseHeader = $headers->get($header, false);

The call to Headers::get() has too many arguments starting with false.

        return $responseHeader;
    }

    /**
     * Assert that response is a redirect
     */
    protected function assertRedirect()
    {
        $responseHeader = $this->getResponseHeader('Location');
        if (false === $responseHeader) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                'Failed asserting response is a redirect'
            );
        }
        $this->assertNotEquals(false, $responseHeader);
    }

    /**
     * Assert that response is NOT a redirect
     */
    protected function assertNotRedirect()
    {
        $responseHeader = $this->getResponseHeader('Location');
        if (false !== $responseHeader) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                sprintf(
                    'Failed asserting response is NOT a redirect, actual redirection is "%s"',
                    $responseHeader->getFieldValue()

The method getFieldValue does only exist in Zend\Http\Header\HeaderInterface, but not in ArrayIterator.

                )
            );
        }
        $this->assertFalse($responseHeader);
    }

    /**
     * Assert that response redirects to given URL
     *
     * @param string $url
     *
     * @throws \PHPUnit_Framework_ExpectationFailedException
     */
    protected function assertRedirectTo($url)
    {
        $responseHeader = $this->getResponseHeader('Location');
        if (!$responseHeader) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                'Failed asserting response is a redirect'
            );
        }
        if ($url != $responseHeader->getFieldValue()) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                sprintf(
                    'Failed asserting response redirects to "%s", actual redirection is "%s"',
                    $url,
                    $responseHeader->getFieldValue()

The method getFieldValue does only exist in Zend\Http\Header\HeaderInterface, but not in ArrayIterator.

                )
            );
        }
        $this->assertEquals($url, $responseHeader->getFieldValue());
    }

    /**
     * Assert that response does not redirect to given URL
     *
     * @param string $url
     *
     * @throws \PHPUnit_Framework_ExpectationFailedException
     */
    protected function assertNotRedirectTo($url)
    {
        $responseHeader = $this->getResponseHeader('Location');
        if (!$responseHeader) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                'Failed asserting response is a redirect'
            );
        }
        if ($url == $responseHeader->getFieldValue()) {

The method getFieldValue does only exist in Zend\Http\Header\HeaderInterface, but not in ArrayIterator.

            throw new PHPUnit_Framework_ExpectationFailedException(
                sprintf(
                    'Failed asserting response redirects to "%s"',
                    $url
                )
            );
        }
        $this->assertNotEquals($url, $responseHeader->getFieldValue());
    }

    /**
     * Assert that redirect location matches pattern
     *
     * @param string $pattern
     *
     * @throws \PHPUnit_Framework_ExpectationFailedException
     */
    protected function assertRedirectRegex($pattern)
    {
        $responseHeader = $this->getResponseHeader('Location');
        if (!$responseHeader) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                'Failed asserting response is a redirect'
            );
        }
        if (!preg_match($pattern, $responseHeader->getFieldValue())) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                sprintf(
                    'Failed asserting response redirects to URL MATCHING "%s", actual redirection is "%s"',
                    $pattern,
                    $responseHeader->getFieldValue()

The method getFieldValue does only exist in Zend\Http\Header\HeaderInterface, but not in ArrayIterator.

                )
            );
        }
        $this->assertTrue((bool)preg_match($pattern, $responseHeader->getFieldValue()));
    }

    /**
     * Assert that redirect location does not match pattern
     *
     * @param string $pattern
     *
     * @throws \PHPUnit_Framework_ExpectationFailedException
     */
    protected function assertNotRedirectRegex($pattern)
    {
        $responseHeader = $this->getResponseHeader('Location');
        if (!$responseHeader) {
            throw new PHPUnit_Framework_ExpectationFailedException(
                'Failed asserting response is a redirect'
            );
        }
        if (preg_match($pattern, $responseHeader->getFieldValue())) {

The method getFieldValue does only exist in Zend\Http\Header\HeaderInterface, but not in ArrayIterator.

            throw new PHPUnit_Framework_ExpectationFailedException(
                sprintf(
                    'Failed asserting response DOES NOT redirect to URL MATCHING "%s"',
                    $pattern
                )
            );
        }
        $this->assertFalse((bool)preg_match($pattern, $responseHeader->getFieldValue()));
    }
}