GenericExceptionResponseControllerTest::shouldNotHandleThrowables() - Code Metrics - Inspection of "added argument-objects (WIP!) as a future replacem..." - addiks/symfony_generics - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 677e94...463d73 )

by Gerrit

created 2019-04-29 11:16 UTC

shouldNotHandleThrowables() A

↳ Parent: GenericExceptionResponseControllerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	9.456
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * Copyright (C) 2017  Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\SymfonyGenerics\Tests\Unit\Controllers;

use PHPUnit\Framework\TestCase;
use Addiks\SymfonyGenerics\Controllers\GenericExceptionResponseController;
use Addiks\SymfonyGenerics\Controllers\ControllerHelperInterface;
use Serializable;
use Symfony\Component\HttpFoundation\Response;
use InvalidArgumentException;
use DivisionByZeroError;
use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\ParameterBag;

final class GenericExceptionResponseControllerTest extends TestCase
{

    /**
     * @var GenericExceptionResponseController
     */
    private $controller;

    /**
     * @var ControllerHelperInterface
     */
    private $controllerHelper;

    /**
     * @var Serializable
     */
    private $innerController;

    /**
     * @var ArgumentCompilerInterface
     */
    private $argumentBuilder;

    public function setUp()
    {
        $this->controllerHelper = $this->createMock(ControllerHelperInterface::class);

        $this->innerController = $this->createMock(Serializable::class);

        $this->argumentBuilder = $this->createMock(ArgumentCompilerInterface::class);

    }

    /**
     * @test
     */
    public function shouldexecuteInnerControllerSafely()
    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
        ]);

        $this->innerController->method("serialize")->willReturn(new Response("foo", 205));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->executeInnerControllerSafely($request);

        $this->assertEquals("foo", $response->getContent());
        $this->assertEquals(205, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function shouldOverrideSuccessResponse()

    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'success-response' => "Some success!",
            'success-response-code' => 234,
        ]);

        $this->innerController->method("serialize")->willReturn(new Response("foo", 205));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->executeInnerControllerSafely($request);

        $this->assertEquals("Some success!", $response->getContent());
        $this->assertEquals(234, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function shouldOverrideSuccessResponseWithDefaultResponseCode()

    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'success-response' => "Some success!",
        ]);

        $this->innerController->method("serialize")->willReturn(new Response("foo", 205));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->executeInnerControllerSafely($request);

        $this->assertEquals("Some success!", $response->getContent());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function shouldTriggerSuccessFlashMessage()
    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'success-flash-message' => 'Some Success Message!'
        ]);

        $this->controllerHelper->expects($this->once())->method('addFlashMessage')->with(

            $this->equalTo('Some Success Message!'),
            $this->equalTo('success')
        );

        $this->innerController->method("serialize")->willReturn(new Response("foo", 200));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $controller->executeInnerControllerSafely($request);
    }

    /**
     * @test
     */
    public function shouldAddFlashMessageUponException()
    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'exception-responses' => [
                InvalidArgumentException::class => [
                    'flash-type' => 'danger',
                    'flash-message' => 'Something happened: %s'
                ]
            ]
        ]);

        $this->innerController->method("serialize")->will($this->returnCallback(
            function () {
                throw new InvalidArgumentException("Lorem ipsum!");
            }
        ));

        $this->controllerHelper->expects($this->once())->method('handleException');

        $this->controllerHelper->expects($this->once())->method('addFlashMessage')->with(

            $this->equalTo('Something happened: Lorem ipsum!'),
            $this->equalTo('danger')
        );

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->executeInnerControllerSafely($request);

        $this->assertEquals("Lorem ipsum!", $response->getContent());
        $this->assertEquals(500, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function shouldForwardThrowExceptionIfNotHandled()
    {
        /** @var mixed $controller */
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
        ]);

        $this->innerController->method("serialize")->will($this->returnCallback(
            function () {
                throw new InvalidArgumentException("Lorem ipsum!");
            }
        ));

        $this->expectException(InvalidArgumentException::class);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $controller->executeInnerControllerSafely($request);
    }

    /**
     * @test
     */
    public function shouldThrowExceptionIfInnerControllerDidNotReturnAResponse()
    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
        ]);

        $this->expectException(InvalidArgumentException::class);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $controller->executeInnerControllerSafely($request);
    }

    /**
     * @test
     */
    public function shouldThrowExceptionIfHandledExceptionClassIsNotException()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'exception-responses' => [
                "TotallyNotAnException" => [
                    'flash-type' => 'danger',
                    'flash-message' => 'Something happened: %s'
                ]
            ]
        ]);
    }

    /**
     * @test
     */
    public function shouldHandleThrowables()
    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'exception-responses' => [
                DivisionByZeroError::class => [
                    'flash-type' => 'danger',
                    'flash-message' => 'Something happened: %s'
                ]
            ]
        ]);

        $this->innerController->method("serialize")->will($this->returnCallback(
            function () {
                throw new DivisionByZeroError("Lorem ipsum");

            }
        ));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->executeInnerControllerSafely($request);

        $this->assertEquals("Lorem ipsum", $response->getContent());
    }

    /**
     * @test
     */
    public function shouldRejectNonObjectInnerController()

    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            'inner-controller' => false,
            'inner-controller-method' => "serialize",
        ]);
    }

    /**
     * @test
     */
    public function shouldRejectControllerBeingCalledAgain()

    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
        ]);

        $controller->__construct($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
        ]);
    }

    /**
     * @test
     */
    public function shouldRejectNonArrayGivenAsInnerControllerArguments()

    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'arguments' => "Lorem ipsum",
        ]);
    }

    /**
     * @test
     */
    public function shouldRedirectFromException()

    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'exception-responses' => [
                InvalidArgumentException::class => [
                    'redirect-route' => 'some_redirect_route',
                    'redirect-route-parameters' => [
                        'foo' => 'bar'
                    ]
                ]
            ]
        ]);

        $this->innerController->method("serialize")->will($this->returnCallback(
            function () {
                throw new InvalidArgumentException("Lorem ipsum!");
            }
        ));

        /** @var RedirectResponse $redirectResponse */
        $redirectResponse = $this->createMock(RedirectResponse::class);

        $this->controllerHelper->expects($this->once())->method('handleException');

        $this->controllerHelper->expects($this->once())->method('redirectToRoute')->with(

            $this->equalTo('some_redirect_route'),
            $this->equalTo([]),
            $this->equalTo(301)
        )->willReturn($redirectResponse);

        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->attributes = $this->createMock(ParameterBag::class);

        $request->attributes->method('get')->willReturn([]);

        /** @var Response $response */
        $response = $controller->executeInnerControllerSafely($request);

        $this->assertSame($redirectResponse, $response);
    }

    /**
     * @test
     */
    public function shouldBeCallableByInvokingController()

    {
        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
            'exception-responses' => [
                InvalidArgumentException::class => [
                    'redirect-route' => 'some_redirect_route',
                    'redirect-route-parameters' => [
                        'foo' => 'bar'
                    ]
                ]
            ]
        ]);

        $this->innerController->method("serialize")->will($this->returnCallback(
            function () {
                throw new InvalidArgumentException("Lorem ipsum!");
            }
        ));

        /** @var RedirectResponse $redirectResponse */
        $redirectResponse = $this->createMock(RedirectResponse::class);

        $this->controllerHelper->expects($this->once())->method('handleException');

        $this->controllerHelper->expects($this->once())->method('redirectToRoute')->with(

            $this->equalTo('some_redirect_route'),
            $this->equalTo([]),
            $this->equalTo(301)
        )->willReturn($redirectResponse);

        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->attributes = $this->createMock(ParameterBag::class);

        $request->attributes->method('get')->willReturn([]);

        $this->controllerHelper->method('getCurrentRequest')->willReturn($request);


        /** @var Response $response */
        $response = $controller();

        $this->assertSame($redirectResponse, $response);
    }

    /**
     * @test
     */
    public function shouldRejectCallWithoutRequest()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericExceptionResponseController($this->controllerHelper, $this->argumentBuilder, [
            'inner-controller' => $this->innerController,
            'inner-controller-method' => "serialize",
        ]);

        $this->controllerHelper->method('getCurrentRequest')->willReturn(null);


        $controller();
    }

}


1			<?php
2			/**
3			* Copyright (C) 2017 Gerrit Addiks.
4			* This package (including this file) was released under the terms of the GPL-3.0.
5			* You should have received a copy of the GNU General Public License along with this program.
6			* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7			* @license GPL-3.0
8			* @author Gerrit Addiks <[email protected]>
9			*/
10
11			namespace Addiks\SymfonyGenerics\Tests\Unit\Controllers;
12
13			use PHPUnit\Framework\TestCase;
14			use Addiks\SymfonyGenerics\Controllers\GenericExceptionResponseController;
15			use Addiks\SymfonyGenerics\Controllers\ControllerHelperInterface;
16			use Serializable;
17			use Symfony\Component\HttpFoundation\Response;
18			use InvalidArgumentException;
19			use DivisionByZeroError;
20			use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
21			use Symfony\Component\HttpFoundation\Request;
22			use Symfony\Component\HttpFoundation\RedirectResponse;
23			use Symfony\Component\HttpFoundation\ParameterBag;
24
25			final class GenericExceptionResponseControllerTest extends TestCase
26			{
27
28			/**
29			* @var GenericExceptionResponseController
30			*/
31			private $controller;
32
33			/**
34			* @var ControllerHelperInterface
35			*/
36			private $controllerHelper;
37
38			/**
39			* @var Serializable
40			*/

addiks / symfony_generics

Push — master ( 677e94...463d73 )

shouldNotHandleThrowables() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like