UploadersValidationTest::test_it_validates_files_on_multiple_uploader() - Code Metrics - Inspection of "add uploaders to test coverage" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — add-uploaders-tests ( 22787e...b7f78d )

by Pedro

created 2024-05-13 17:04 UTC

test_it_validates_files_on_multiple_uploader() A

↳ Parent: UploadersValidationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	11
rs	10
c	1
b	0
f	1

<?php

namespace Tests\Feature;

use Backpack\CRUD\Tests\config\CrudPanel\BaseDBCrudPanel;
use Backpack\CRUD\Tests\config\Http\Controllers\UploaderValidationCrudController;
use Backpack\CRUD\Tests\config\Models\Uploader;
use Backpack\CRUD\Tests\config\Models\User;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use PHPUnit\Framework\Attributes\Group;

class UploadersValidationTest extends BaseDBCrudPanel
{
    private string $testBaseUrl;

    protected function defineRoutes($router)
    {
        $router->crud(config('backpack.base.route_prefix').'/uploader-validation', UploaderValidationCrudController::class);
    }

    protected function setUp(): void
    {
        parent::setUp();

        $this->testBaseUrl = config('backpack.base.route_prefix').'/uploader-validation';
        Storage::fake('uploaders');
        $this->actingAs(User::find(1));
    }
    
    
    public function test_it_can_access_the_uploaders_create_page()
    {
        $response = $this->get($this->testBaseUrl.'/create');
        $response->assertStatus(200);
    }

    public function test_it_can_store_uploaded_files()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => UploadedFile::fake()->create('avatar.pdf'),
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf'), UploadedFile::fake()->create('avatar2.pdf')],
        ]);

        $response->assertStatus(302);

        $response->assertRedirect($this->testBaseUrl);

        $this->assertDatabaseCount('uploaders', 1);

        $files = Storage::disk('uploaders')->allFiles();

        $this->assertEquals(3, count($files));

        $this->assertDatabaseHas('uploaders', [
            'upload'          => 'avatar.pdf',
            'upload_multiple' => json_encode(['avatar1.pdf',  'avatar2.pdf']),
        ]);

        $this->assertTrue(Storage::disk('uploaders')->exists('avatar.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar1.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar2.pdf'));
    }

    public function test_it_display_the_edit_page_without_files()
    {
        self::initUploader();

        $response = $this->get($this->testBaseUrl.'/1/edit');
        $response->assertStatus(200);
    }

    public function test_it_display_the_upload_page_with_files()
    {
        self::initUploaderWithImages();

        $response = $this->get($this->testBaseUrl.'/1/edit');

        $response->assertStatus(200);

        $response->assertSee('avatar1.jpg');
        $response->assertSee('avatar2.jpg');
        $response->assertSee('avatar3.jpg');
    }

    public function test_it_can_update_uploaded_files()
    {
        self::initUploaderWithFiles();

        $response = $this->put($this->testBaseUrl.'/1', [
            'upload'                => UploadedFile::fake()->create('avatar4.pdf'),
            'upload_multiple'       => [UploadedFile::fake()->create('avatar5.pdf'), UploadedFile::fake()->create('avatar6.pdf')],
            'clear_upload_multiple' => ['avatar2.pdf',  'avatar3.pdf'],
            'id'                    => 1,
        ]);

        $response->assertStatus(302);

        $response->assertRedirect($this->testBaseUrl);

        $this->assertDatabaseCount('uploaders', 1);

        $this->assertDatabaseHas('uploaders', [
            'upload'          => 'avatar4.pdf',
            'upload_multiple' => json_encode(['avatar5.pdf',  'avatar6.pdf']),
        ]);

        $files = Storage::disk('uploaders')->allFiles();

        $this->assertEquals(3, count($files));

        $this->assertTrue(Storage::disk('uploaders')->exists('avatar4.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar5.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar6.pdf'));
    }
    
    public function test_it_can_delete_uploaded_files()
    {
        self::initUploaderWithImages();

        $response = $this->delete($this->testBaseUrl.'/1');

        $response->assertStatus(200);

        $this->assertDatabaseCount('uploaders', 0);

        $files = Storage::disk('uploaders')->allFiles();

        $this->assertEquals(0, count($files));
    }

    public function test_it_keeps_previous_values_unchaged_when_not_deleted()
    {
        self::initUploaderWithFiles();

        $response = $this->put($this->testBaseUrl.'/1', [
            'upload_multiple' => ['avatar2.pdf',  'avatar3.pdf'],
            'id'              => 1,
        ]);

        $response->assertStatus(302);

        $response->assertRedirect($this->testBaseUrl);

        $this->assertDatabaseCount('uploaders', 1);

        $this->assertDatabaseHas('uploaders', [
            'upload'          => 'avatar1.pdf',
            'upload_multiple' => json_encode(['avatar2.pdf',  'avatar3.pdf']),
        ]);

        $files = Storage::disk('uploaders')->allFiles();

        $this->assertEquals(3, count($files));

        $this->assertTrue(Storage::disk('uploaders')->exists('avatar1.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar2.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar3.pdf'));
    }

    public function test_upload_multiple_can_delete_uploaded_files_and_add_at_the_same_time()
    {
        self::initUploaderWithFiles();

        $response = $this->put($this->testBaseUrl.'/1', [
            'upload_multiple'       => [UploadedFile::fake()->create('avatar4.pdf'), UploadedFile::fake()->create('avatar5.pdf')],
            'clear_upload_multiple' => ['avatar2.pdf'],
            'id'                    => 1,
        ]);

        $response->assertStatus(302);

        $response->assertRedirect($this->testBaseUrl);

        $this->assertDatabaseCount('uploaders', 1);

        $this->assertDatabaseHas('uploaders', [
            'upload'          => 'avatar1.pdf',
            'upload_multiple' => json_encode(['avatar3.pdf', 'avatar4.pdf',  'avatar5.pdf']),
        ]);

        $files = Storage::disk('uploaders')->allFiles();

        $this->assertEquals(4, count($files));

        $this->assertTrue(Storage::disk('uploaders')->exists('avatar1.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar3.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar4.pdf'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar5.pdf'));
    }

    public function test_it_validates_files_on_a_single_upload()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => 'not-a-file',
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf'), UploadedFile::fake()->create('avatar2.pdf')],
        ]);

        $response->assertStatus(302);
        $response->assertSessionHasErrors('upload');

        $this->assertDatabaseCount('uploaders', 0);
    }

    public function test_it_validates_files_on_multiple_uploader()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => UploadedFile::fake()->create('avatar.pdf'),
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf'), 'not-a-file'],
        ]);
        
        $response->assertStatus(302);
        $response->assertSessionHasErrors('upload_multiple');

        $this->assertDatabaseCount('uploaders', 0);
    }
   
    public function test_it_validates_mime_types_on_single_and_multi_uploads()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => UploadedFile::fake()->create('avatar2.jpg'),
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.jpg'), UploadedFile::fake()->create('avatar3.jpg')],
        ]);
        
        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload_multiple');
        $response->assertSessionHasErrors('upload');

        // assert the error content
        $this->assertEquals('The upload multiple field must be a file of type: pdf.', session('errors')->get('upload_multiple')[0]);
        $this->assertEquals('The upload field must be a file of type: pdf.', session('errors')->get('upload')[0]);

        $this->assertDatabaseCount('uploaders', 0);
    }

    public function test_it_validates_file_size_on_single_and_multi_uploads()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => UploadedFile::fake()->create('avatar.pdf', 2000),
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf', 2000), UploadedFile::fake()->create('avatar2.pdf', 2000)],
        ]);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload_multiple');
        $response->assertSessionHasErrors('upload');

        // assert the error content
        $this->assertEquals('The upload multiple field must not be greater than 1024 kilobytes.', session('errors')->get('upload_multiple')[0]);
        $this->assertEquals('The upload field must not be greater than 1024 kilobytes.', session('errors')->get('upload')[0]);

        $this->assertDatabaseCount('uploaders', 0);
    }
    
    public function test_it_validates_min_files_on_multi_uploads()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => UploadedFile::fake()->create('avatar.pdf'),
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf')],
        ]);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload_multiple');

        // assert the error content
        $this->assertEquals('The upload multiple field must have at least 2 items.', session('errors')->get('upload_multiple')[0]);

        $this->assertDatabaseCount('uploaders', 0);
    }

    public function test_it_validates_required_files_on_single_and_multi_uploads()
    {
        $response = $this->post($this->testBaseUrl, [
            'upload'          => null,
            'upload_multiple' => null,
        ]);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload');
        $response->assertSessionHasErrors('upload_multiple');

        // assert the error content
        $this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
        $this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);

        $this->assertDatabaseCount('uploaders', 0);
    }

    
    public function test_it_validates_required_when_not_present_in_request()
    {
        $response = $this->post($this->testBaseUrl, []);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload');
        $response->assertSessionHasErrors('upload_multiple');

        $this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
        $this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);

        $this->assertDatabaseCount('uploaders', 0);
    }
    #[Group('fail')]
    public function test_it_validates_required_files_on_single_and_multi_uploads_when_updating()
    {
        self::initUploader();

        $response = $this->put($this->testBaseUrl.'/1', [
            'upload'          => null,
            'upload_multiple' => null,
            'id'              => 1,
        ]);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload');
        $response->assertSessionHasErrors('upload_multiple');

        // assert the error content
        $this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
        $this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);

        $this->assertDatabaseCount('uploaders', 1);
    }
    
    public function test_it_validates_required_files_on_single_and_multi_uploads_when_updating_with_files()
    {
        self::initUploaderWithFiles();

        $response = $this->put($this->testBaseUrl.'/1', [
            'upload'          => null,
            'upload_multiple' => null,
            'clear_upload_multiple' => ['avatar2.pdf',  'avatar3.pdf'],
            'id'              => 1,
        ]);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload');
        $response->assertSessionHasErrors('upload_multiple');

        // assert the error content
        $this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
        $this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);

        $this->assertDatabaseCount('uploaders', 1);
    }
    
    #[Group('fail')]
    public function test_it_validates_min_files_on_multi_uploads_when_updating()
    {
        self::initUploaderWithFiles();

        $response = $this->put($this->testBaseUrl.'/1', [
            'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf')],
            'clear_upload_multiple' => ['avatar2.pdf',  'avatar3.pdf'],
            'id'              => 1,
        ]);

        $response->assertStatus(302);

        $response->assertSessionHasErrors('upload_multiple');

        // assert the error content
        $this->assertEquals('The upload multiple field must have at least 2 items.', session('errors')->get('upload_multiple')[0]);

        $this->assertDatabaseCount('uploaders', 1);
    }

    protected static function initUploaderWithImages()
    {
        UploadedFile::fake()->image('avatar1.jpg')->storeAs('', 'avatar1.jpg', ['disk' => 'uploaders']);
        UploadedFile::fake()->image('avatar2.jpg')->storeAs('', 'avatar2.jpg', ['disk' => 'uploaders']);
        UploadedFile::fake()->image('avatar3.jpg')->storeAs('', 'avatar3.jpg', ['disk' => 'uploaders']);

        Uploader::create([
            'upload'          => 'avatar1.jpg',
            'upload_multiple' => json_encode(['avatar2.jpg',  'avatar3.jpg']),
        ]);
    }

    protected static function initUploaderWithFiles()
    {
        UploadedFile::fake()->create('avatar1.pdf')->storeAs('', 'avatar1.pdf', ['disk' => 'uploaders']);
        UploadedFile::fake()->create('avatar2.pdf')->storeAs('', 'avatar2.pdf', ['disk' => 'uploaders']);
        UploadedFile::fake()->create('avatar3.pdf')->storeAs('', 'avatar3.pdf', ['disk' => 'uploaders']);

        Uploader::create([
            'upload'          => 'avatar1.pdf',
            'upload_multiple' => json_encode(['avatar2.pdf',  'avatar3.pdf']),
        ]);
    }

    protected static function initUploader()
    {
        Uploader::create([
            'upload'          => null,
            'upload_multiple' => null,
        ]);
    }
}


1			<?php
2
3			namespace Tests\Feature;
4
5			use Backpack\CRUD\Tests\config\CrudPanel\BaseDBCrudPanel;
6			use Backpack\CRUD\Tests\config\Http\Controllers\UploaderValidationCrudController;
7			use Backpack\CRUD\Tests\config\Models\Uploader;
8			use Backpack\CRUD\Tests\config\Models\User;
9			use Illuminate\Http\UploadedFile;
10			use Illuminate\Support\Facades\Storage;
11			use PHPUnit\Framework\Attributes\Group;
12
13			class UploadersValidationTest extends BaseDBCrudPanel
14			{
15			private string $testBaseUrl;
16
17			protected function defineRoutes($router)
18			{
19			$router->crud(config('backpack.base.route_prefix').'/uploader-validation', UploaderValidationCrudController::class);
20			}
21
22			protected function setUp(): void
23			{
24			parent::setUp();
25
26			$this->testBaseUrl = config('backpack.base.route_prefix').'/uploader-validation';
27			Storage::fake('uploaders');
28			$this->actingAs(User::find(1));
29			}
30
31
32			public function test_it_can_access_the_uploaders_create_page()
33			{
34			$response = $this->get($this->testBaseUrl.'/create');
35			$response->assertStatus(200);
36			}
37
38			public function test_it_can_store_uploaded_files()
39			{
40			$response = $this->post($this->testBaseUrl, [
41			'upload' => UploadedFile::fake()->create('avatar.pdf'),
42			'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf'), UploadedFile::fake()->create('avatar2.pdf')],
43			]);
44
45			$response->assertStatus(302);
46
47			$response->assertRedirect($this->testBaseUrl);
48
49			$this->assertDatabaseCount('uploaders', 1);
50
51			$files = Storage::disk('uploaders')->allFiles();
52
53			$this->assertEquals(3, count($files));
54
55			$this->assertDatabaseHas('uploaders', [
56			'upload' => 'avatar.pdf',
57			'upload_multiple' => json_encode(['avatar1.pdf', 'avatar2.pdf']),
58			]);
59
60			$this->assertTrue(Storage::disk('uploaders')->exists('avatar.pdf'));
61			$this->assertTrue(Storage::disk('uploaders')->exists('avatar1.pdf'));
62			$this->assertTrue(Storage::disk('uploaders')->exists('avatar2.pdf'));
63			}
64
65			public function test_it_display_the_edit_page_without_files()
66			{
67			self::initUploader();
68
69			$response = $this->get($this->testBaseUrl.'/1/edit');
70			$response->assertStatus(200);
71			}
72
73			public function test_it_display_the_upload_page_with_files()
74			{
75			self::initUploaderWithImages();
76
77			$response = $this->get($this->testBaseUrl.'/1/edit');
78
79			$response->assertStatus(200);
80
81			$response->assertSee('avatar1.jpg');
82			$response->assertSee('avatar2.jpg');
83			$response->assertSee('avatar3.jpg');
84			}
85
86			public function test_it_can_update_uploaded_files()
87			{
88			self::initUploaderWithFiles();
89
90			$response = $this->put($this->testBaseUrl.'/1', [
91			'upload' => UploadedFile::fake()->create('avatar4.pdf'),
92			'upload_multiple' => [UploadedFile::fake()->create('avatar5.pdf'), UploadedFile::fake()->create('avatar6.pdf')],
93			'clear_upload_multiple' => ['avatar2.pdf', 'avatar3.pdf'],
94			'id' => 1,
95			]);
96
97			$response->assertStatus(302);
98
99			$response->assertRedirect($this->testBaseUrl);
100
101			$this->assertDatabaseCount('uploaders', 1);
102
103			$this->assertDatabaseHas('uploaders', [
104			'upload' => 'avatar4.pdf',
105			'upload_multiple' => json_encode(['avatar5.pdf', 'avatar6.pdf']),
106			]);
107
108			$files = Storage::disk('uploaders')->allFiles();
109
110			$this->assertEquals(3, count($files));
111
112			$this->assertTrue(Storage::disk('uploaders')->exists('avatar4.pdf'));
113			$this->assertTrue(Storage::disk('uploaders')->exists('avatar5.pdf'));
114			$this->assertTrue(Storage::disk('uploaders')->exists('avatar6.pdf'));
115			}
116
117			public function test_it_can_delete_uploaded_files()
118			{
119			self::initUploaderWithImages();
120
121			$response = $this->delete($this->testBaseUrl.'/1');
122
123			$response->assertStatus(200);
124
125			$this->assertDatabaseCount('uploaders', 0);
126
127			$files = Storage::disk('uploaders')->allFiles();
128
129			$this->assertEquals(0, count($files));
130			}
131
132			public function test_it_keeps_previous_values_unchaged_when_not_deleted()
133			{
134			self::initUploaderWithFiles();
135
136			$response = $this->put($this->testBaseUrl.'/1', [
137			'upload_multiple' => ['avatar2.pdf', 'avatar3.pdf'],
138			'id' => 1,
139			]);
140
141			$response->assertStatus(302);
142
143			$response->assertRedirect($this->testBaseUrl);
144
145			$this->assertDatabaseCount('uploaders', 1);
146
147			$this->assertDatabaseHas('uploaders', [
148			'upload' => 'avatar1.pdf',
149			'upload_multiple' => json_encode(['avatar2.pdf', 'avatar3.pdf']),
150			]);
151
152			$files = Storage::disk('uploaders')->allFiles();
153
154			$this->assertEquals(3, count($files));
155
156			$this->assertTrue(Storage::disk('uploaders')->exists('avatar1.pdf'));
157			$this->assertTrue(Storage::disk('uploaders')->exists('avatar2.pdf'));
158			$this->assertTrue(Storage::disk('uploaders')->exists('avatar3.pdf'));
159			}
160
161			public function test_upload_multiple_can_delete_uploaded_files_and_add_at_the_same_time()
162			{
163			self::initUploaderWithFiles();
164
165			$response = $this->put($this->testBaseUrl.'/1', [
166			'upload_multiple' => [UploadedFile::fake()->create('avatar4.pdf'), UploadedFile::fake()->create('avatar5.pdf')],
167			'clear_upload_multiple' => ['avatar2.pdf'],
168			'id' => 1,
169			]);
170
171			$response->assertStatus(302);
172
173			$response->assertRedirect($this->testBaseUrl);
174
175			$this->assertDatabaseCount('uploaders', 1);
176
177			$this->assertDatabaseHas('uploaders', [
178			'upload' => 'avatar1.pdf',
179			'upload_multiple' => json_encode(['avatar3.pdf', 'avatar4.pdf', 'avatar5.pdf']),
180			]);
181
182			$files = Storage::disk('uploaders')->allFiles();
183
184			$this->assertEquals(4, count($files));
185
186			$this->assertTrue(Storage::disk('uploaders')->exists('avatar1.pdf'));
187			$this->assertTrue(Storage::disk('uploaders')->exists('avatar3.pdf'));
188			$this->assertTrue(Storage::disk('uploaders')->exists('avatar4.pdf'));
189			$this->assertTrue(Storage::disk('uploaders')->exists('avatar5.pdf'));
190			}
191
192			public function test_it_validates_files_on_a_single_upload()
193			{
194			$response = $this->post($this->testBaseUrl, [
195			'upload' => 'not-a-file',
196			'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf'), UploadedFile::fake()->create('avatar2.pdf')],
197			]);
198
199			$response->assertStatus(302);
200			$response->assertSessionHasErrors('upload');
201
202			$this->assertDatabaseCount('uploaders', 0);
203			}
204
205			public function test_it_validates_files_on_multiple_uploader()
206			{
207			$response = $this->post($this->testBaseUrl, [
208			'upload' => UploadedFile::fake()->create('avatar.pdf'),
209			'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf'), 'not-a-file'],
210			]);
211
212			$response->assertStatus(302);
213			$response->assertSessionHasErrors('upload_multiple');
214
215			$this->assertDatabaseCount('uploaders', 0);
216			}
217
218			public function test_it_validates_mime_types_on_single_and_multi_uploads()
219			{
220			$response = $this->post($this->testBaseUrl, [
221			'upload' => UploadedFile::fake()->create('avatar2.jpg'),
222			'upload_multiple' => [UploadedFile::fake()->create('avatar1.jpg'), UploadedFile::fake()->create('avatar3.jpg')],
223			]);
224
225			$response->assertStatus(302);
226
227			$response->assertSessionHasErrors('upload_multiple');
228			$response->assertSessionHasErrors('upload');
229
230			// assert the error content
231			$this->assertEquals('The upload multiple field must be a file of type: pdf.', session('errors')->get('upload_multiple')[0]);
232			$this->assertEquals('The upload field must be a file of type: pdf.', session('errors')->get('upload')[0]);
233
234			$this->assertDatabaseCount('uploaders', 0);
235			}
236
237			public function test_it_validates_file_size_on_single_and_multi_uploads()
238			{
239			$response = $this->post($this->testBaseUrl, [
240			'upload' => UploadedFile::fake()->create('avatar.pdf', 2000),
241			'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf', 2000), UploadedFile::fake()->create('avatar2.pdf', 2000)],
242			]);
243
244			$response->assertStatus(302);
245
246			$response->assertSessionHasErrors('upload_multiple');
247			$response->assertSessionHasErrors('upload');
248
249			// assert the error content
250			$this->assertEquals('The upload multiple field must not be greater than 1024 kilobytes.', session('errors')->get('upload_multiple')[0]);
251			$this->assertEquals('The upload field must not be greater than 1024 kilobytes.', session('errors')->get('upload')[0]);
252
253			$this->assertDatabaseCount('uploaders', 0);
254			}
255
256			public function test_it_validates_min_files_on_multi_uploads()
257			{
258			$response = $this->post($this->testBaseUrl, [
259			'upload' => UploadedFile::fake()->create('avatar.pdf'),
260			'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf')],
261			]);
262
263			$response->assertStatus(302);
264
265			$response->assertSessionHasErrors('upload_multiple');
266
267			// assert the error content
268			$this->assertEquals('The upload multiple field must have at least 2 items.', session('errors')->get('upload_multiple')[0]);
269
270			$this->assertDatabaseCount('uploaders', 0);
271			}
272
273			public function test_it_validates_required_files_on_single_and_multi_uploads()
274			{
275			$response = $this->post($this->testBaseUrl, [
276			'upload' => null,
277			'upload_multiple' => null,
278			]);
279
280			$response->assertStatus(302);
281
282			$response->assertSessionHasErrors('upload');
283			$response->assertSessionHasErrors('upload_multiple');
284
285			// assert the error content
286			$this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
287			$this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);
288
289			$this->assertDatabaseCount('uploaders', 0);
290			}
291
292
293			public function test_it_validates_required_when_not_present_in_request()
294			{
295			$response = $this->post($this->testBaseUrl, []);
296
297			$response->assertStatus(302);
298
299			$response->assertSessionHasErrors('upload');
300			$response->assertSessionHasErrors('upload_multiple');
301
302			$this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
303			$this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);
304
305			$this->assertDatabaseCount('uploaders', 0);
306			}
307			#[Group('fail')]
308			public function test_it_validates_required_files_on_single_and_multi_uploads_when_updating()
309			{
310			self::initUploader();
311
312			$response = $this->put($this->testBaseUrl.'/1', [
313			'upload' => null,
314			'upload_multiple' => null,
315			'id' => 1,
316			]);
317
318			$response->assertStatus(302);
319
320			$response->assertSessionHasErrors('upload');
321			$response->assertSessionHasErrors('upload_multiple');
322
323			// assert the error content
324			$this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
325			$this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);
326
327			$this->assertDatabaseCount('uploaders', 1);
328			}
329
330			public function test_it_validates_required_files_on_single_and_multi_uploads_when_updating_with_files()
331			{
332			self::initUploaderWithFiles();
333
334			$response = $this->put($this->testBaseUrl.'/1', [
335			'upload' => null,
336			'upload_multiple' => null,
337			'clear_upload_multiple' => ['avatar2.pdf', 'avatar3.pdf'],
338			'id' => 1,
339			]);
340
341			$response->assertStatus(302);
342
343			$response->assertSessionHasErrors('upload');
344			$response->assertSessionHasErrors('upload_multiple');
345
346			// assert the error content
347			$this->assertEquals('The upload field is required.', session('errors')->get('upload')[0]);
348			$this->assertEquals('The upload multiple field is required.', session('errors')->get('upload_multiple')[0]);
349
350			$this->assertDatabaseCount('uploaders', 1);
351			}
352
353			#[Group('fail')]
354			public function test_it_validates_min_files_on_multi_uploads_when_updating()
355			{
356			self::initUploaderWithFiles();
357
358			$response = $this->put($this->testBaseUrl.'/1', [
359			'upload_multiple' => [UploadedFile::fake()->create('avatar1.pdf')],
360			'clear_upload_multiple' => ['avatar2.pdf', 'avatar3.pdf'],
361			'id' => 1,
362			]);
363
364			$response->assertStatus(302);
365
366			$response->assertSessionHasErrors('upload_multiple');
367
368			// assert the error content
369			$this->assertEquals('The upload multiple field must have at least 2 items.', session('errors')->get('upload_multiple')[0]);
370
371			$this->assertDatabaseCount('uploaders', 1);
372			}
373
374			protected static function initUploaderWithImages()
375			{
376			UploadedFile::fake()->image('avatar1.jpg')->storeAs('', 'avatar1.jpg', ['disk' => 'uploaders']);
377			UploadedFile::fake()->image('avatar2.jpg')->storeAs('', 'avatar2.jpg', ['disk' => 'uploaders']);
378			UploadedFile::fake()->image('avatar3.jpg')->storeAs('', 'avatar3.jpg', ['disk' => 'uploaders']);
379
380			Uploader::create([
381			'upload' => 'avatar1.jpg',
382			'upload_multiple' => json_encode(['avatar2.jpg', 'avatar3.jpg']),
383			]);
384			}
385
386			protected static function initUploaderWithFiles()
387			{
388			UploadedFile::fake()->create('avatar1.pdf')->storeAs('', 'avatar1.pdf', ['disk' => 'uploaders']);
389			UploadedFile::fake()->create('avatar2.pdf')->storeAs('', 'avatar2.pdf', ['disk' => 'uploaders']);
390			UploadedFile::fake()->create('avatar3.pdf')->storeAs('', 'avatar3.pdf', ['disk' => 'uploaders']);
391
392			Uploader::create([
393			'upload' => 'avatar1.pdf',
394			'upload_multiple' => json_encode(['avatar2.pdf', 'avatar3.pdf']),
395			]);
396			}
397
398			protected static function initUploader()
399			{
400			Uploader::create([
401			'upload' => null,
402			'upload_multiple' => null,
403			]);
404			}
405			}
406

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Push — add-uploaders-tests ( 22787e...b7f78d )

test_it_validates_files_on_multiple_uploader() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like