FileBagBuilderTest - Code Metrics - fracture/http - Measure and Improve Code Quality continuously with Scrutinizer

FileBagBuilderTest A
last analyzed 2016-03-10 22:03 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
wmc	6
c	4
b	0
f	0
lcom	0
cbo	1
dl	0
loc	195
rs	10

6 Methods

Rating	Name	Size	Complexity
A	testCreatedDummyElement()	9	1
A	testWithInvalidInput()	21	1
A	testWithInvalidMalformedUpload()	21	1
B	testSingleFileUpload()	30	1
B	testTwoFilesUploadedFromDiffrentInputs()	39	1
B	testTwoFilesUploadedFromInputWithSameName()	31	1

<?php


namespace Fracture\Http;

use Exception;
use ReflectionClass;
use PHPUnit_Framework_TestCase;

class FileBagBuilderTest extends PHPUnit_Framework_TestCase
{

    /**
     * @covers Fracture\Http\FileBagBuilder::__construct
     * @covers Fracture\Http\FileBagBuilder::create
     * @covers Fracture\Http\FileBagBuilder::createItem
     */
    public function testCreatedDummyElement()
    {
        $builder = $this->getMock('Fracture\Http\UploadedFileBuilder');

        $instance = new FileBagBuilder($builder);
        $object = $instance->create([]);

        $this->assertInstanceOf('Fracture\Http\FileBag', $object);
    }


    /**
     * @covers Fracture\Http\FileBagBuilder::__construct
     * @covers Fracture\Http\FileBagBuilder::create
     * @covers Fracture\Http\FileBagBuilder::createItem
     */
    public function testWithInvalidInput()
    {
        $input = [ 'foo' => 'bar' ];

        $response  = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
        $response->expects($this->once())
                 ->method('isValid')
                 ->will($this->returnValue(false));


        $builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
        $builder->expects($this->once())
                ->method('create')
                ->will($this->returnValue($response));


        $instance = new FileBagBuilder($builder);

        $object = $instance->create($input);
        $this->assertInstanceOf('Fracture\Http\FileBag', $object);
    }


    /**
     * @covers Fracture\Http\FileBagBuilder::__construct
     * @covers Fracture\Http\FileBagBuilder::create
     * @covers Fracture\Http\FileBagBuilder::createItem
     */
    public function testWithInvalidMalformedUpload()
    {
        $input = ['foo' => ['bar']];

        $response  = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
        $response->expects($this->once())
                 ->method('isValid')
                 ->will($this->returnValue(false));


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

        $instance = new FileBagBuilder($builder);

        $object = $instance->create($input);
        $this->assertInstanceOf('Fracture\Http\FileBag', $object);
    }

    /**
     * @covers Fracture\Http\FileBagBuilder::__construct
     * @covers Fracture\Http\FileBagBuilder::create
     * @covers Fracture\Http\FileBagBuilder::createItem
     */
    public function testSingleFileUpload()
    {
        $input = [
            'alpha' => [
                'name'      => 'simple.png',
                'type'      => 'image/png',
                'tmp_name'  => FIXTURE_PATH . '/file-simple.png',
                'error'     => 0,
                'size'      => 74,
            ],
        ];

        $response  = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
        $response->expects($this->once())
                 ->method('isValid')
                 ->will($this->returnValue(true));


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

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

        $this->assertInstanceOf('Fracture\Http\FileBag', $object);
        $this->assertInstanceOf('Fracture\Http\UploadedFile', $object['alpha']);
    }


    /**
     * @covers Fracture\Http\FileBagBuilder::__construct
     * @covers Fracture\Http\FileBagBuilder::create
     * @covers Fracture\Http\FileBagBuilder::createItem
     */
    public function testTwoFilesUploadedFromDiffrentInputs()
    {
        $input = [
            'alpha' => [
                'name'      => 'simple.png',
                'type'      => 'image/png',
                'tmp_name'  => FIXTURE_PATH . '/file-simple.png',
                'error'     => 0,
                'size'      => 74,
            ],
            'beta' => [
                'name'      => 'no-extension',
                'type'      => 'application/octet-stream',
                'tmp_name'  => FIXTURE_PATH . '/file-tempname',
                'error'     => 0,
                'size'      => 75,
            ],
        ];

        $alpha  = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
        $alpha->expects($this->once())
              ->method('isValid')
              ->will($this->returnValue(true));

        $beta  = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
        $beta->expects($this->once())
             ->method('isValid')
             ->will($this->returnValue(true));

        $builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
        $builder->expects($this->exactly(2))
                ->method('create')
                ->will($this->onConsecutiveCalls($alpha, $beta));

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

        $this->assertInstanceOf('Fracture\Http\FileBag', $object);
    }


    /**
     * @covers Fracture\Http\FileBagBuilder::__construct
     * @covers Fracture\Http\FileBagBuilder::create
     * @covers Fracture\Http\FileBagBuilder::createItem
     * @covers Fracture\Http\FileBagBuilder::createFromList
     */
    public function testTwoFilesUploadedFromInputWithSameName()
    {
        $input = [
            'alpha' => [
                'name'      => ['tempname', 'simple.png'],
                'type'      => ['application/octet-stream', 'image/png'],
                'tmp_name'  => [FIXTURE_PATH . '/file-tempname', FIXTURE_PATH . '/file-simple.png'],
                'error'     => [0, 0],
                'size'      => [75, 74],
            ],
        ];

        $response  = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
        $response->expects($this->exactly(2))
                 ->method('isValid')
                 ->will($this->returnValue(true));


        $builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
        $builder->expects($this->exactly(2))
                ->method('create')
                ->will($this->returnValue($response));

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

        $this->assertInstanceOf('Fracture\Http\FileBag', $object);
        $this->assertInstanceOf('Fracture\Http\FileBag', $object['alpha']);
        $this->assertInstanceOf('Fracture\Http\UploadedFile', $object['alpha'][0]);
        $this->assertInstanceOf('Fracture\Http\UploadedFile', $object['alpha'][1]);
    }
}


1			<?php
2
3
4			namespace Fracture\Http;
5
6			use Exception;
7			use ReflectionClass;
8			use PHPUnit_Framework_TestCase;
9
10			class FileBagBuilderTest extends PHPUnit_Framework_TestCase
11			{
12
13			/**
14			* @covers Fracture\Http\FileBagBuilder::__construct
15			* @covers Fracture\Http\FileBagBuilder::create
16			* @covers Fracture\Http\FileBagBuilder::createItem
17			*/
18			public function testCreatedDummyElement()
19			{
20			$builder = $this->getMock('Fracture\Http\UploadedFileBuilder');
21
22			$instance = new FileBagBuilder($builder);
23			$object = $instance->create([]);
24
25			$this->assertInstanceOf('Fracture\Http\FileBag', $object);
26			}
27
28
29			/**
30			* @covers Fracture\Http\FileBagBuilder::__construct
31			* @covers Fracture\Http\FileBagBuilder::create
32			* @covers Fracture\Http\FileBagBuilder::createItem
33			*/
34			public function testWithInvalidInput()
35			{
36			$input = [ 'foo' => 'bar' ];
37
38			$response = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
39			$response->expects($this->once())
40			->method('isValid')
41			->will($this->returnValue(false));
42
43
44			$builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
45			$builder->expects($this->once())
46			->method('create')
47			->will($this->returnValue($response));
48
49
50			$instance = new FileBagBuilder($builder);
51
52			$object = $instance->create($input);
53			$this->assertInstanceOf('Fracture\Http\FileBag', $object);
54			}
55
56
57			/**
58			* @covers Fracture\Http\FileBagBuilder::__construct
59			* @covers Fracture\Http\FileBagBuilder::create
60			* @covers Fracture\Http\FileBagBuilder::createItem
61			*/
62			public function testWithInvalidMalformedUpload()
63			{
64			$input = ['foo' => ['bar']];
65
66			$response = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
67			$response->expects($this->once())
68			->method('isValid')
69			->will($this->returnValue(false));
70
71
72			$builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
73			$builder->expects($this->once())
74			->method('create')
75			->with($this->equalTo($input['foo']))
76			->will($this->returnValue($response));
77
78			$instance = new FileBagBuilder($builder);
79
80			$object = $instance->create($input);
81			$this->assertInstanceOf('Fracture\Http\FileBag', $object);
82			}
83
84			/**
85			* @covers Fracture\Http\FileBagBuilder::__construct
86			* @covers Fracture\Http\FileBagBuilder::create
87			* @covers Fracture\Http\FileBagBuilder::createItem
88			*/
89			public function testSingleFileUpload()
90			{
91			$input = [
92			'alpha' => [
93			'name' => 'simple.png',
94			'type' => 'image/png',
95			'tmp_name' => FIXTURE_PATH . '/file-simple.png',
96			'error' => 0,
97			'size' => 74,
98			],
99			];
100
101			$response = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
102			$response->expects($this->once())
103			->method('isValid')
104			->will($this->returnValue(true));
105
106
107			$builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
108			$builder->expects($this->once())
109			->method('create')
110			->with($this->equalTo($input['alpha']))
111			->will($this->returnValue($response));
112
113			$instance = new FileBagBuilder($builder);
114			$object = $instance->create($input);
115
116			$this->assertInstanceOf('Fracture\Http\FileBag', $object);
117			$this->assertInstanceOf('Fracture\Http\UploadedFile', $object['alpha']);
118			}
119
120
121			/**
122			* @covers Fracture\Http\FileBagBuilder::__construct
123			* @covers Fracture\Http\FileBagBuilder::create
124			* @covers Fracture\Http\FileBagBuilder::createItem
125			*/
126			public function testTwoFilesUploadedFromDiffrentInputs()
127			{
128			$input = [
129			'alpha' => [
130			'name' => 'simple.png',
131			'type' => 'image/png',
132			'tmp_name' => FIXTURE_PATH . '/file-simple.png',
133			'error' => 0,
134			'size' => 74,
135			],
136			'beta' => [
137			'name' => 'no-extension',
138			'type' => 'application/octet-stream',
139			'tmp_name' => FIXTURE_PATH . '/file-tempname',
140			'error' => 0,
141			'size' => 75,
142			],
143			];
144
145			$alpha = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
146			$alpha->expects($this->once())
147			->method('isValid')
148			->will($this->returnValue(true));
149
150			$beta = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
151			$beta->expects($this->once())
152			->method('isValid')
153			->will($this->returnValue(true));
154
155			$builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
156			$builder->expects($this->exactly(2))
157			->method('create')
158			->will($this->onConsecutiveCalls($alpha, $beta));
159
160			$instance = new FileBagBuilder($builder);
161			$object = $instance->create($input);
162
163			$this->assertInstanceOf('Fracture\Http\FileBag', $object);
164			}
165
166
167			/**
168			* @covers Fracture\Http\FileBagBuilder::__construct
169			* @covers Fracture\Http\FileBagBuilder::create
170			* @covers Fracture\Http\FileBagBuilder::createItem
171			* @covers Fracture\Http\FileBagBuilder::createFromList
172			*/
173			public function testTwoFilesUploadedFromInputWithSameName()
174			{
175			$input = [
176			'alpha' => [
177			'name' => ['tempname', 'simple.png'],
178			'type' => ['application/octet-stream', 'image/png'],
179			'tmp_name' => [FIXTURE_PATH . '/file-tempname', FIXTURE_PATH . '/file-simple.png'],
180			'error' => [0, 0],
181			'size' => [75, 74],
182			],
183			];
184
185			$response = $this->getMock('Fracture\Http\UploadedFile', ['isValid'], ['foo' => 'bar']);
186			$response->expects($this->exactly(2))
187			->method('isValid')
188			->will($this->returnValue(true));
189
190
191			$builder = $this->getMock('Fracture\Http\UploadedFileBuilder', ['create']);
192			$builder->expects($this->exactly(2))
193			->method('create')
194			->will($this->returnValue($response));
195
196			$instance = new FileBagBuilder($builder);
197			$object = $instance->create($input);
198
199			$this->assertInstanceOf('Fracture\Http\FileBag', $object);
200			$this->assertInstanceOf('Fracture\Http\FileBag', $object['alpha']);
201			$this->assertInstanceOf('Fracture\Http\UploadedFile', $object['alpha'][0]);
202			$this->assertInstanceOf('Fracture\Http\UploadedFile', $object['alpha'][1]);
203			}
204			}
205

fracture / http

FileBagBuilderTest A last analyzed 2016-03-10 22:03 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

6 Methods

Duplication Side-by-Side

Filter issues like

FileBagBuilderTest A
last analyzed 2016-03-10 22:03 UTC