RequestTest::testMethodGetterForRequest() - Code Metrics - Inspection of "Various minor internal changes and documentation" - fracture/http - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

by Mārtiņš

created 2016-03-10 21:58 UTC

RequestTest::testMethodGetterForRequest() A

↳ Parent: RequestTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	7
rs	9.4285
cc	1
eloc	4
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 testMethodGetterForRequest()
    {
        $request = new Request;
        $request->setMethod('GET');

        $this->assertEquals('get', $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::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'));
    }
}


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 testMethodGetterForRequest()
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::getParameter
28			*/
29			public function testParameterGetterWhenNoValue()
30			{
31			$request = new Request;
32			$this->assertNull($request->getParameter('foobar'));
33			}
34
35
36			/**
37			* @covers Fracture\Http\Request::setParameters
38			* @covers Fracture\Http\Request::getParameter
39			*/
40			public function testParameterGetterWhenSetValue()
41			{
42			$request = new Request;
43			$request->setParameters(['param' => 'value']);
44			$this->assertEquals('value', $request->getParameter('param'));
45			}
46
47
48			/**
49			* @covers Fracture\Http\Request::setParameters
50			* @covers Fracture\Http\Request::getParameter
51			*/
52			public function testParameterGetterWithDifferentSetter()
53			{
54			$request = new Request;
55			$request->setParameters(['param' => 'value']);
56			$this->assertNull($request->getParameter('different'));
57			}
58
59
60			/**
61			* @covers Fracture\Http\Request::setParameters
62			*/
63			public function testDuplicateKeysAssignedToParameters()
64			{
65			set_error_handler([$this, 'handleWarnedMethod'], \E_USER_WARNING);
66
67			$request = new Request;
68			$request->setParameters(['alpha' => 'foo']);
69			$request->setParameters(['alpha' => 'foo']);
70
71			restore_error_handler();
72			}
73
74			public function handleWarnedMethod($errno, $errstr)
75			{
76			$this->assertEquals(\E_USER_WARNING, $errno);
77			}
78
79
80
81			/**
82			* @dataProvider provideCleanUriList
83			* @covers Fracture\Http\Request::setUri
84			* @covers Fracture\Http\Request::getUri
85			*
86			* @covers Fracture\Http\Request::sanitizeUri
87			* @covers Fracture\Http\Request::resolveUri
88			* @covers Fracture\Http\Request::adjustUriSegments
89			*/
90			public function testValidCleanUri($uri, $expected)
91			{
92			$request = new Request;
93			$request->setUri($uri);
94
95			$this->assertEquals($expected, $request->getUri());
96			}
97
98
99			public function provideCleanUriList()
100			{
101			return include FIXTURE_PATH . '/uri-variations.php';
102			}
103
104
105			/**
106			* @covers Fracture\Http\Request::setAddress
107			* @covers Fracture\Http\Request::getAddress
108			*/
109			public function testValidAddress()
110			{
111			$request = new Request;
112			$request->setAddress('127.0.0.1');
113
114			$this->assertEquals('127.0.0.1', $request->getAddress());
115			}
116
117			/**
118			* @covers Fracture\Http\Request::setAddress
119			* @covers Fracture\Http\Request::getAddress
120			*/
121			public function testInvalidAddress()
122			{
123			$request = new Request;
124			$request->setAddress('a.b.c.d.e');
125
126			$this->assertNull($request->getAddress());
127			}
128
129
130			/**
131			* @covers Fracture\Http\Request::__construct
132			* @covers Fracture\Http\Request::getUpload
133			*/
134			public function testGatheringUploadsWithoutFiles()
135			{
136			$instance = new Request;
137			$this->assertNull($instance->getUpload('foobar'));
138			}
139
140
141			/**
142			* @covers Fracture\Http\Request::__construct
143			* @covers Fracture\Http\Request::setUploadedFiles
144			* @covers Fracture\Http\Request::getUpload
145			*/
146			public function testAdditionOfUploadsWithoutBuilder()
147			{
148			$input = [
149			'alpha' => [
150			'name' => 'simple.png',
151			'type' => 'image/png',
152			'tmp_name' => FIXTURE_PATH . '/files/simple.png',
153			'error' => 0,
154			'size' => 74,
155			],
156			];
157
158			$instance = new Request;
159			$instance->setUploadedFiles($input);
160
161			$this->assertEquals($input[ 'alpha' ], $instance->getUpload('alpha'));
162			}
163
164
165			/**
166			* @covers Fracture\Http\Request::__construct
167			* @covers Fracture\Http\Request::setUploadedFiles
168			*/
169			public function testCallOnFileBagBuilderWhenSettingUploads()
170			{
171			$input = [
172			'alpha' => [
173			'name' => 'simple.png',
174			'type' => 'image/png',
175			'tmp_name' => FIXTURE_PATH . '/files/simple.png',
176			'error' => 0,
177			'size' => 74,
178			],
179			];
180
181			$builder = $this->getMock(
182			'Fracture\Http\FileBagBuilder',
183			['create'],
184			[
185			'uploadedFileBuilder' => $this->getMock('Fracture\Http\UploadedFileBuilder')
186			]
187			);
188			$builder->expects($this->once())
189			->method('create')
190			->with($this->equalTo($input));
191
192			$instance = new Request($builder);
193			$instance->setUploadedFiles($input);
194			}
195
196
197			/**
198			* @covers Fracture\Http\Request::__construct
199			* @covers Fracture\Http\Request::setAcceptHeader
200			* @covers Fracture\Http\Request::getAcceptHeader
201			*/
202			public function testGetterAndSetterForAcceptHeader()
203			{
204			$request = new Request;
205			$header = $this->getMock('Fracture\Http\Headers\Accept');
206			$request->setAcceptHeader($header);
207			$this->assertEquals($header, $request->getAcceptHeader());
208			}
209
210
211
212			/**
213			* @covers Fracture\Http\Request::__construct
214			* @covers Fracture\Http\Request::setContentTypeHeader
215			* @covers Fracture\Http\Request::getContentTypeHeader
216			*/
217			public function testGetterAndSetterForContentTypeHeader()
218			{
219			$request = new Request;
220			$header = $this->getMock('Fracture\Http\Headers\ContentType');
221			$request->setContentTypeHeader($header);
222			$this->assertEquals($header, $request->getContentTypeHeader());
223			}
224
225
226			/**
227			* @covers Fracture\Http\Request::__construct
228			* @covers Fracture\Http\Request::getCookie
229			* @covers Fracture\Http\Request::addCookie
230			*/
231			public function testAddedCookie()
232			{
233			$request = new Request;
234			$this->assertNull($request->getCookie('alpha'));
235
236			$request->addCookie('alpha', 'value');
237			$this->assertEquals('value', $request->getCookie('alpha'));
238			}
239			}
240

fracture / http

Pull Request — master (#10)

RequestTest::testMethodGetterForRequest() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like