WorksWithFileUploadsTest::testPutHasOneFileUpload() - Code Metrics - rafflesargentina/l5-resource-controller - Measure and Improve Code Quality continuously with Scrutinizer

testPutHasOneFileUpload() A
last analyzed 2019-02-10 15:19 UTC

↳ Parent: WorksWithFileUploadsTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace RafflesArgentina\ResourceController;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;

use Orchestra\Testbench\TestCase;

class WorksWithFileUploadsTest extends TestCase
{
    use BaseTest;

    /**
     * @coversNothing
     */
    function testPostNonMultipleFileUpload()

    {
        Storage::fake('uploads');

        $this->post(
            '/test', [
                'location' => UploadedFile::fake()->image('test.jpeg'),
                'name' => 'Mario',
                'email' => '[email protected]',
                'password' => str_random()
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue(!is_null($user->location));
    }

    /**
     * @coversNothing
     */
    function testPostHasOneFileUpload()

    {
        Storage::fake('uploads');

        $this->post(
            '/test', [
                'name' => 'Mario',
                'email' => '[email protected]',
                'password' => str_random(),
                'hasOneFileUpload' => [
                    UploadedFile::fake()->image('test.jpeg')
                ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue(!is_null($user->hasOneFileUpload));
    }

    /**
     * @coversNothing
     */
    function testPostMorphOneFileUpload()

    {
        Storage::fake('uploads');

        $this->post(
            '/test', [
            'name' => 'Mario',
            'email' => '[email protected]',
            'password' => str_random(),
                'morphOneFileUpload' => [
                    UploadedFile::fake()->image('test.jpeg')
                ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue(!is_null($user->morphOneFileUpload));
    }

    /**
     * @coversNothing
     */
    function testPostBelongsToFileUpload()

    {
        $user = \RafflesArgentina\ResourceController\Models\User::first();


        Storage::fake('uploads');

        $this->post(
            '/test', [
            'name' => 'Mario',
            'email' => '[email protected]',
            'password' => str_random(),
                'belongsToFileUpload' => [
                    UploadedFile::fake()->image('test.jpeg')
                ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue(!is_null($user->belongsToFileUpload));
    }

    /**
     * @coversNothing
     */
    function testPostHasManyFileUploads()

    {
        Storage::fake('uploads');

        $this->post(
            '/test', [
            'name' => 'Mario',
            'email' => '[email protected]',
            'password' => str_random(),
            'hasManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ]
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue($user->hasManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPostMorphManyFileUploads()

    {
        $user = \RafflesArgentina\ResourceController\Models\User::first();


        Storage::fake('uploads');

        $this->post(
            '/test', [
            'name' => 'Mario',
            'email' => '[email protected]',
            'password' => str_random(),
            'morphManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue($user->morphManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPostBelongsToManyFileUploads()

    {
        $user = \RafflesArgentina\ResourceController\Models\User::first();


        Storage::fake('uploads');

        $this->post(
            '/test', [
            'name' => 'Mario',
            'email' => '[email protected]',
            'password' => str_random(),
            'belongsToManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue($user->belongsToManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPostMorphToManyFileUploads()

    {
        $user = \RafflesArgentina\ResourceController\Models\User::first();


        Storage::fake('uploads');

        $this->post(
            '/test', [
            'name' => 'Mario',
            'email' => '[email protected]',
            'password' => str_random(),
            'morphToManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user = \RafflesArgentina\ResourceController\Models\User::first();
        $this->assertTrue($user->morphToManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPutNonMultipleFileUpload()

    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
                'location' => UploadedFile::fake()->image('test.jpeg'),
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user->refresh();
        $this->assertTrue(!is_null($user->location));
    }

    /**
     * @coversNothing
     */
    function testPutHasOneFileUpload()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
                'hasOneFileUpload' => [
                    UploadedFile::fake()->image('test.jpeg')
                ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $this->assertTrue(!is_null($user->hasOneFileUpload));
    }

    /**
     * @coversNothing
     */
    function testPutMorphOneFileUpload()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
                'morphOneFileUpload' => [
                    UploadedFile::fake()->image('test.jpeg')
                ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $this->assertTrue(!is_null($user->morphOneFileUpload));
    }

    /**
     * @coversNothing
     */
    function testPutBelongsToFileUpload()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
                'belongsToFileUpload' => [
                    UploadedFile::fake()->image('test.jpeg')
                ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $user->refresh();
        $this->assertTrue(!is_null($user->belongsToFileUpload));
    }

    /**
     * @coversNothing
     */
    function testPutHasManyFileUploads()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
            'hasManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ]
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $this->assertTrue($user->hasManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPutMorphManyFileUploads()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
            'morphManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $this->assertTrue($user->morphManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPutBelongsToManyFileUploads()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
            'belongsToManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $this->assertTrue($user->belongsToManyFileUploads->count() === 2);
    }

    /**
     * @coversNothing
     */
    function testPutMorphToManyFileUploads()
    {
        $user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();

        Storage::fake('uploads');

        $this->put(
            '/test/1', [
            'morphToManyFileUploads' => [
                UploadedFile::fake()->image('test.jpeg'),
                UploadedFile::fake()->create('document.pdf')
            ],
            ]
        )->assertRedirect('/test')
            ->assertSessionHas('rafflesargentina.status.success');

        $this->assertTrue($user->morphToManyFileUploads->count() === 2);
    }
}


1			<?php
2
3			namespace RafflesArgentina\ResourceController;
4
5			use Illuminate\Http\UploadedFile;
6			use Illuminate\Support\Facades\Storage;
7
8			use Orchestra\Testbench\TestCase;
9
10			class WorksWithFileUploadsTest extends TestCase
11			{
12			use BaseTest;
13
14			/**
15			* @coversNothing
16			*/
17			function testPostNonMultipleFileUpload()
			0 ignored issues – show Best Practice introduced 2018-12-04 23:38 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
18			{
19			Storage::fake('uploads');
20
21			$this->post(
22			'/test', [
23			'location' => UploadedFile::fake()->image('test.jpeg'),
24			'name' => 'Mario',
25			'email' => '[email protected]',
26			'password' => str_random()
27			]
28			)->assertRedirect('/test')
29			->assertSessionHas('rafflesargentina.status.success');
30
31			$user = \RafflesArgentina\ResourceController\Models\User::first();
32			$this->assertTrue(!is_null($user->location));
33			}
34
35			/**
36			* @coversNothing
37			*/
38			function testPostHasOneFileUpload()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
39			{
40			Storage::fake('uploads');
41
42			$this->post(
43			'/test', [
44			'name' => 'Mario',
45			'email' => '[email protected]',
46			'password' => str_random(),
47			'hasOneFileUpload' => [
48			UploadedFile::fake()->image('test.jpeg')
49			],
50			]
51			)->assertRedirect('/test')
52			->assertSessionHas('rafflesargentina.status.success');
53
54			$user = \RafflesArgentina\ResourceController\Models\User::first();
55			$this->assertTrue(!is_null($user->hasOneFileUpload));
56			}
57
58			/**
59			* @coversNothing
60			*/
61			function testPostMorphOneFileUpload()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
62			{
63			Storage::fake('uploads');
64
65			$this->post(
66			'/test', [
67			'name' => 'Mario',
68			'email' => '[email protected]',
69			'password' => str_random(),
70			'morphOneFileUpload' => [
71			UploadedFile::fake()->image('test.jpeg')
72			],
73			]
74			)->assertRedirect('/test')
75			->assertSessionHas('rafflesargentina.status.success');
76
77			$user = \RafflesArgentina\ResourceController\Models\User::first();
78			$this->assertTrue(!is_null($user->morphOneFileUpload));
79			}
80
81			/**
82			* @coversNothing
83			*/
84			function testPostBelongsToFileUpload()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
85			{
86			$user = \RafflesArgentina\ResourceController\Models\User::first();
			0 ignored issues – show Unused Code introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report The assignment to `$user` is dead and can be removed. Loading history...
87
88			Storage::fake('uploads');
89
90			$this->post(
91			'/test', [
92			'name' => 'Mario',
93			'email' => '[email protected]',
94			'password' => str_random(),
95			'belongsToFileUpload' => [
96			UploadedFile::fake()->image('test.jpeg')
97			],
98			]
99			)->assertRedirect('/test')
100			->assertSessionHas('rafflesargentina.status.success');
101
102			$user = \RafflesArgentina\ResourceController\Models\User::first();
103			$this->assertTrue(!is_null($user->belongsToFileUpload));
104			}
105
106			/**
107			* @coversNothing
108			*/
109			function testPostHasManyFileUploads()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
110			{
111			Storage::fake('uploads');
112
113			$this->post(
114			'/test', [
115			'name' => 'Mario',
116			'email' => '[email protected]',
117			'password' => str_random(),
118			'hasManyFileUploads' => [
119			UploadedFile::fake()->image('test.jpeg'),
120			UploadedFile::fake()->create('document.pdf')
121			]
122			]
123			)->assertRedirect('/test')
124			->assertSessionHas('rafflesargentina.status.success');
125
126			$user = \RafflesArgentina\ResourceController\Models\User::first();
127			$this->assertTrue($user->hasManyFileUploads->count() === 2);
128			}
129
130			/**
131			* @coversNothing
132			*/
133			function testPostMorphManyFileUploads()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
134			{
135			$user = \RafflesArgentina\ResourceController\Models\User::first();
			0 ignored issues – show Unused Code introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report The assignment to `$user` is dead and can be removed. Loading history...
136
137			Storage::fake('uploads');
138
139			$this->post(
140			'/test', [
141			'name' => 'Mario',
142			'email' => '[email protected]',
143			'password' => str_random(),
144			'morphManyFileUploads' => [
145			UploadedFile::fake()->image('test.jpeg'),
146			UploadedFile::fake()->create('document.pdf')
147			],
148			]
149			)->assertRedirect('/test')
150			->assertSessionHas('rafflesargentina.status.success');
151
152			$user = \RafflesArgentina\ResourceController\Models\User::first();
153			$this->assertTrue($user->morphManyFileUploads->count() === 2);
154			}
155
156			/**
157			* @coversNothing
158			*/
159			function testPostBelongsToManyFileUploads()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
160			{
161			$user = \RafflesArgentina\ResourceController\Models\User::first();
			0 ignored issues – show Unused Code introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report The assignment to `$user` is dead and can be removed. Loading history...
162
163			Storage::fake('uploads');
164
165			$this->post(
166			'/test', [
167			'name' => 'Mario',
168			'email' => '[email protected]',
169			'password' => str_random(),
170			'belongsToManyFileUploads' => [
171			UploadedFile::fake()->image('test.jpeg'),
172			UploadedFile::fake()->create('document.pdf')
173			],
174			]
175			)->assertRedirect('/test')
176			->assertSessionHas('rafflesargentina.status.success');
177
178			$user = \RafflesArgentina\ResourceController\Models\User::first();
179			$this->assertTrue($user->belongsToManyFileUploads->count() === 2);
180			}
181
182			/**
183			* @coversNothing
184			*/
185			function testPostMorphToManyFileUploads()
			0 ignored issues – show Best Practice introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
186			{
187			$user = \RafflesArgentina\ResourceController\Models\User::first();
			0 ignored issues – show Unused Code introduced 2018-04-19 19:36 UTC by Report Bug Copy Issue Report The assignment to `$user` is dead and can be removed. Loading history...
188
189			Storage::fake('uploads');
190
191			$this->post(
192			'/test', [
193			'name' => 'Mario',
194			'email' => '[email protected]',
195			'password' => str_random(),
196			'morphToManyFileUploads' => [
197			UploadedFile::fake()->image('test.jpeg'),
198			UploadedFile::fake()->create('document.pdf')
199			],
200			]
201			)->assertRedirect('/test')
202			->assertSessionHas('rafflesargentina.status.success');
203
204			$user = \RafflesArgentina\ResourceController\Models\User::first();
205			$this->assertTrue($user->morphToManyFileUploads->count() === 2);
206			}
207
208			/**
209			* @coversNothing
210			*/
211			function testPutNonMultipleFileUpload()
			0 ignored issues – show Best Practice introduced 2018-12-04 23:38 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
212			{
213			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
214
215			Storage::fake('uploads');
216
217			$this->put(
218			'/test/1', [
219			'location' => UploadedFile::fake()->image('test.jpeg'),
220			]
221			)->assertRedirect('/test')
222			->assertSessionHas('rafflesargentina.status.success');
223
224			$user->refresh();
225			$this->assertTrue(!is_null($user->location));
226			}
227
228			/**
229			* @coversNothing
230			*/
231			function testPutHasOneFileUpload()
232			{
233			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
234
235			Storage::fake('uploads');
236
237			$this->put(
238			'/test/1', [
239			'hasOneFileUpload' => [
240			UploadedFile::fake()->image('test.jpeg')
241			],
242			]
243			)->assertRedirect('/test')
244			->assertSessionHas('rafflesargentina.status.success');
245
246			$this->assertTrue(!is_null($user->hasOneFileUpload));
247			}
248
249			/**
250			* @coversNothing
251			*/
252			function testPutMorphOneFileUpload()
253			{
254			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
255
256			Storage::fake('uploads');
257
258			$this->put(
259			'/test/1', [
260			'morphOneFileUpload' => [
261			UploadedFile::fake()->image('test.jpeg')
262			],
263			]
264			)->assertRedirect('/test')
265			->assertSessionHas('rafflesargentina.status.success');
266
267			$this->assertTrue(!is_null($user->morphOneFileUpload));
268			}
269
270			/**
271			* @coversNothing
272			*/
273			function testPutBelongsToFileUpload()
274			{
275			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
276
277			Storage::fake('uploads');
278
279			$this->put(
280			'/test/1', [
281			'belongsToFileUpload' => [
282			UploadedFile::fake()->image('test.jpeg')
283			],
284			]
285			)->assertRedirect('/test')
286			->assertSessionHas('rafflesargentina.status.success');
287
288			$user->refresh();
289			$this->assertTrue(!is_null($user->belongsToFileUpload));
290			}
291
292			/**
293			* @coversNothing
294			*/
295			function testPutHasManyFileUploads()
296			{
297			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
298
299			Storage::fake('uploads');
300
301			$this->put(
302			'/test/1', [
303			'hasManyFileUploads' => [
304			UploadedFile::fake()->image('test.jpeg'),
305			UploadedFile::fake()->create('document.pdf')
306			]
307			]
308			)->assertRedirect('/test')
309			->assertSessionHas('rafflesargentina.status.success');
310
311			$this->assertTrue($user->hasManyFileUploads->count() === 2);
312			}
313
314			/**
315			* @coversNothing
316			*/
317			function testPutMorphManyFileUploads()
318			{
319			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
320
321			Storage::fake('uploads');
322
323			$this->put(
324			'/test/1', [
325			'morphManyFileUploads' => [
326			UploadedFile::fake()->image('test.jpeg'),
327			UploadedFile::fake()->create('document.pdf')
328			],
329			]
330			)->assertRedirect('/test')
331			->assertSessionHas('rafflesargentina.status.success');
332
333			$this->assertTrue($user->morphManyFileUploads->count() === 2);
334			}
335
336			/**
337			* @coversNothing
338			*/
339			function testPutBelongsToManyFileUploads()
340			{
341			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
342
343			Storage::fake('uploads');
344
345			$this->put(
346			'/test/1', [
347			'belongsToManyFileUploads' => [
348			UploadedFile::fake()->image('test.jpeg'),
349			UploadedFile::fake()->create('document.pdf')
350			],
351			]
352			)->assertRedirect('/test')
353			->assertSessionHas('rafflesargentina.status.success');
354
355			$this->assertTrue($user->belongsToManyFileUploads->count() === 2);
356			}
357
358			/**
359			* @coversNothing
360			*/
361			function testPutMorphToManyFileUploads()
362			{
363			$user = factory(\RafflesArgentina\ResourceController\Models\User::class)->create();
364
365			Storage::fake('uploads');
366
367			$this->put(
368			'/test/1', [
369			'morphToManyFileUploads' => [
370			UploadedFile::fake()->image('test.jpeg'),
371			UploadedFile::fake()->create('document.pdf')
372			],
373			]
374			)->assertRedirect('/test')
375			->assertSessionHas('rafflesargentina.status.success');
376
377			$this->assertTrue($user->morphToManyFileUploads->count() === 2);
378			}
379			}
380

rafflesargentina / l5-resource-controller

testPutHasOneFileUpload() A last analyzed 2019-02-10 15:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testPutHasOneFileUpload() A
last analyzed 2019-02-10 15:19 UTC