RequestHandlerTest.php$12 ➔ testHandleWithoutStack() - Code Metrics - Inspection of "Minor changes" - sunrise-php/http-router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 10fd01...6c0fb4 )

by Anatoly

created 2018-12-09 20:56 UTC

php$12 ➔ testHandleWithoutStack() A

↳ Parent: RequestHandlerTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0

<?php

namespace Sunrise\Http\ServerRequest\Tests;

use PHPUnit\Framework\TestCase;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Sunrise\Http\Message\ResponseFactory;
use Sunrise\Http\Router\RequestHandler;
use Sunrise\Http\ServerRequest\ServerRequestFactory;

class RequestHandlerTest extends TestCase
{
	public function testConstructor()
	{
		$handler = new RequestHandler();

		$this->assertInstanceOf(RequestHandlerInterface::class, $handler);
	}

	public function testAdd()
	{
		$handler = new RequestHandler();

		$this->assertInstanceOf(RequestHandlerInterface::class, $handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request);
			}
		}));
	}

	public function testHandleQueue()
	{
		$handler = new RequestHandler();

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'foo');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'bar');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'baz');
			}
		});

		$request = (new ServerRequestFactory)
		->createServerRequest('GET', '/');

		$response = $handler->handle($request);

		$this->assertEquals([
			'x-queue' => ['baz', 'bar', 'foo'],
		], $response->getHeaders());
	}

	public function testHandleBreakQueueAtBeginning()
	{
		$handler = new RequestHandler();

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return (new ResponseFactory)->createResponse()->withAddedHeader('x-queue', 'foo');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'bar');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'baz');
			}
		});

		$request = (new ServerRequestFactory)
		->createServerRequest('GET', '/');

		$response = $handler->handle($request);

		$this->assertEquals([
			'x-queue' => ['foo'],
		], $response->getHeaders());
	}

	public function testHandleBreakQueueAtMiddle()
	{
		$handler = new RequestHandler();

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'foo');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return (new ResponseFactory)->createResponse()->withAddedHeader('x-queue', 'bar');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'baz');
			}
		});

		$request = (new ServerRequestFactory)
		->createServerRequest('GET', '/');

		$response = $handler->handle($request);

		$this->assertEquals([
			'x-queue' => ['bar', 'foo'],
		], $response->getHeaders());
	}

	public function testHandleBreakQueueAtEnd()
	{
		$handler = new RequestHandler();

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'foo');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return $handler->handle($request)->withAddedHeader('x-queue', 'bar');
			}
		});

		$handler->add(new class implements MiddlewareInterface {
			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
				return (new ResponseFactory)->createResponse()->withAddedHeader('x-queue', 'baz');
			}
		});

		$request = (new ServerRequestFactory)
		->createServerRequest('GET', '/');

		$response = $handler->handle($request);

		$this->assertEquals([
			'x-queue' => ['baz', 'bar', 'foo'],
		], $response->getHeaders());
	}

	public function testHandleWithoutStack()
	{
		$handler = new RequestHandler();

		$request = (new ServerRequestFactory)
		->createServerRequest('GET', '/');

		$response = $handler->handle($request);

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


1			<?php
2
3			namespace Sunrise\Http\ServerRequest\Tests;
4
5			use PHPUnit\Framework\TestCase;
6			use Psr\Http\Message\ResponseInterface;
7			use Psr\Http\Message\ServerRequestInterface;
8			use Psr\Http\Server\MiddlewareInterface;
9			use Psr\Http\Server\RequestHandlerInterface;
10			use Sunrise\Http\Message\ResponseFactory;
11			use Sunrise\Http\Router\RequestHandler;
12			use Sunrise\Http\ServerRequest\ServerRequestFactory;
13
14			class RequestHandlerTest extends TestCase
15			{
16			public function testConstructor()
17			{
18			$handler = new RequestHandler();
19
20			$this->assertInstanceOf(RequestHandlerInterface::class, $handler);
21			}
22
23			public function testAdd()
24			{
25			$handler = new RequestHandler();
26
27			$this->assertInstanceOf(RequestHandlerInterface::class, $handler->add(new class implements MiddlewareInterface {
28			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
29			return $handler->handle($request);
30			}
31			}));
32			}
33
34			public function testHandleQueue()
35			{
36			$handler = new RequestHandler();
37
38			$handler->add(new class implements MiddlewareInterface {
39			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
40			return $handler->handle($request)->withAddedHeader('x-queue', 'foo');
41			}
42			});
43
44			$handler->add(new class implements MiddlewareInterface {
45			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
46			return $handler->handle($request)->withAddedHeader('x-queue', 'bar');
47			}
48			});
49
50			$handler->add(new class implements MiddlewareInterface {
51			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
52			return $handler->handle($request)->withAddedHeader('x-queue', 'baz');
53			}
54			});
55
56			$request = (new ServerRequestFactory)
57			->createServerRequest('GET', '/');
58
59			$response = $handler->handle($request);
60
61			$this->assertEquals([
62			'x-queue' => ['baz', 'bar', 'foo'],
63			], $response->getHeaders());
64			}
65
66			public function testHandleBreakQueueAtBeginning()
67			{
68			$handler = new RequestHandler();
69
70			$handler->add(new class implements MiddlewareInterface {
71			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
72			return (new ResponseFactory)->createResponse()->withAddedHeader('x-queue', 'foo');
73			}
74			});
75
76			$handler->add(new class implements MiddlewareInterface {
77			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
78			return $handler->handle($request)->withAddedHeader('x-queue', 'bar');
79			}
80			});
81
82			$handler->add(new class implements MiddlewareInterface {
83			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
84			return $handler->handle($request)->withAddedHeader('x-queue', 'baz');
85			}
86			});
87
88			$request = (new ServerRequestFactory)
89			->createServerRequest('GET', '/');
90
91			$response = $handler->handle($request);
92
93			$this->assertEquals([
94			'x-queue' => ['foo'],
95			], $response->getHeaders());
96			}
97
98			public function testHandleBreakQueueAtMiddle()
99			{
100			$handler = new RequestHandler();
101
102			$handler->add(new class implements MiddlewareInterface {
103			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
104			return $handler->handle($request)->withAddedHeader('x-queue', 'foo');
105			}
106			});
107
108			$handler->add(new class implements MiddlewareInterface {
109			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
110			return (new ResponseFactory)->createResponse()->withAddedHeader('x-queue', 'bar');
111			}
112			});
113
114			$handler->add(new class implements MiddlewareInterface {
115			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
116			return $handler->handle($request)->withAddedHeader('x-queue', 'baz');
117			}
118			});
119
120			$request = (new ServerRequestFactory)
121			->createServerRequest('GET', '/');
122
123			$response = $handler->handle($request);
124
125			$this->assertEquals([
126			'x-queue' => ['bar', 'foo'],
127			], $response->getHeaders());
128			}
129
130			public function testHandleBreakQueueAtEnd()
131			{
132			$handler = new RequestHandler();
133
134			$handler->add(new class implements MiddlewareInterface {
135			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
136			return $handler->handle($request)->withAddedHeader('x-queue', 'foo');
137			}
138			});
139
140			$handler->add(new class implements MiddlewareInterface {
141			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
142			return $handler->handle($request)->withAddedHeader('x-queue', 'bar');
143			}
144			});
145
146			$handler->add(new class implements MiddlewareInterface {
147			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface {
148			return (new ResponseFactory)->createResponse()->withAddedHeader('x-queue', 'baz');
149			}
150			});
151
152			$request = (new ServerRequestFactory)
153			->createServerRequest('GET', '/');
154
155			$response = $handler->handle($request);
156
157			$this->assertEquals([
158			'x-queue' => ['baz', 'bar', 'foo'],
159			], $response->getHeaders());
160			}
161
162			public function testHandleWithoutStack()
163			{
164			$handler = new RequestHandler();
165
166			$request = (new ServerRequestFactory)
167			->createServerRequest('GET', '/');
168
169			$response = $handler->handle($request);
170
171			$this->assertInstanceOf(ResponseInterface::class, $response);
172			}
173			}
174

sunrise-php / http-router

Push — master ( 10fd01...6c0fb4 )

php$12 ➔ testHandleWithoutStack() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like