RequestBuilderTest::testAppliedContentParsersWithHeader() - Code Metrics - Inspection of "Merge pull request #7 from teresko/master" - fracture/http - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b5ed08...526d1c )

by Mārtiņš

created 2016-02-22 08:36 UTC

testAppliedContentParsersWithHeader() A

↳ Parent: RequestBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	17
rs	9.4285
cc	1
eloc	9
nc	1
nop	0

<?php


namespace Fracture\Http;

use Exception;
use ReflectionClass;
use PHPUnit_Framework_TestCase;

class RequestBuilderTest extends PHPUnit_Framework_TestCase
{



    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::buildInstance
     */
    public function testSimpleUsecase()
    {
        $builder = new RequestBuilder;
        $instance = $builder->create([]);
        $this->assertInstanceOf('Fracture\Http\Request', $instance);
    }

    /**
     * @covers Fracture\Http\RequestBuilder::create
     */
    public function testInternalManipulationsofInstance()
    {
        $request = new Request(
            new FileBagBuilder(
                new UploadedFileBuilder
            )
        );

        $params = [
            'get'    => [],
            'post'   => [],
            'server' => [],
            'files'  => [],
            'cookies'=> [],
        ];


        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['buildInstance', 'applyParams']);

        $builder->expects($this->once())
                ->method('buildInstance')
                ->will($this->returnValue($request));

        $builder->expects($this->once())
                ->method('applyParams')
                ->with($this->equalTo($request), $this->equalTo($params));


        $instance = $builder->create([]);
        $this->assertInstanceOf('Fracture\Http\Request', $instance);
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyParams
     * @covers Fracture\Http\RequestBuilder::applyWebContext
     */
    public function testMethodCallsOnInstance()
    {
        $request = $this->getMock(
            'Fracture\Http\Request',
            [
                'setParameters',
                'setMethod',
                'setUploadedFiles',
                'setAddress',
                'prepare',
            ]
        );

        $request->expects($this->exactly(2))->method('setParameters');
        $request->expects($this->once())->method('setMethod');
        $request->expects($this->once())->method('prepare');

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['buildInstance']);

        $builder->expects($this->once())
                ->method('buildInstance')
                ->will($this->returnValue($request));


        $request->expects($this->once())->method('setUploadedFiles');
        $request->expects($this->once())->method('setAddress');

        $instance = $builder->create([
            'get'    => [],
            'post'   => [],
            'server' => [
                'REQUEST_METHOD' => 'post',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
            'files'  => [],
        ]);
        $this->assertInstanceOf('Fracture\Http\Request', $instance);
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyParams
     */
    public function testMethodCallsOnInstanceForCLI()
    {
        $builder = new RequestBuilder;


        $instance = $builder->create([
            'get'    => [],
            'post'   => [],
            'files'  => [],
        ]);
        $this->assertInstanceOf('Fracture\Http\Request', $instance);
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::buildInstance
     */
    public function testUnalteredInstance()
    {
        $input = [
            'get'  => [],
            'server' => [
                'REQUEST_METHOD' => 'post',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
        ];

        $params = [
            'get'    => [],
            'post'   => [],
            'server' => [
                'REQUEST_METHOD' => 'post',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
            'files'  => [],
            'cookies'=> [],
        ];



        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['applyParams']);

        $builder->expects($this->once())
                ->method('applyParams')
                ->with($this->isInstanceOf('\Fracture\Http\Request'), $this->equalTo($params));

        $builder->create($input);
    }

    /**
     * @covers Fracture\Http\RequestBuilder::create
     */
    public function testWhenContentParsersApplied()
    {
        $input = [
            'get'    => [],
            'server' => [
                'REQUEST_METHOD' => 'put',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['applyContentParsers', 'isCLI']);

        $builder->expects($this->once())
                ->method('applyContentParsers')
                ->with($this->isInstanceOf('\Fracture\Http\Request'));

        $builder->create($input);
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     */
    public function testWhenContentParsersIgnored()
    {
        $input = [
            'get'    => [],
            'server' => [
                'REQUEST_METHOD' => 'get',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['applyContentParsers', 'isCLI']);

        $builder->expects($this->never())
                ->method('applyContentParsers');

        $builder->create($input);
    }



    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::addContentParser
     *
     * @covers Fracture\Http\RequestBuilder::alterParameters
     */
    public function testAppliedContentParsers()
    {
        $input = [
            'get'    => [],
            'server' => [
                'REQUEST_METHOD' => 'delete',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
                'CONTENT_TYPE'   => 'application/json',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);

        $builder->addContentParser('application/json', function () {
            return ['foo' => 'bar'];
        });

        $instance = $builder->create($input);
        $this->assertEquals('bar', $instance->getParameter('foo'));

    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::addContentParser
     *
     * @covers Fracture\Http\RequestBuilder::alterParameters
     */
    public function testAppliedContentParsersOverridesPameters()
    {
        $input = [
            'get'    => [
                'foo' => 'bar',
            ],
            'server' => [
                'REQUEST_METHOD' => 'delete',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
                'CONTENT_TYPE'   => 'application/json',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);

        $builder->addContentParser('application/json', function () {
            return ['foo' => 'different'];
        });

        $instance = $builder->create($input);
        $this->assertEquals('different', $instance->getParameter('foo'));

    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::addContentParser
     *
     * @covers Fracture\Http\RequestBuilder::alterParameters
     *
     * @expectedException PHPUnit_Framework_Error_Warning
     */
    public function testAppliedContentParsersWithBadReturn()
    {
        $input = [
            'get'    => [
                'foo' => 'bar',
            ],
            'server' => [
                'REQUEST_METHOD' => 'delete',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
                'CONTENT_TYPE'   => 'application/json',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);

        $builder->addContentParser('application/json', function () {
            return null;
        });

        $instance = $builder->create($input);
        $this->assertEquals('bar', $instance->getParameter('foo'));

    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::addContentParser
     */
    public function testAppliedContentParsersWithMissingHeader()
    {
        $input = [
            'get'    => [],
            'server' => [
                'REQUEST_METHOD' => 'delete',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);

        $builder->addContentParser('application/json', function () {
            return ['foo' => 'bar'];
        });

        $instance = $builder->create($input);
        $this->assertEquals(null, $instance->getParameter('foo'));

    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::addContentParser
     */
    public function testAppliedContentParsersWithHeader()
    {
        $input = [
            'server' => [
                'CONTENT_TYPE'    => 'text/html;version=2',
            ],
        ];

        $builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);

        $builder->addContentParser('text/html', function ($header) {
            return ['foo' => $header->getParameter('version')];
        });

        $instance = $builder->create($input);
        $this->assertEquals(2, $instance->getParameter('foo'));
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::applyHeaders
     */
    public function testIfAcceptHeaderApplied()
    {
        $input = [
            'get'    => [],
            'server' => [
                'REQUEST_METHOD' => 'post',
                'REMOTE_ADDR'    => '0.0.0.0',
                'HTTP_ACCEPT'    => 'text/html',
            ],
        ];

        $builder = new RequestBuilder;
        $instance = $builder->create($input);

        $this->assertInstanceOf('Fracture\Http\Headers\Accept', $instance->getAcceptHeader());
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyContentParsers
     * @covers Fracture\Http\RequestBuilder::applyHeaders
     */
    public function testIfContentTypeHeaderApplied()
    {
        $input = [
            'get'    => [],
            'server' => [
                'REQUEST_METHOD' => 'post',
                'REMOTE_ADDR'    => '0.0.0.0',
                'CONTENT_TYPE'   => 'application/json',
            ],
        ];


        $builder = new RequestBuilder;
        $instance = $builder->create($input);

        $this->assertInstanceOf('Fracture\Http\Headers\ContentType', $instance->getContentTypeHeader());
    }


    /**
     * @covers Fracture\Http\RequestBuilder::create
     * @covers Fracture\Http\RequestBuilder::applyParams
     *
     * @covers Fracture\Http\RequestBuilder::alterParameters
     */
    public function testWithCookieAddition()
    {
        $input = [
            'cookies' => [
                'name' => 'value'
            ]
        ];

        $builder = new RequestBuilder;
        $instance = $builder->create($input);

        $this->assertInstanceOf('Fracture\Http\Cookie', $instance->getCookie('name'));
    }
}


1			<?php
2
3
4			namespace Fracture\Http;
5
6			use Exception;
7			use ReflectionClass;
8			use PHPUnit_Framework_TestCase;
9
10			class RequestBuilderTest extends PHPUnit_Framework_TestCase
11			{
12
13
14
15			/**
16			* @covers Fracture\Http\RequestBuilder::create
17			* @covers Fracture\Http\RequestBuilder::buildInstance
18			*/
19			public function testSimpleUsecase()
20			{
21			$builder = new RequestBuilder;
22			$instance = $builder->create([]);
23			$this->assertInstanceOf('Fracture\Http\Request', $instance);
24			}
25
26			/**
27			* @covers Fracture\Http\RequestBuilder::create
28			*/
29			public function testInternalManipulationsofInstance()
30			{
31			$request = new Request(
32			new FileBagBuilder(
33			new UploadedFileBuilder
34			)
35			);
36
37			$params = [
38			'get' => [],
39			'post' => [],
40			'server' => [],
41			'files' => [],
42			'cookies'=> [],
43			];
44
45
46			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['buildInstance', 'applyParams']);
47
48			$builder->expects($this->once())
49			->method('buildInstance')
50			->will($this->returnValue($request));
51
52			$builder->expects($this->once())
53			->method('applyParams')
54			->with($this->equalTo($request), $this->equalTo($params));
55
56
57			$instance = $builder->create([]);
58			$this->assertInstanceOf('Fracture\Http\Request', $instance);
59			}
60
61
62			/**
63			* @covers Fracture\Http\RequestBuilder::create
64			* @covers Fracture\Http\RequestBuilder::applyParams
65			* @covers Fracture\Http\RequestBuilder::applyWebContext
66			*/
67			public function testMethodCallsOnInstance()
68			{
69			$request = $this->getMock(
70			'Fracture\Http\Request',
71			[
72			'setParameters',
73			'setMethod',
74			'setUploadedFiles',
75			'setAddress',
76			'prepare',
77			]
78			);
79
80			$request->expects($this->exactly(2))->method('setParameters');
81			$request->expects($this->once())->method('setMethod');
82			$request->expects($this->once())->method('prepare');
83
84			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['buildInstance']);
85
86			$builder->expects($this->once())
87			->method('buildInstance')
88			->will($this->returnValue($request));
89
90
91			$request->expects($this->once())->method('setUploadedFiles');
92			$request->expects($this->once())->method('setAddress');
93
94			$instance = $builder->create([
95			'get' => [],
96			'post' => [],
97			'server' => [
98			'REQUEST_METHOD' => 'post',
99			'REMOTE_ADDR' => '0.0.0.0',
100			'HTTP_ACCEPT' => 'text/html',
101			],
102			'files' => [],
103			]);
104			$this->assertInstanceOf('Fracture\Http\Request', $instance);
105			}
106
107
108			/**
109			* @covers Fracture\Http\RequestBuilder::create
110			* @covers Fracture\Http\RequestBuilder::applyParams
111			*/
112			public function testMethodCallsOnInstanceForCLI()
113			{
114			$builder = new RequestBuilder;
115
116
117			$instance = $builder->create([
118			'get' => [],
119			'post' => [],
120			'files' => [],
121			]);
122			$this->assertInstanceOf('Fracture\Http\Request', $instance);
123			}
124
125
126			/**
127			* @covers Fracture\Http\RequestBuilder::create
128			* @covers Fracture\Http\RequestBuilder::buildInstance
129			*/
130			public function testUnalteredInstance()
131			{
132			$input = [
133			'get' => [],
134			'server' => [
135			'REQUEST_METHOD' => 'post',
136			'REMOTE_ADDR' => '0.0.0.0',
137			'HTTP_ACCEPT' => 'text/html',
138			],
139			];
140
141			$params = [
142			'get' => [],
143			'post' => [],
144			'server' => [
145			'REQUEST_METHOD' => 'post',
146			'REMOTE_ADDR' => '0.0.0.0',
147			'HTTP_ACCEPT' => 'text/html',
148			],
149			'files' => [],
150			'cookies'=> [],
151			];
152
153
154
155			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['applyParams']);
156
157			$builder->expects($this->once())
158			->method('applyParams')
159			->with($this->isInstanceOf('\Fracture\Http\Request'), $this->equalTo($params));
160
161			$builder->create($input);
162			}
163
164			/**
165			* @covers Fracture\Http\RequestBuilder::create
166			*/
167			public function testWhenContentParsersApplied()
168			{
169			$input = [
170			'get' => [],
171			'server' => [
172			'REQUEST_METHOD' => 'put',
173			'REMOTE_ADDR' => '0.0.0.0',
174			'HTTP_ACCEPT' => 'text/html',
175			],
176			];
177
178			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['applyContentParsers', 'isCLI']);
179
180			$builder->expects($this->once())
181			->method('applyContentParsers')
182			->with($this->isInstanceOf('\Fracture\Http\Request'));
183
184			$builder->create($input);
185			}
186
187
188			/**
189			* @covers Fracture\Http\RequestBuilder::create
190			*/
191			public function testWhenContentParsersIgnored()
192			{
193			$input = [
194			'get' => [],
195			'server' => [
196			'REQUEST_METHOD' => 'get',
197			'REMOTE_ADDR' => '0.0.0.0',
198			'HTTP_ACCEPT' => 'text/html',
199			],
200			];
201
202			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['applyContentParsers', 'isCLI']);
203
204			$builder->expects($this->never())
205			->method('applyContentParsers');
206
207			$builder->create($input);
208			}
209
210
211
212			/**
213			* @covers Fracture\Http\RequestBuilder::create
214			* @covers Fracture\Http\RequestBuilder::applyContentParsers
215			* @covers Fracture\Http\RequestBuilder::addContentParser
216			*
217			* @covers Fracture\Http\RequestBuilder::alterParameters
218			*/
219			public function testAppliedContentParsers()
220			{
221			$input = [
222			'get' => [],
223			'server' => [
224			'REQUEST_METHOD' => 'delete',
225			'REMOTE_ADDR' => '0.0.0.0',
226			'HTTP_ACCEPT' => 'text/html',
227			'CONTENT_TYPE' => 'application/json',
228			],
229			];
230
231			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);
232
233			$builder->addContentParser('application/json', function () {
234			return ['foo' => 'bar'];
235			});
236
237			$instance = $builder->create($input);
238			$this->assertEquals('bar', $instance->getParameter('foo'));
239
240			}
241
242
243			/**
244			* @covers Fracture\Http\RequestBuilder::create
245			* @covers Fracture\Http\RequestBuilder::applyContentParsers
246			* @covers Fracture\Http\RequestBuilder::addContentParser
247			*
248			* @covers Fracture\Http\RequestBuilder::alterParameters
249			*/
250			public function testAppliedContentParsersOverridesPameters()
251			{
252			$input = [
253			'get' => [
254			'foo' => 'bar',
255			],
256			'server' => [
257			'REQUEST_METHOD' => 'delete',
258			'REMOTE_ADDR' => '0.0.0.0',
259			'HTTP_ACCEPT' => 'text/html',
260			'CONTENT_TYPE' => 'application/json',
261			],
262			];
263
264			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);
265
266			$builder->addContentParser('application/json', function () {
267			return ['foo' => 'different'];
268			});
269
270			$instance = $builder->create($input);
271			$this->assertEquals('different', $instance->getParameter('foo'));
272
273			}
274
275
276			/**
277			* @covers Fracture\Http\RequestBuilder::create
278			* @covers Fracture\Http\RequestBuilder::applyContentParsers
279			* @covers Fracture\Http\RequestBuilder::addContentParser
280			*
281			* @covers Fracture\Http\RequestBuilder::alterParameters
282			*
283			* @expectedException PHPUnit_Framework_Error_Warning
284			*/
285			public function testAppliedContentParsersWithBadReturn()
286			{
287			$input = [
288			'get' => [
289			'foo' => 'bar',
290			],
291			'server' => [
292			'REQUEST_METHOD' => 'delete',
293			'REMOTE_ADDR' => '0.0.0.0',
294			'HTTP_ACCEPT' => 'text/html',
295			'CONTENT_TYPE' => 'application/json',
296			],
297			];
298
299			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);
300
301			$builder->addContentParser('application/json', function () {
302			return null;
303			});
304
305			$instance = $builder->create($input);
306			$this->assertEquals('bar', $instance->getParameter('foo'));
307
308			}
309
310
311			/**
312			* @covers Fracture\Http\RequestBuilder::create
313			* @covers Fracture\Http\RequestBuilder::applyContentParsers
314			* @covers Fracture\Http\RequestBuilder::addContentParser
315			*/
316			public function testAppliedContentParsersWithMissingHeader()
317			{
318			$input = [
319			'get' => [],
320			'server' => [
321			'REQUEST_METHOD' => 'delete',
322			'REMOTE_ADDR' => '0.0.0.0',
323			'HTTP_ACCEPT' => 'text/html',
324			],
325			];
326
327			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);
328
329			$builder->addContentParser('application/json', function () {
330			return ['foo' => 'bar'];
331			});
332
333			$instance = $builder->create($input);
334			$this->assertEquals(null, $instance->getParameter('foo'));
335
336			}
337
338
339			/**
340			* @covers Fracture\Http\RequestBuilder::create
341			* @covers Fracture\Http\RequestBuilder::applyContentParsers
342			* @covers Fracture\Http\RequestBuilder::addContentParser
343			*/
344			public function testAppliedContentParsersWithHeader()
345			{
346			$input = [
347			'server' => [
348			'CONTENT_TYPE' => 'text/html;version=2',
349			],
350			];
351
352			$builder = $this->getMock('Fracture\Http\RequestBuilder', ['isCLI']);
353
354			$builder->addContentParser('text/html', function ($header) {
355			return ['foo' => $header->getParameter('version')];
356			});
357
358			$instance = $builder->create($input);
359			$this->assertEquals(2, $instance->getParameter('foo'));
360			}
361
362
363			/**
364			* @covers Fracture\Http\RequestBuilder::create
365			* @covers Fracture\Http\RequestBuilder::applyContentParsers
366			* @covers Fracture\Http\RequestBuilder::applyHeaders
367			*/
368			public function testIfAcceptHeaderApplied()
369			{
370			$input = [
371			'get' => [],
372			'server' => [
373			'REQUEST_METHOD' => 'post',
374			'REMOTE_ADDR' => '0.0.0.0',
375			'HTTP_ACCEPT' => 'text/html',
376			],
377			];
378
379			$builder = new RequestBuilder;
380			$instance = $builder->create($input);
381
382			$this->assertInstanceOf('Fracture\Http\Headers\Accept', $instance->getAcceptHeader());
383			}
384
385
386			/**
387			* @covers Fracture\Http\RequestBuilder::create
388			* @covers Fracture\Http\RequestBuilder::applyContentParsers
389			* @covers Fracture\Http\RequestBuilder::applyHeaders
390			*/
391			public function testIfContentTypeHeaderApplied()
392			{
393			$input = [
394			'get' => [],
395			'server' => [
396			'REQUEST_METHOD' => 'post',
397			'REMOTE_ADDR' => '0.0.0.0',
398			'CONTENT_TYPE' => 'application/json',
399			],
400			];
401
402
403			$builder = new RequestBuilder;
404			$instance = $builder->create($input);
405
406			$this->assertInstanceOf('Fracture\Http\Headers\ContentType', $instance->getContentTypeHeader());
407			}
408
409
410			/**
411			* @covers Fracture\Http\RequestBuilder::create
412			* @covers Fracture\Http\RequestBuilder::applyParams
413			*
414			* @covers Fracture\Http\RequestBuilder::alterParameters
415			*/
416			public function testWithCookieAddition()
417			{
418			$input = [
419			'cookies' => [
420			'name' => 'value'
421			]
422			];
423
424			$builder = new RequestBuilder;
425			$instance = $builder->create($input);
426
427			$this->assertInstanceOf('Fracture\Http\Cookie', $instance->getCookie('name'));
428			}
429			}
430

fracture / http

Push — master ( b5ed08...526d1c )

testAppliedContentParsersWithHeader() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like