test refactoring

src/App/Users/Models/User.php

@@ -7,7 +7,6 @@ use Domain\Files\Models\File;
 use Domain\Folders\Models\Folder;
 use Laravel\Sanctum\HasApiTokens;
 use Domain\Traffic\Models\Traffic;
-use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 use Database\Factories\UserFactory;
 use Domain\Settings\Models\Setting;

src/App/Users/Resources/UserStorageResource.php

@@ -1,5 +1,4 @@
 <?php
-
 namespace App\Users\Resources;
 
 use ByteUnits\Metric;
@@ -21,18 +20,18 @@ class UserStorageResource extends JsonResource
 
         $totalCapacity = match (get_settings('subscription_type')) {
             'metered' => $this->usedCapacity / 1000000000,
-            'fixed' => $this->limitations->max_storage_amount,
+            'fixed'   => $this->limitations->max_storage_amount,
-            default => $this->limitations->max_storage_amount,
+            default   => $this->limitations->max_storage_amount,
         };
 
         return [
             'data' => [
-                'id'         => (string)$this->id,
+                'id'         => (string) $this->id,
                 'type'       => 'storage',
                 'attributes' => [
                     'used'       => Metric::bytes($this->usedCapacity)->format(),
                     'capacity'   => format_gigabytes($totalCapacity),
-                    'percentage' => (float)get_storage_percentage($this->usedCapacity, $totalCapacity),
+                    'percentage' => (float) get_storage_percentage($this->usedCapacity, $totalCapacity),
                 ],
                 'meta'       => [
                     'traffic'   => [
@@ -45,23 +44,23 @@ class UserStorageResource extends JsonResource
                     ],
                     'images'    => [
                         'used'       => Metric::bytes($images)->format(),
-                        'percentage' => (float)get_storage_percentage($images, $totalCapacity),
+                        'percentage' => (float) get_storage_percentage($images, $totalCapacity),
                     ],
                     'audios'    => [
                         'used'       => Metric::bytes($audios)->format(),
-                        'percentage' => (float)get_storage_percentage($audios, $totalCapacity),
+                        'percentage' => (float) get_storage_percentage($audios, $totalCapacity),
                     ],
                     'videos'    => [
                         'used'       => Metric::bytes($videos)->format(),
-                        'percentage' => (float)get_storage_percentage($videos, $totalCapacity),
+                        'percentage' => (float) get_storage_percentage($videos, $totalCapacity),
                     ],
                     'documents' => [
                         'used'       => Metric::bytes($documents)->format(),
-                        'percentage' => (float)get_storage_percentage($documents, $totalCapacity),
+                        'percentage' => (float) get_storage_percentage($documents, $totalCapacity),
                     ],
                     'others'    => [
                         'used'       => Metric::bytes($others)->format(),
-                        'percentage' => (float)get_storage_percentage($others, $totalCapacity),
+                        'percentage' => (float) get_storage_percentage($others, $totalCapacity),
                     ],
                 ],
             ],
@@ -133,13 +132,13 @@ class UserStorageResource extends JsonResource
             ->orderBy('created_at')
             ->get();
 
-        $upload = $trafficRecords->map(fn($record) => [
+        $upload = $trafficRecords->map(fn ($record) => [
             'created_at' => format_date($record->created_at, '%d. %B'),
             'percentage' => $uploadMax !== 0 ? round(($record->upload / $uploadMax) * 100, 2) : 0,
             'amount'     => Metric::bytes($record->upload)->format(),
         ]);
 
-        $download = $trafficRecords->map(fn($record) => [
+        $download = $trafficRecords->map(fn ($record) => [
             'created_at' => format_date($record->created_at, '%d. %B'),
             'percentage' => $downloadMax !== 0 ? round(($record->download / $downloadMax) * 100, 2) : 0,
             'amount'     => Metric::bytes($record->download)->format(),

src/Domain/Admin/Controllers/Dashboard/GetDashboardDataController.php

@@ -1,5 +1,4 @@
 <?php
-
 namespace Domain\Admin\Controllers\Dashboard;
 
 use ByteUnits\Metric;
@@ -66,13 +65,13 @@ class GetDashboardDataController extends Controller
             ->groupBy('created_at')
             ->get();
 
-        $upload = $trafficRecords->map(fn($record) => [
+        $upload = $trafficRecords->map(fn ($record) => [
             'created_at' => format_date($record->created_at, '%d. %B'),
             'percentage' => intval($trafficRecords->max('upload')) !== 0 ? round(($record->upload / $trafficRecords->max('upload')) * 100, 2) : 0,
             'amount'     => Metric::bytes($record->upload)->format(),
         ]);
 
-        $download = $trafficRecords->map(fn($record) => [
+        $download = $trafficRecords->map(fn ($record) => [
             'created_at' => format_date($record->created_at, '%d. %B'),
             'percentage' => intval($trafficRecords->max('download')) !== 0 ? round(($record->download / $trafficRecords->max('download')) * 100, 2) : 0,
             'amount'     => Metric::bytes($record->download)->format(),

src/Domain/Files/Actions/CreateFolderStructureAction.php

@@ -1,22 +1,10 @@
 <?php
-
+namespace Domain\Files\Actions;
-namespace  Domain\Files\Actions;
 
 use Domain\Folders\Models\Folder;
 
-
 class CreateFolderStructureAction
 {
-    /**
-     * Create a new action instance.
-     *
-     * @return void
-     */
-    public function __construct()
-    {
-        // Prepare the action for execution, leveraging constructor injection.
-    }
-
     /**
      * Execute the action.
      *
@@ -24,7 +12,6 @@ class CreateFolderStructureAction
      */
     public function __invoke($path, $parent, $user_id)
     {
-         
         $folders = array_slice(explode('/', $path), 1, -1);
 
         $parent_id = $parent;
@@ -35,44 +22,36 @@ class CreateFolderStructureAction
         $structure = Folder::whereIn('name', $folders)->with('parent')->get();
 
         // If file have some parent folders
-        if( count($folders) > 0) {
+        if (count($folders) > 0) {
-
             // If uploading structure has same lenght as a already existed structure
-            if( count($folders) === count($structure) ) {
+            if (count($folders) === count($structure)) {
-
                 // Get correct file parent from the already craeted structure
                 $last_folder = $this->get_file_parent($structure, $folders);
-            
+            } elseif (count($folders) !== count($structure)) {
-            } else if ( count($folders) !== count($structure) ) {
+                if (count($structure) > 0) {
-
-                
-                if( count($structure) > 0 ) {
-
                     // Check what folders are missed in structure and return missed folder with last created folder in structure
                     $data = $this->check_exist_folders($structure, $folders);
 
                     $folders = $data[0];
 
                     $parent_id = $data[1];
-
                 }
 
                 // Create folders
-                foreach($folders as $folder) {
+                foreach ($folders as $folder) {
-
                     $new_folder = Folder::create([
-                                    'name' => $folder,
+                        'name'      => $folder,
-                                    'parent_id' => $parent_id,
+                        'parent_id' => $parent_id,
-                                    'user_id' => $user_id,
+                        'user_id'   => $user_id,
-                                ]);
+                    ]);
-                                
+
                     $parent_id = $new_folder->id;
-        
+
                     $last_folder = $new_folder->id;
-                };
+                }
             }
-        } 
+        }
-        
+
         return $last_folder;
     }
 
@@ -83,44 +62,38 @@ class CreateFolderStructureAction
     {
         $parent_name = '';
 
-        foreach(array_reverse($folders) as $folder) {
+        foreach (array_reverse($folders) as $folder) {
-            
             $item = $structure->where('name', $folder);
 
             $parent = $item->pluck('parent')->pluck('name')[0];
 
             // Check if folder have valid parent name
-            if( $parent && $folder === $parent_name || $parent_name == '') {
+            if ($parent && $folder === $parent_name || $parent_name == '') {
-
                 $parent_name = $parent;
             }
-       
+
             return $structure->where('name', $folders[array_key_last($folders)])->first()->id;
         }
     }
+
     /**
      * Return the folders that is need to create in already created structure and last created parent
      */
-    private function check_exist_folders($structure, $folders)
+    private function check_exist_folders($structure, $folders): array
     {
+        $create_folders = [];
+        $last_parent = '';
 
-       $create_folders = [];
+        foreach ($folders as $folder) {
-       $last_parent = '';
-
-       foreach($folders as $folder) {
-
             // Filter folders that is need to create
-           if(! $structure->where('name', $folder)->first()) {
+            if (! $structure->where('name', $folder)->first()) {
-
+                array_push($create_folders, $folder);
-               array_push($create_folders, $folder);
+            } else {
-           }else {
-
                 // Find last created folder
-               $last_parent = $structure->where('name', $folder)->first()->id;
+                $last_parent = $structure->where('name', $folder)->first()->id;
-           }
+            }
-       }
+        }
 
-       return [$create_folders, $last_parent];
+        return [$create_folders, $last_parent];
     }
 }
-

src/Domain/Files/Actions/UploadFileAction.php

@@ -10,7 +10,7 @@ use Domain\Files\Requests\UploadRequest;
 use Domain\Files\Models\File as UserFile;
 use Domain\Traffic\Actions\RecordUploadAction;
 use App\Users\Exceptions\InvalidUserActionException;
-use Domain\Files\Actions\CreateFolderStructureAction;
+use Illuminate\Contracts\Filesystem\FileNotFoundException;
 
 class UploadFileAction
 {
@@ -25,7 +25,7 @@ class UploadFileAction
     /**
      * Upload new file
      *
-     * @throws InvalidUserActionException
+     * @throws InvalidUserActionException|FileNotFoundException
      */
     public function __invoke(
         UploadRequest $request,

tests/Domain/Folders/FolderTest.php

@@ -1,4 +1,5 @@
 <?php
+
 namespace Tests\Domain\Folders;
 
 use Storage;
@@ -36,7 +37,7 @@ class FolderTest extends TestCase
         $this
             ->actingAs($user)
             ->postJson('/api/create-folder', [
-                'name'      => 'New Folder',
+                'name' => 'New Folder',
             ])
             ->assertStatus(201)
             ->assertJsonFragment([
@@ -413,58 +414,4 @@ class FolderTest extends TestCase
                 ]);
             });
     }
-
-    /**
-     * @test
-     */
-    public function it_upload_folders_structure_with_files()
-    {
-        $file_1 = UploadedFile::fake()
-        ->create('fake-file_1.pdf', 12000000, 'application/pdf');
-
-        $file_2 = UploadedFile::fake()
-        ->create('fake-file_2.pdf', 12000000, 'application/pdf');
-
-        $user = User::factory(User::class)
-            ->create();
-
-        $uploaded_file_1 = $this
-                            ->actingAs($user)
-                            ->postJson('/api/upload', [
-                                'filename'  => $file_2->name,
-                                'file'      => $file_2,
-                                'path'      => '/Folder_1/' . $file_2->name,
-                                'folder_id' => null,
-                                'is_last'   => 'true',
-                            ])->assertStatus(201);
-
-        $uploaded_file_2 = $this
-                            ->actingAs($user)
-                            ->postJson('/api/upload', [
-                                'filename'  => $file_1->name,
-                                'file'      => $file_1,
-                                'path'      => '/Folder_1/Folder_2/' . $file_1->name,
-                                'folder_id' => null,
-                                'is_last'   => 'true',
-                            ])->assertStatus(201);
-
-
-        $file_1_parent = Folder::whereName('Folder_1')->first();
-
-        $file_2_parent = Folder::whereName('Folder_2')->first();
-
-        $this->assertDatabaseHas('folders', [
-            'id'        => $uploaded_file_1['folder_id'],
-            'parent_id' => null,
-            'id'        => $uploaded_file_2['folder_id'],
-            'parent_id' => $file_1_parent->id,
-        ]);
-
-        $this->assertDatabaseHas('files', [
-            'id'        => $uploaded_file_1['id'],
-            'folder_id' => $file_1_parent->id,
-            'id'        => $uploaded_file_2['id'],
-            'folder_id' => $file_2_parent->id,
-        ]);
-    }
 }

tests/Domain/Folders/FolderUploadTest.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Tests\Domain\Folders;
+
+use App\Users\Models\User;
+use Domain\Files\Models\File;
+use Domain\Folders\Models\Folder;
+use Illuminate\Http\UploadedFile;
+use Tests\TestCase;
+
+class FolderUploadTest extends TestCase
+{
+    /**
+     * @test
+     */
+    public function check_folder_tree_structure_creation_after_folder_upload()
+    {
+        $user = User::factory()
+            ->hasSettings()
+            ->create();
+
+        $file = UploadedFile::fake()
+            ->create('fake-file_1.pdf', 120000, 'application/pdf');
+
+        $this
+            ->actingAs($user)
+            ->postJson('/api/upload', [
+                'filename'  => $file->name,
+                'file'      => $file,
+                'path'      => "/level_1/level_2/level_3/$file->name",
+                'parent_id' => null,
+                'is_last'   => 'true',
+            ])->assertStatus(201);
+
+        $file = File::first();
+
+        $level_1 = Folder::where('name', 'level_1')->first();
+        $level_2 = Folder::where('name', 'level_2')->first();
+        $level_3 = Folder::where('name', 'level_3')->first();
+
+        $this->assertEquals(null, $level_1->parent_id);
+        $this->assertEquals($level_2->parent_id, $level_1->id);
+        $this->assertEquals($level_3->parent_id, $level_2->id);
+
+        $this->assertEquals($level_3->id, $file->parent_id);
+    }
+
+
+    /**
+     * @test
+     */
+    public function check_children_tree_structure_creation_after_folder_upload()
+    {
+        $user = User::factory()
+            ->hasSettings()
+            ->create();
+
+        $brother = UploadedFile::fake()
+            ->create('brother.pdf', 120000, 'application/pdf');
+
+        $sister = UploadedFile::fake()
+            ->create('sister.pdf', 120000, 'application/pdf');
+
+        $this
+            ->actingAs($user)
+            ->postJson('/api/upload', [
+                'filename'  => $brother->name,
+                'file'      => $brother,
+                'path'      => "/Folder/Brother/$brother->name",
+                'parent_id' => null,
+                'is_last'   => 'true',
+            ])->assertStatus(201);
+
+        $this
+            ->actingAs($user)
+            ->postJson('/api/upload', [
+                'filename'  => $sister->name,
+                'file'      => $sister,
+                'path'      => "/Folder/Sister/$sister->name",
+                'parent_id' => null,
+                'is_last'   => 'true',
+            ])->assertStatus(201);
+
+        $brotherFile = File::where('name', 'brother.pdf')->first();
+        $sisterFile = File::where('name', 'sister.pdf')->first();
+
+        $brotherFolder = Folder::where('name', 'Brother')->first();
+        $sisterFolder = Folder::where('name', 'Sister')->first();
+
+        // Check correctness of siblings file appended to the folder
+        $this->assertEquals($brotherFolder->id, $brotherFile->parent_id);
+        $this->assertEquals($sisterFolder->id, $sisterFile->parent_id);
+
+        $home = Folder::where('name', 'Folder')->first();
+
+        // Check correctness of siblings folders appended to the home folder
+        $this->assertEquals($home->id, $brotherFolder->parent_id);
+        $this->assertEquals($home->id, $sisterFolder->parent_id);
+    }
+}