TrailingSlashControllerProviderTest::testShouldRespondOkToHeadWithoutTrailingSlash() - Code Metrics - Inspection of "Silex 2 (#9)" - graze/silex-trailing-slash-handler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 293404...dec55c )

by Harry

created 2017-09-26 09:17 UTC

testShouldRespondOkToHeadWithoutTrailingSlash() B

↳ Parent: TrailingSlashControllerProviderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	34
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	34
rs	8.8571
cc	1
eloc	19
nc	1
nop	0

<?php

namespace Graze\Silex\Tests\ControllerProvider;

use Graze\Silex\ControllerProvider\TrailingSlashControllerProvider;
use Mockery;
use Pimple\ServiceProviderInterface;
use Psr\Log\LoggerInterface;
use Silex\Application;
use Silex\Api\ControllerProviderInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Matcher\UrlMatcher;

/**
 * TrailingSlashControllerProvider test cases.
 */
class TrailingSlashControllerProviderTest extends \PHPUnit_Framework_TestCase
{
    public function testShouldInitalize()
    {
        $provider = new TrailingSlashControllerProvider();

        $this->assertInstanceOf(ControllerProviderInterface::class, $provider);
        $this->assertInstanceOf(ServiceProviderInterface::class, $provider);
    }

    public function testShouldRegisterUrlMatcher()
    {
        $app = new Application();

        $app->register(new TrailingSlashControllerProvider());

        $this->assertInstanceOf(UrlMatcher::class, $app['request_matcher']);
    }

    public function testShouldMount()
    {
        $app = new Application();

        // `mount` should return the application.
        $this->assertSame(
            $app,
            $app->mount('/', new TrailingSlashControllerProvider())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    /**
     * @dataProvider requestMethodProvider
     *
     * @param string $method
     */
    public function testShouldRespondOkWithoutTrailingSlash($method)

    {
        $app = new Application();

        $app->match('/foo/', function () {
            return 'hunter42';
        })->method($method);

        $app->match('/foo/bar/', function () {
            return 'What\'s the question?';
        })->method($method);

        $app->match('/foo/bar/baz/', function () {
            return 'Fizz Buzz';
        })->method($method);

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $request = Request::create('/foo', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar/baz', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * This just shows that the mount order for the controller provider doesn't
     * matter when all routes are defined with a trailing slash.
     *
     * @dataProvider requestMethodProvider
     *
     * @param string $method
     */
    public function testShouldRespondOkWithoutTrailingSlashWhenMountedFirst($method)

    {
        $app = new Application();

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $app->match('/foo/', function () {
            return 'hunter42';
        })->method($method);

        $app->match('/foo/bar/', function () {
            return 'What\'s the question?';
        })->method($method);

        $app->match('/foo/bar/baz/', function () {
            return 'Fizz Buzz';
        })->method($method);

        $request = Request::create('/foo', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar/baz', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * This just shows that the controller provider is compatiable with other
     * controller providers.
     *
     * @dataProvider requestMethodProvider
     *
     * @param string $method
     */
    public function testShouldRespondOkWithoutTrailingSlashWithMountedControllers($method)
    {
        $app = new Application();

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $controller = $app['controllers_factory'];

        $controller->match('/foo/', function () {
            return 'hunter42';
        })->method($method);

        $controller->match('/foo/bar/', function () {
            return 'hunter42';
        })->method($method);

        $controller->match('/foo/bar/baz/', function () {
            return 'hunter42';
        })->method($method);

        $provider = Mockery::mock(ControllerProviderInterface::class);
        $provider->shouldReceive('connect')->andReturn($controller);

        $app->mount('/', $provider);

        $request = Request::create('/foo', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar/baz', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @return array
     */
    public function requestMethodProvider()
    {
        return [
            ['GET'],
            ['POST'],
            ['PUT'],
            ['PATCH'],
            ['DELETE'],
            ['PURGE'],
            ['OPTIONS'],
            ['TRACE'],
            ['CONNECT'],
        ];
    }

    public function testShouldRespondOkToHeadWithoutTrailingSlash()
    {
        $app = new Application();

        $app->get('/foo/', function () {
            return 'hunter42';
        });

        $app->get('/foo/bar/', function () {
            return 'What\'s the question?';
        });

        $app->get('/foo/bar/baz/', function () {
            return 'Fizz Buzz';
        });

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $request = Request::create('/foo', 'HEAD');
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar', 'HEAD');
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar/baz', 'HEAD');
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * This is just to show when defining routes that the trailing slash is
     * required when the controller provider is mounted before any other routes.
     *
     * @dataProvider requestMethodProvider
     *
     * @param string $method
     */
    public function testWillRespondWithNotFoundForRouteWithNoTrailingSlashWhenMountedFirst($method)

    {
        $app = new Application();

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $app->match('/foo', function () {
            return 'hunter42';
        })->method($method);

        $app->match('/foo/bar', function () {
            return 'hunter42';
        })->method($method);

        $request = Request::create('/foo', $method);
        $response = $app->handle($request);

        $this->assertEquals(404, $response->getStatusCode());

        $request = Request::create('/foo/bar', $method);
        $response = $app->handle($request);

        $this->assertEquals(404, $response->getStatusCode());
    }

    /**
     * This shows that by default it will return 404 when the routes are defined with trailing slashes
     *
     * @dataProvider requestMethodProvider
     *
     * @param string $method
     */
    public function testWillRespondWillNotFoundForRouteWithTrailingSlashWhenNotMounted($method)

    {
        $app = new Application();

        $app->match('/foo/', function () {
            return 'hunter42';
        })->method($method);

        $app->match('/foo/bar/', function () {
            return 'hunter42';
        })->method($method);

        $app->register(new TrailingSlashControllerProvider());

        $request = Request::create('/foo', $method);
        $response = $app->handle($request);

        $this->assertEquals(404, $response->getStatusCode());

        $request = Request::create('/foo/bar', $method);
        $response = $app->handle($request);

        $this->assertEquals(404, $response->getStatusCode());
    }

    /**
     * This is just to show when defining routes with no trailing slash before
     * mounting the controller provider they should respond as expected.
     *
     * @dataProvider requestMethodProvider
     *
     * @param string $method
     */
    public function testWillRespondWithOkForRouteWithNoTrailingSlashWhenMountedLast($method)

    {
        $app = new Application();

        $app->match('/foo', function () {
            return 'hunter42';
        })->method($method);

        $app->match('/foo/bar', function () {
            return 'hunter42';
        })->method($method);

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $request = Request::create('/foo', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());

        $request = Request::create('/foo/bar', $method);
        $response = $app->handle($request);

        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * Test the case in which a request should have both query
     * string params and body params
     */
    public function testWillHandleQueryAndBodySeparately()
    {
        $app = new Application();

        $app->match('/foo/', function (Request $request) {
            $response = [
                'query' => $request->query->all(),
                'request' => $request->request->all()
            ];
            return json_encode($response, true);
        })->method('POST');

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $request = Request::create('/foo?q=1', 'POST', ['r' => 2]);
        $response = $app->handle($request);
        $this->assertEquals(200, $response->getStatusCode());
        $body = json_decode($response->getContent(), true);
        $this->assertRequestQuery($body);

        $request = Request::create('/foo/?q=1', 'POST', ['r' => 2]);
        $response = $app->handle($request);
        $this->assertEquals(200, $response->getStatusCode());
        $body = json_decode($response->getContent(), true);
        $this->assertRequestQuery($body);
    }

    /**
     * @param array $body
     */
    private function assertRequestQuery(array $body)
    {
        $this->assertArrayHasKey('query', $body);
        $this->assertArrayHasKey('request', $body);

        $this->assertArrayHasKey('q', $body['query']);
        $this->assertEquals(1, $body['query']['q']);

        $this->assertArrayHasKey('r', $body['request']);
        $this->assertEquals(2, $body['request']['r']);
    }

    public function testLogging()
    {
        $app = new Application();

        $logger = Mockery::mock(LoggerInterface::class)->makePartial()->shouldIgnoreMissing();
        $app['logger'] = $logger;

        $app->match('/foo/', function () {
            return 'hunter42';
        })->method('GET');

        $logger->shouldReceive('debug')
               ->with('Appending a trailing slash for the request to `/foo`.')
               ->once();
        $logger->shouldReceive('debug')
               ->with('Overriding the default Silex url matcher to Symfony\Component\Routing\Matcher\UrlMatcher.')
               ->once();

        $app->register(new TrailingSlashControllerProvider());
        $app->mount('/', new TrailingSlashControllerProvider());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $request = Request::create('/foo', 'GET');
        $response = $app->handle($request);
        $this->assertEquals(200, $response->getStatusCode());
    }
}


1			<?php
2
3			namespace Graze\Silex\Tests\ControllerProvider;
4
5			use Graze\Silex\ControllerProvider\TrailingSlashControllerProvider;
6			use Mockery;
7			use Pimple\ServiceProviderInterface;
8			use Psr\Log\LoggerInterface;
9			use Silex\Application;
10			use Silex\Api\ControllerProviderInterface;
11			use Symfony\Component\HttpFoundation\Request;
12			use Symfony\Component\Routing\Matcher\UrlMatcher;
13
14			/**
15			* TrailingSlashControllerProvider test cases.
16			*/
17			class TrailingSlashControllerProviderTest extends \PHPUnit_Framework_TestCase
18			{
19			public function testShouldInitalize()
20			{
21			$provider = new TrailingSlashControllerProvider();
22
23			$this->assertInstanceOf(ControllerProviderInterface::class, $provider);
24			$this->assertInstanceOf(ServiceProviderInterface::class, $provider);
25			}
26
27			public function testShouldRegisterUrlMatcher()
28			{
29			$app = new Application();
30
31			$app->register(new TrailingSlashControllerProvider());
32
33			$this->assertInstanceOf(UrlMatcher::class, $app['request_matcher']);
34			}
35
36			public function testShouldMount()
37			{
38			$app = new Application();
39
40			// `mount` should return the application.

graze / silex-trailing-slash-handler

Push — master ( 293404...dec55c )

testShouldRespondOkToHeadWithoutTrailingSlash() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like