RequestTest::testMethodGetterForPreparedRequestWithCustomMethodAndOverride() - 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

testMethodGetterForPreparedRequestWithCustomMethodAndOverride() A

↳ Parent: RequestTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	8
rs	9.4285
cc	1
eloc	5
nc	1
nop	0

<?php


namespace Fracture\Http;

use Exception;
use ReflectionClass;
use PHPUnit_Framework_TestCase;

class RequestTest extends PHPUnit_Framework_TestCase
{

    /**
     * @covers Fracture\Http\Request::setMethod
     * @covers Fracture\Http\Request::getMethod
     */
    public function testMethodGetterForUnpreparedRequest()
    {
        $request = new Request;
        $request->setMethod('GET');

        $this->assertEquals('get', $request->getMethod());
    }


    /**
     * @covers Fracture\Http\Request::setMethod
     * @covers Fracture\Http\Request::getMethod
     * @covers Fracture\Http\Request::prepare
     *
     * @depends testMethodGetterForUnpreparedRequest
     */
    public function testMethodGetterForPreparedRequest()
    {
        $request = new Request;
        $request->setMethod('GET');
        $request->prepare();

        $this->assertEquals('get', $request->getMethod());
    }


    /**
     * @covers Fracture\Http\Request::setParameters
     * @covers Fracture\Http\Request::getMethod
     */
    public function testMethodGetterForUnpreparedRequestWithCustomMethod()
    {
        $request = new Request;
        $request->setParameters(['_method' => 'PUT']);

        $this->assertNull($request->getMethod());
    }


    /**
     * @covers Fracture\Http\Request::getParameter
     */
    public function testParameterGetterWhenNoValue()
    {
        $request = new Request;
        $this->assertNull($request->getParameter('foobar'));
    }


    /**
     * @covers Fracture\Http\Request::setParameters
     * @covers Fracture\Http\Request::getParameter
     */
    public function testParameterGetterWhenSetValue()
    {
        $request = new Request;
        $request->setParameters(['param' => 'value']);
        $this->assertEquals('value', $request->getParameter('param'));
    }


    /**
     * @covers Fracture\Http\Request::setParameters
     * @covers Fracture\Http\Request::getParameter
     */
    public function testParameterGetterWithDifferentSetter()
    {
        $request = new Request;
        $request->setParameters(['param' => 'value']);
        $this->assertNull($request->getParameter('different'));
    }


    /**
     * @covers Fracture\Http\Request::setParameters
     */
    public function testDuplicateKeysAssignedToParameters()
    {
        set_error_handler([$this, 'handleWarnedMethod'], \E_USER_WARNING);

        $request = new Request;
        $request->setParameters(['alpha' => 'foo']);
        $request->setParameters(['alpha' => 'foo']);

        restore_error_handler();
    }

    public function handleWarnedMethod($errno, $errstr)
    {
         $this->assertEquals(\E_USER_WARNING, $errno);
    }



    /**
     * @dataProvider provideCleanUriList
     * @covers Fracture\Http\Request::setUri
     * @covers Fracture\Http\Request::getUri
     *
     * @covers Fracture\Http\Request::sanitizeUri
     * @covers Fracture\Http\Request::resolveUri
     * @covers Fracture\Http\Request::adjustUriSegments
     */
    public function testValidCleanUri($uri, $expected)
    {
        $request = new Request;
        $request->setUri($uri);

        $this->assertEquals($expected, $request->getUri());
    }


    public function provideCleanUriList()
    {
        return include FIXTURE_PATH . '/uri-variations.php';
    }


    /**
     * @covers Fracture\Http\Request::setAddress
     * @covers Fracture\Http\Request::getAddress
     */
    public function testValidAddress()
    {
        $request = new Request;
        $request->setAddress('127.0.0.1');

        $this->assertEquals('127.0.0.1', $request->getAddress());
    }

    /**
     * @covers Fracture\Http\Request::setAddress
     * @covers Fracture\Http\Request::getAddress
     */
    public function testInvalidAddress()
    {
        $request = new Request;
        $request->setAddress('a.b.c.d.e');

        $this->assertNull($request->getAddress());
    }


    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::getUpload
     */
    public function testGatheringUploadsWithoutFiles()
    {
        $instance = new Request;
        $this->assertNull($instance->getUpload('foobar'));
    }


    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::setUploadedFiles
     * @covers Fracture\Http\Request::getUpload
     */
    public function testAdditionOfUploadsWithoutBuilder()
    {
        $input = [
            'alpha' => [
                'name'      => 'simple.png',
                'type'      => 'image/png',
                'tmp_name'  => FIXTURE_PATH . '/files/simple.png',
                'error'     => 0,
                'size'      => 74,
            ],
        ];

        $instance = new Request;
        $instance->setUploadedFiles($input);

        $this->assertEquals($input[ 'alpha' ], $instance->getUpload('alpha'));
    }


    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::setUploadedFiles
     */
    public function testCallOnFileBagBuilderWhenSettingUploads()
    {
        $input = [
            'alpha' => [
                'name'      => 'simple.png',
                'type'      => 'image/png',
                'tmp_name'  => FIXTURE_PATH . '/files/simple.png',
                'error'     => 0,
                'size'      => 74,
            ],
        ];

        $builder = $this->getMock(
            'Fracture\Http\FileBagBuilder',
            ['create'],
            [
                'uploadedFileBuilder' => $this->getMock('Fracture\Http\UploadedFileBuilder')
            ]
        );
        $builder->expects($this->once())
                ->method('create')
                ->with($this->equalTo($input));

        $instance = new Request($builder);
        $instance->setUploadedFiles($input);
    }


    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::setAcceptHeader
     * @covers Fracture\Http\Request::getAcceptHeader
     */
    public function testGetterAndSetterForAcceptHeader()
    {
        $request = new Request;
        $header = $this->getMock('Fracture\Http\Headers\Accept');
        $request->setAcceptHeader($header);
        $this->assertEquals($header, $request->getAcceptHeader());
    }



    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::setContentTypeHeader
     * @covers Fracture\Http\Request::getContentTypeHeader
     */
    public function testGetterAndSetterForContentTypeHeader()
    {
        $request = new Request;
        $header = $this->getMock('Fracture\Http\Headers\ContentType');
        $request->setContentTypeHeader($header);
        $this->assertEquals($header, $request->getContentTypeHeader());
    }


    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::setAcceptHeader
     * @covers Fracture\Http\Request::getAcceptHeader
     * @covers Fracture\Http\Request::getResolvedAcceptHeader
     */
    public function testGetterAndSetterForAcceptHeaderWithManualAcceotValue()
    {
        $request = new Request;
        $header = $this->getMock('Fracture\Http\Headers\Accept', ['prepare', 'setValue']);

        $header->expects($this->once())
               ->method('prepare');

        $header->expects($this->once())
               ->method('setValue')
               ->with($this->equalTo('application/json'));


        $request->setAcceptHeader($header);

        $request->setParameters(['_accept' => 'application/json']);
        $request->prepare();
    }


    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::getCookie
     * @covers Fracture\Http\Request::addCookie
     */
    public function testAddedCookie()
    {
        $request = new Request;
        $this->assertNull($request->getCookie('alpha'));

        $request->addCookie('alpha', 'value');
        $this->assertEquals('value', $request->getCookie('alpha'));
    }

    /**
     * @covers Fracture\Http\Request::__construct
     * @covers Fracture\Http\Request::addCookie
     * @covers Fracture\Http\Request::getAllCookies
     */
    public function testAllCookiesReturned()
    {
        $request = new Request;
        $this->assertEmpty($request->getAllCookies());

        $request->addCookie('first', 'foo');
        $request->addCookie('second', 'bar');

        $this->assertEquals([
            'first' => 'foo',
            'second' => 'bar',
        ], $request->getAllCookies());
    }
}


1			<?php
2
3
4			namespace Fracture\Http;
5
6			use Exception;
7			use ReflectionClass;
8			use PHPUnit_Framework_TestCase;
9
10			class RequestTest extends PHPUnit_Framework_TestCase
11			{
12
13			/**
14			* @covers Fracture\Http\Request::setMethod
15			* @covers Fracture\Http\Request::getMethod
16			*/
17			public function testMethodGetterForUnpreparedRequest()
18			{
19			$request = new Request;
20			$request->setMethod('GET');
21
22			$this->assertEquals('get', $request->getMethod());
23			}
24
25
26			/**
27			* @covers Fracture\Http\Request::setMethod
28			* @covers Fracture\Http\Request::getMethod
29			* @covers Fracture\Http\Request::prepare
30			*
31			* @depends testMethodGetterForUnpreparedRequest
32			*/
33			public function testMethodGetterForPreparedRequest()
34			{
35			$request = new Request;
36			$request->setMethod('GET');
37			$request->prepare();
38
39			$this->assertEquals('get', $request->getMethod());
40			}
41
42
43			/**
44			* @covers Fracture\Http\Request::setParameters
45			* @covers Fracture\Http\Request::getMethod
46			*/
47			public function testMethodGetterForUnpreparedRequestWithCustomMethod()
48			{
49			$request = new Request;
50			$request->setParameters(['_method' => 'PUT']);
51
52			$this->assertNull($request->getMethod());
53			}
54
55
56			/**
57			* @covers Fracture\Http\Request::getParameter
58			*/
59			public function testParameterGetterWhenNoValue()
60			{
61			$request = new Request;
62			$this->assertNull($request->getParameter('foobar'));
63			}
64
65
66			/**
67			* @covers Fracture\Http\Request::setParameters
68			* @covers Fracture\Http\Request::getParameter
69			*/
70			public function testParameterGetterWhenSetValue()
71			{
72			$request = new Request;
73			$request->setParameters(['param' => 'value']);
74			$this->assertEquals('value', $request->getParameter('param'));
75			}
76
77
78			/**
79			* @covers Fracture\Http\Request::setParameters
80			* @covers Fracture\Http\Request::getParameter
81			*/
82			public function testParameterGetterWithDifferentSetter()
83			{
84			$request = new Request;
85			$request->setParameters(['param' => 'value']);
86			$this->assertNull($request->getParameter('different'));
87			}
88
89
90			/**
91			* @covers Fracture\Http\Request::setParameters
92			*/
93			public function testDuplicateKeysAssignedToParameters()
94			{
95			set_error_handler([$this, 'handleWarnedMethod'], \E_USER_WARNING);
96
97			$request = new Request;
98			$request->setParameters(['alpha' => 'foo']);
99			$request->setParameters(['alpha' => 'foo']);
100
101			restore_error_handler();
102			}
103
104			public function handleWarnedMethod($errno, $errstr)
105			{
106			$this->assertEquals(\E_USER_WARNING, $errno);
107			}
108
109
110
111			/**
112			* @dataProvider provideCleanUriList
113			* @covers Fracture\Http\Request::setUri
114			* @covers Fracture\Http\Request::getUri
115			*
116			* @covers Fracture\Http\Request::sanitizeUri
117			* @covers Fracture\Http\Request::resolveUri
118			* @covers Fracture\Http\Request::adjustUriSegments
119			*/
120			public function testValidCleanUri($uri, $expected)
121			{
122			$request = new Request;
123			$request->setUri($uri);
124
125			$this->assertEquals($expected, $request->getUri());
126			}
127
128
129			public function provideCleanUriList()
130			{
131			return include FIXTURE_PATH . '/uri-variations.php';
132			}
133
134
135			/**
136			* @covers Fracture\Http\Request::setAddress
137			* @covers Fracture\Http\Request::getAddress
138			*/
139			public function testValidAddress()
140			{
141			$request = new Request;
142			$request->setAddress('127.0.0.1');
143
144			$this->assertEquals('127.0.0.1', $request->getAddress());
145			}
146
147			/**
148			* @covers Fracture\Http\Request::setAddress
149			* @covers Fracture\Http\Request::getAddress
150			*/
151			public function testInvalidAddress()
152			{
153			$request = new Request;
154			$request->setAddress('a.b.c.d.e');
155
156			$this->assertNull($request->getAddress());
157			}
158
159
160			/**
161			* @covers Fracture\Http\Request::__construct
162			* @covers Fracture\Http\Request::getUpload
163			*/
164			public function testGatheringUploadsWithoutFiles()
165			{
166			$instance = new Request;
167			$this->assertNull($instance->getUpload('foobar'));
168			}
169
170
171			/**
172			* @covers Fracture\Http\Request::__construct
173			* @covers Fracture\Http\Request::setUploadedFiles
174			* @covers Fracture\Http\Request::getUpload
175			*/
176			public function testAdditionOfUploadsWithoutBuilder()
177			{
178			$input = [
179			'alpha' => [
180			'name' => 'simple.png',
181			'type' => 'image/png',
182			'tmp_name' => FIXTURE_PATH . '/files/simple.png',
183			'error' => 0,
184			'size' => 74,
185			],
186			];
187
188			$instance = new Request;
189			$instance->setUploadedFiles($input);
190
191			$this->assertEquals($input[ 'alpha' ], $instance->getUpload('alpha'));
192			}
193
194
195			/**
196			* @covers Fracture\Http\Request::__construct
197			* @covers Fracture\Http\Request::setUploadedFiles
198			*/
199			public function testCallOnFileBagBuilderWhenSettingUploads()
200			{
201			$input = [
202			'alpha' => [
203			'name' => 'simple.png',
204			'type' => 'image/png',
205			'tmp_name' => FIXTURE_PATH . '/files/simple.png',
206			'error' => 0,
207			'size' => 74,
208			],
209			];
210
211			$builder = $this->getMock(
212			'Fracture\Http\FileBagBuilder',
213			['create'],
214			[
215			'uploadedFileBuilder' => $this->getMock('Fracture\Http\UploadedFileBuilder')
216			]
217			);
218			$builder->expects($this->once())
219			->method('create')
220			->with($this->equalTo($input));
221
222			$instance = new Request($builder);
223			$instance->setUploadedFiles($input);
224			}
225
226
227			/**
228			* @covers Fracture\Http\Request::__construct
229			* @covers Fracture\Http\Request::setAcceptHeader
230			* @covers Fracture\Http\Request::getAcceptHeader
231			*/
232			public function testGetterAndSetterForAcceptHeader()
233			{
234			$request = new Request;
235			$header = $this->getMock('Fracture\Http\Headers\Accept');
236			$request->setAcceptHeader($header);
237			$this->assertEquals($header, $request->getAcceptHeader());
238			}
239
240
241
242			/**
243			* @covers Fracture\Http\Request::__construct
244			* @covers Fracture\Http\Request::setContentTypeHeader
245			* @covers Fracture\Http\Request::getContentTypeHeader
246			*/
247			public function testGetterAndSetterForContentTypeHeader()
248			{
249			$request = new Request;
250			$header = $this->getMock('Fracture\Http\Headers\ContentType');
251			$request->setContentTypeHeader($header);
252			$this->assertEquals($header, $request->getContentTypeHeader());
253			}
254
255
256			/**
257			* @covers Fracture\Http\Request::__construct
258			* @covers Fracture\Http\Request::setAcceptHeader
259			* @covers Fracture\Http\Request::getAcceptHeader
260			* @covers Fracture\Http\Request::getResolvedAcceptHeader
261			*/
262			public function testGetterAndSetterForAcceptHeaderWithManualAcceotValue()
263			{
264			$request = new Request;
265			$header = $this->getMock('Fracture\Http\Headers\Accept', ['prepare', 'setValue']);
266
267			$header->expects($this->once())
268			->method('prepare');
269
270			$header->expects($this->once())
271			->method('setValue')
272			->with($this->equalTo('application/json'));
273
274
275			$request->setAcceptHeader($header);
276
277			$request->setParameters(['_accept' => 'application/json']);
278			$request->prepare();
279			}
280
281
282			/**
283			* @covers Fracture\Http\Request::__construct
284			* @covers Fracture\Http\Request::getCookie
285			* @covers Fracture\Http\Request::addCookie
286			*/
287			public function testAddedCookie()
288			{
289			$request = new Request;
290			$this->assertNull($request->getCookie('alpha'));
291
292			$request->addCookie('alpha', 'value');
293			$this->assertEquals('value', $request->getCookie('alpha'));
294			}
295
296			/**
297			* @covers Fracture\Http\Request::__construct
298			* @covers Fracture\Http\Request::addCookie
299			* @covers Fracture\Http\Request::getAllCookies
300			*/
301			public function testAllCookiesReturned()
302			{
303			$request = new Request;
304			$this->assertEmpty($request->getAllCookies());
305
306			$request->addCookie('first', 'foo');
307			$request->addCookie('second', 'bar');
308
309			$this->assertEquals([
310			'first' => 'foo',
311			'second' => 'bar',
312			], $request->getAllCookies());
313			}
314			}
315

fracture / http

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

testMethodGetterForPreparedRequestWithCustomMethodAndOverride() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like