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

Completed

Push — master ( 4adb8e...15c2d3 )

by Mārtiņš

created 2016-03-07 04:29 UTC

testOverrideRequestMethodWithParser() A

↳ Parent: RequestBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	21
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	21
rs	9.3142
cc	1
eloc	13
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']);

        $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']);

        $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 = new RequestBuilder;
        $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 = new RequestBuilder;
        $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 = new RequestBuilder;
        $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 = new RequestBuilder;
        $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 = new RequestBuilder;
        $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::addContentParser
     */
    public function testAppliedContentParsersWithRequest()
    {
        $input = [
            'get'    => [
                'test' => 'value',
            ],
            'server' => [
                'CONTENT_TYPE'    => 'text/html',
            ],
        ];

        $builder = new RequestBuilder;
        $builder->addContentParser('text/html', function ($header, $request) {
            return ['duplicate' => $request->getParameter('test')];
        });

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


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

        $builder = new RequestBuilder;
        $builder->addContentParser('text/html', function ($header, $request) {
            $method = $request->getParameter('_mark');
            $request->setMethod($method);
            return [];
        });

        $instance = $builder->create($input);
        $this->assertEquals('put', $instance->getMethod());
    }


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

        $builder = new RequestBuilder;
        $builder->addContentParser('*/*', function ($header, $request) {

            return ['called' => true];
        });

        $instance = $builder->create($input);
        $this->assertTrue($instance->getParameter('called'));
    }


    /**
     * @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->assertEquals('value', $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']);
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']);
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 = new RequestBuilder;
232			$builder->addContentParser('application/json', function () {
233			return ['foo' => 'bar'];
234			});
235
236			$instance = $builder->create($input);
237			$this->assertEquals('bar', $instance->getParameter('foo'));
238
239			}
240
241
242			/**
243			* @covers Fracture\Http\RequestBuilder::create
244			* @covers Fracture\Http\RequestBuilder::applyContentParsers
245			* @covers Fracture\Http\RequestBuilder::addContentParser
246			*
247			* @covers Fracture\Http\RequestBuilder::alterParameters
248			*/
249			public function testAppliedContentParsersOverridesPameters()
250			{
251			$input = [
252			'get' => [
253			'foo' => 'bar',
254			],
255			'server' => [
256			'REQUEST_METHOD' => 'delete',
257			'REMOTE_ADDR' => '0.0.0.0',
258			'HTTP_ACCEPT' => 'text/html',
259			'CONTENT_TYPE' => 'application/json',
260			],
261			];
262
263			$builder = new RequestBuilder;
264			$builder->addContentParser('application/json', function () {
265			return ['foo' => 'different'];
266			});
267
268			$instance = $builder->create($input);
269			$this->assertEquals('different', $instance->getParameter('foo'));
270
271			}
272
273
274			/**
275			* @covers Fracture\Http\RequestBuilder::create
276			* @covers Fracture\Http\RequestBuilder::applyContentParsers
277			* @covers Fracture\Http\RequestBuilder::addContentParser
278			*
279			* @covers Fracture\Http\RequestBuilder::alterParameters
280			*
281			* @expectedException PHPUnit_Framework_Error_Warning
282			*/
283			public function testAppliedContentParsersWithBadReturn()
284			{
285			$input = [
286			'get' => [
287			'foo' => 'bar',
288			],
289			'server' => [
290			'REQUEST_METHOD' => 'delete',
291			'REMOTE_ADDR' => '0.0.0.0',
292			'HTTP_ACCEPT' => 'text/html',
293			'CONTENT_TYPE' => 'application/json',
294			],
295			];
296
297			$builder = new RequestBuilder;
298			$builder->addContentParser('application/json', function () {
299			return null;
300			});
301
302			$instance = $builder->create($input);
303			$this->assertEquals('bar', $instance->getParameter('foo'));
304
305			}
306
307
308			/**
309			* @covers Fracture\Http\RequestBuilder::create
310			* @covers Fracture\Http\RequestBuilder::applyContentParsers
311			* @covers Fracture\Http\RequestBuilder::addContentParser
312			*/
313			public function testAppliedContentParsersWithMissingHeader()
314			{
315			$input = [
316			'get' => [],
317			'server' => [
318			'REQUEST_METHOD' => 'delete',
319			'REMOTE_ADDR' => '0.0.0.0',
320			'HTTP_ACCEPT' => 'text/html',
321			],
322			];
323
324			$builder = new RequestBuilder;
325			$builder->addContentParser('application/json', function () {
326			return ['foo' => 'bar'];
327			});
328
329			$instance = $builder->create($input);
330			$this->assertEquals(null, $instance->getParameter('foo'));
331
332			}
333
334
335			/**
336			* @covers Fracture\Http\RequestBuilder::create
337			* @covers Fracture\Http\RequestBuilder::applyContentParsers
338			* @covers Fracture\Http\RequestBuilder::addContentParser
339			*/
340			public function testAppliedContentParsersWithHeader()
341			{
342			$input = [
343			'server' => [
344			'CONTENT_TYPE' => 'text/html;version=2',
345			],
346			];
347
348			$builder = new RequestBuilder;
349			$builder->addContentParser('text/html', function ($header) {
350			return ['foo' => $header->getParameter('version')];
351			});
352
353			$instance = $builder->create($input);
354			$this->assertEquals(2, $instance->getParameter('foo'));
355			}
356
357
358			/**
359			* @covers Fracture\Http\RequestBuilder::create
360			* @covers Fracture\Http\RequestBuilder::applyContentParsers
361			* @covers Fracture\Http\RequestBuilder::addContentParser
362			*/
363			public function testAppliedContentParsersWithRequest()
364			{
365			$input = [
366			'get' => [
367			'test' => 'value',
368			],
369			'server' => [
370			'CONTENT_TYPE' => 'text/html',
371			],
372			];
373
374			$builder = new RequestBuilder;
375			$builder->addContentParser('text/html', function ($header, $request) {
376			return ['duplicate' => $request->getParameter('test')];
377			});
378
379			$instance = $builder->create($input);
380			$this->assertEquals('value', $instance->getParameter('duplicate'));
381			}
382
383
384			/**
385			* @covers Fracture\Http\RequestBuilder::create
386			* @covers Fracture\Http\RequestBuilder::applyContentParsers
387			* @covers Fracture\Http\RequestBuilder::addContentParser
388			*/
389			public function testOverrideRequestMethodWithParser()
390			{
391			$input = [
392			'get' => [
393			'_mark' => 'put',
394			],
395			'server' => [
396			'CONTENT_TYPE' => 'text/html',
397			],
398			];
399
400			$builder = new RequestBuilder;
401			$builder->addContentParser('text/html', function ($header, $request) {
402			$method = $request->getParameter('_mark');
403			$request->setMethod($method);
404			return [];
405			});
406
407			$instance = $builder->create($input);
408			$this->assertEquals('put', $instance->getMethod());
409			}
410
411
412			/**
413			* @covers Fracture\Http\RequestBuilder::create
414			* @covers Fracture\Http\RequestBuilder::applyContentParsers
415			* @covers Fracture\Http\RequestBuilder::addContentParser
416			*/
417			public function testAppliedParserForWildecard()
418			{
419			$input = [
420			'server' => [
421			'CONTENT_TYPE' => 'text/html',
422			],
423			];
424
425			$builder = new RequestBuilder;
426			$builder->addContentParser('/', function ($header, $request) {
			0 ignored issues – show Unused Code introduced 2016-03-07 04:25 UTC by Report Bug Copy Issue Report The parameter `$header` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2016-03-07 04:25 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
427			return ['called' => true];
428			});
429
430			$instance = $builder->create($input);
431			$this->assertTrue($instance->getParameter('called'));
432			}
433
434
435			/**
436			* @covers Fracture\Http\RequestBuilder::create
437			* @covers Fracture\Http\RequestBuilder::applyContentParsers
438			* @covers Fracture\Http\RequestBuilder::applyHeaders
439			*/
440			public function testIfAcceptHeaderApplied()
441			{
442			$input = [
443			'get' => [],
444			'server' => [
445			'REQUEST_METHOD' => 'post',
446			'REMOTE_ADDR' => '0.0.0.0',
447			'HTTP_ACCEPT' => 'text/html',
448			],
449			];
450
451			$builder = new RequestBuilder;
452			$instance = $builder->create($input);
453
454			$this->assertInstanceOf('Fracture\Http\Headers\Accept', $instance->getAcceptHeader());
455			}
456
457
458			/**
459			* @covers Fracture\Http\RequestBuilder::create
460			* @covers Fracture\Http\RequestBuilder::applyContentParsers
461			* @covers Fracture\Http\RequestBuilder::applyHeaders
462			*/
463			public function testIfContentTypeHeaderApplied()
464			{
465			$input = [
466			'get' => [],
467			'server' => [
468			'REQUEST_METHOD' => 'post',
469			'REMOTE_ADDR' => '0.0.0.0',
470			'CONTENT_TYPE' => 'application/json',
471			],
472			];
473
474
475			$builder = new RequestBuilder;
476			$instance = $builder->create($input);
477
478			$this->assertInstanceOf('Fracture\Http\Headers\ContentType', $instance->getContentTypeHeader());
479			}
480
481
482			/**
483			* @covers Fracture\Http\RequestBuilder::create
484			* @covers Fracture\Http\RequestBuilder::applyParams
485			*
486			* @covers Fracture\Http\RequestBuilder::alterParameters
487			*/
488			public function testWithCookieAddition()
489			{
490			$input = [
491			'cookies' => [
492			'name' => 'value'
493			]
494			];
495
496			$builder = new RequestBuilder;
497			$instance = $builder->create($input);
498
499			$this->assertEquals('value', $instance->getCookie('name'));
500			}
501			}
502

fracture / http

Push — master ( 4adb8e...15c2d3 )

testOverrideRequestMethodWithParser() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like