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

Passed

Push — add-uploaders-tests ( ce6830...a0b017 )

by Pedro

created 2024-05-14 15:23 UTC

UploadersValidationTest::setUp() A

↳ Parent: UploadersValidationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	7
rs	10
c	0
b	0
f	0

<?php

namespace Backpack\CRUD\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;

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

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Push — add-uploaders-tests ( ce6830...a0b017 )

UploadersValidationTest::setUp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like