RequestBuilderTest::testAppliedContentParsersWithHeader() - Code Metrics - fracture/http - Measure and Improve Code Quality continuously with Scrutinizer

testAppliedContentParsersWithHeader() A
last analyzed 2016-03-10 22:03 UTC

↳ Parent: RequestBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

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

<?php


namespace Fracture\Http;

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

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

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

fracture / http

testAppliedContentParsersWithHeader() A last analyzed 2016-03-10 22:03 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testAppliedContentParsersWithHeader() A
last analyzed 2016-03-10 22:03 UTC