UploadersTest::test_it_can_delete_uploaded_files() - 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

UploadersTest::test_it_can_delete_uploaded_files() A

↳ Parent: UploadersTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	13
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\UploaderCrudController;
use Backpack\CRUD\Tests\config\Models\Uploader;
use Backpack\CRUD\Tests\config\Models\User;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;

/**
 * @covers Backpack\CRUD\app\Library\Uploaders\Uploader
 * @covers Backpack\CRUD\app\Library\Uploaders\SingleFile
 * @covers Backpack\CRUD\app\Library\Uploaders\MultipleFiles
 * @covers Backpack\CRUD\app\Library\Uploaders\Support\RegisterUploadEvents
 * @covers Backpack\CRUD\app\Library\Uploaders\Support\UploadersRepository
 */
class UploadersTest extends BaseDBCrudPanel
{
    protected string $testBaseUrl;

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

    protected function setUp(): void
    {
        parent::setUp();
        $this->testBaseUrl = config('backpack.base.route_prefix').'/uploader';
        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()->image('avatar.jpg'),
            'upload_multiple' => [UploadedFile::fake()->image('avatar1.jpg'), UploadedFile::fake()->image('avatar2.jpg')],
        ]);
        
        $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.jpg',
            'upload_multiple' => json_encode(['avatar1.jpg',  'avatar2.jpg']),
        ]);

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

    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::initUploaderWithFiles();
        $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()->image('avatar4.jpg'),
            'upload_multiple' => [UploadedFile::fake()->image('avatar5.jpg'), UploadedFile::fake()->image('avatar6.jpg')],
            'clear_upload_multiple' => ['avatar2.jpg',  'avatar3.jpg'],
            'id' => 1,
        ]);

        $response->assertStatus(302);

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

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

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

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

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

        $this->assertTrue(Storage::disk('uploaders')->exists('avatar4.jpg'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar5.jpg'));
        $this->assertTrue(Storage::disk('uploaders')->exists('avatar6.jpg'));
    }

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

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

        $response->assertStatus(302);

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

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

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

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

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

        $this->assertFalse(Storage::disk('uploaders')->exists('avatar1.jpg'));
    }

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

        $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.jpg',  'avatar3.jpg'],
            'id' => 1,
        ]);

        $response->assertStatus(302);

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

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

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

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

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

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

    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()->image('avatar4.jpg'), UploadedFile::fake()->image('avatar5.jpg')],
            'clear_upload_multiple' => ['avatar2.jpg'],
            'id' => 1,
        ]);

        $response->assertStatus(302);

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

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

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

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

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

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

    protected static function initUploaderWithFiles()
    {
        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 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\UploaderCrudController;
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
12			/**
13			* @covers Backpack\CRUD\app\Library\Uploaders\Uploader
14			* @covers Backpack\CRUD\app\Library\Uploaders\SingleFile
15			* @covers Backpack\CRUD\app\Library\Uploaders\MultipleFiles
16			* @covers Backpack\CRUD\app\Library\Uploaders\Support\RegisterUploadEvents
17			* @covers Backpack\CRUD\app\Library\Uploaders\Support\UploadersRepository
18			*/
19			class UploadersTest extends BaseDBCrudPanel
20			{
21			protected string $testBaseUrl;
22
23			protected function defineRoutes($router)
24			{
25			$router->crud(config('backpack.base.route_prefix').'/uploader', UploaderCrudController::class);
26			}
27
28			protected function setUp(): void
29			{
30			parent::setUp();
31			$this->testBaseUrl = config('backpack.base.route_prefix').'/uploader';
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()->image('avatar.jpg'),
46			'upload_multiple' => [UploadedFile::fake()->image('avatar1.jpg'), UploadedFile::fake()->image('avatar2.jpg')],
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.jpg',
61			'upload_multiple' => json_encode(['avatar1.jpg', 'avatar2.jpg']),
62			]);
63
64			$this->assertTrue(Storage::disk('uploaders')->exists('avatar.jpg'));
65			$this->assertTrue(Storage::disk('uploaders')->exists('avatar1.jpg'));
66			$this->assertTrue(Storage::disk('uploaders')->exists('avatar2.jpg'));
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::initUploaderWithFiles();
80			$response = $this->get($this->testBaseUrl.'/1/edit');
81
82			$response->assertStatus(200);
83
84			$response->assertSee('avatar1.jpg');
85			$response->assertSee('avatar2.jpg');
86			$response->assertSee('avatar3.jpg');
87			}
88
89			public function test_it_can_update_uploaded_files()
90			{
91			self::initUploaderWithFiles();
92
93			$response = $this->put($this->testBaseUrl.'/1', [
94			'upload' => UploadedFile::fake()->image('avatar4.jpg'),
95			'upload_multiple' => [UploadedFile::fake()->image('avatar5.jpg'), UploadedFile::fake()->image('avatar6.jpg')],
96			'clear_upload_multiple' => ['avatar2.jpg', 'avatar3.jpg'],
97			'id' => 1,
98			]);
99
100			$response->assertStatus(302);
101
102			$response->assertRedirect($this->testBaseUrl);
103
104			$this->assertDatabaseCount('uploaders', 1);
105
106			$this->assertDatabaseHas('uploaders', [
107			'upload' => 'avatar4.jpg',
108			'upload_multiple' => json_encode(['avatar5.jpg', 'avatar6.jpg']),
109			]);
110
111			$files = Storage::disk('uploaders')->allFiles();
112
113			$this->assertEquals(3, count($files));
114
115			$this->assertTrue(Storage::disk('uploaders')->exists('avatar4.jpg'));
116			$this->assertTrue(Storage::disk('uploaders')->exists('avatar5.jpg'));
117			$this->assertTrue(Storage::disk('uploaders')->exists('avatar6.jpg'));
118			}
119
120			public function test_single_upload_deletes_files_when_updated_without_values()
121			{
122			self::initUploaderWithFiles();
123
124			$response = $this->put($this->testBaseUrl.'/1', [
125			'upload' => null,
126			'id' => 1,
127			]);
128
129			$response->assertStatus(302);
130
131			$response->assertRedirect($this->testBaseUrl);
132
133			$this->assertDatabaseCount('uploaders', 1);
134
135			$this->assertDatabaseHas('uploaders', [
136			'upload' => null,
137			'upload_multiple' => json_encode(['avatar2.jpg', 'avatar3.jpg']),
138			]);
139
140			$files = Storage::disk('uploaders')->allFiles();
141
142			$this->assertEquals(2, count($files));
143
144			$this->assertFalse(Storage::disk('uploaders')->exists('avatar1.jpg'));
145			}
146
147			public function test_it_can_delete_uploaded_files()
148			{
149			self::initUploaderWithFiles();
150
151			$response = $this->delete($this->testBaseUrl.'/1');
152
153			$response->assertStatus(200);
154
155			$this->assertDatabaseCount('uploaders', 0);
156
157			$files = Storage::disk('uploaders')->allFiles();
158
159			$this->assertEquals(0, count($files));
160			}
161
162			public function test_it_keeps_previous_values_unchaged_when_not_deleted()
163			{
164			self::initUploaderWithFiles();
165
166			$response = $this->put($this->testBaseUrl.'/1', [
167			'upload_multiple' => ['avatar2.jpg', 'avatar3.jpg'],
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.jpg',
179			'upload_multiple' => json_encode(['avatar2.jpg', 'avatar3.jpg']),
180			]);
181
182			$files = Storage::disk('uploaders')->allFiles();
183
184			$this->assertEquals(3, count($files));
185
186			$this->assertTrue(Storage::disk('uploaders')->exists('avatar1.jpg'));
187			$this->assertTrue(Storage::disk('uploaders')->exists('avatar2.jpg'));
188			$this->assertTrue(Storage::disk('uploaders')->exists('avatar3.jpg'));
189			}
190
191			public function test_upload_multiple_can_delete_uploaded_files_and_add_at_the_same_time()
192			{
193			self::initUploaderWithFiles();
194
195			$response = $this->put($this->testBaseUrl.'/1', [
196			'upload_multiple' => [UploadedFile::fake()->image('avatar4.jpg'), UploadedFile::fake()->image('avatar5.jpg')],
197			'clear_upload_multiple' => ['avatar2.jpg'],
198			'id' => 1,
199			]);
200
201			$response->assertStatus(302);
202
203			$response->assertRedirect($this->testBaseUrl);
204
205			$this->assertDatabaseCount('uploaders', 1);
206
207			$this->assertDatabaseHas('uploaders', [
208			'upload' => 'avatar1.jpg',
209			'upload_multiple' => json_encode(['avatar3.jpg', 'avatar4.jpg', 'avatar5.jpg']),
210			]);
211
212			$files = Storage::disk('uploaders')->allFiles();
213
214			$this->assertEquals(4, count($files));
215
216			$this->assertTrue(Storage::disk('uploaders')->exists('avatar1.jpg'));
217			$this->assertTrue(Storage::disk('uploaders')->exists('avatar3.jpg'));
218			$this->assertTrue(Storage::disk('uploaders')->exists('avatar4.jpg'));
219			$this->assertTrue(Storage::disk('uploaders')->exists('avatar5.jpg'));
220			}
221
222			protected static function initUploaderWithFiles()
223			{
224			UploadedFile::fake()->image('avatar1.jpg')->storeAs('', 'avatar1.jpg', ['disk' => 'uploaders']);
225			UploadedFile::fake()->image('avatar2.jpg')->storeAs('', 'avatar2.jpg', ['disk' => 'uploaders']);
226			UploadedFile::fake()->image('avatar3.jpg')->storeAs('', 'avatar3.jpg', ['disk' => 'uploaders']);
227
228			Uploader::create([
229			'upload' => 'avatar1.jpg',
230			'upload_multiple' => json_encode(['avatar2.jpg', 'avatar3.jpg']),
231			]);
232			}
233
234			protected static function initUploader()
235			{
236			Uploader::create([
237			'upload' => null,
238			'upload_multiple' => null,
239			]);
240			}
241			}
242

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

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

UploadersTest::test_it_can_delete_uploaded_files() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like