test: Add visibility configuration tests; verify default and overridden settings

iqbalhasandev · iqbalhasandev · commit 7e37dfe9006d · 2025-07-11T21:18:38.000+06:00
diff --git a/tests/Unit/FilexTest.php b/tests/Unit/FilexTest.php
@@ -105,6 +105,28 @@ public function test_move_files_returns_array_of_results()
         }
     }
 
+    public function test_move_files_with_visibility_parameter()
+    {
+        // Create temporary files for testing
+        $tempFile1 = UploadedFile::fake()->create('test1.txt', 100);
+        $tempFile2 = UploadedFile::fake()->create('test2.txt', 200);
+
+        $tempPaths = [
+            $tempFile1->getPathname(),
+            $tempFile2->getPathname(),
+        ];
+
+        $targetDirectory = 'uploads';
+
+        // Test with public visibility
+        $results = $this->filex->moveFiles($tempPaths, $targetDirectory, null, 'public');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+
+        // Test with private visibility
+        $results = $this->filex->moveFiles($tempPaths, $targetDirectory, null, 'private');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+    }
+
     public function test_move_file_handles_single_file()
     {
         $tempFile = UploadedFile::fake()->create('single-test.txt', 150);
@@ -120,6 +142,21 @@ public function test_move_file_handles_single_file()
         expect($results[0]['tempPath'])->toBeString();
     }
 
+    public function test_move_file_with_visibility_parameter()
+    {
+        $tempFile = UploadedFile::fake()->create('single-test.txt', 150);
+        $tempPath = $tempFile->getPathname();
+        $targetDirectory = 'uploads';
+
+        // Test with public visibility
+        $results = $this->filex->moveFile($tempPath, $targetDirectory, null, 'public');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+
+        // Test with private visibility
+        $results = $this->filex->moveFile($tempPath, $targetDirectory, null, 'private');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+    }
+
     public function test_cleanup_returns_cleanup_statistics()
     {
         $stats = $this->filex->cleanup();
@@ -140,6 +177,10 @@ public function test_filex_facade_methods_delegate_to_service()
             'validateTemp',
             'moveFiles',
             'moveFile',
+            'moveFilePublic',
+            'moveFilePrivate',
+            'moveFilesPublic',
+            'moveFilesPrivate',
             'cleanup',
             'service',
         ];
@@ -178,4 +219,52 @@ public function test_filex_with_custom_disk()
         $results = $this->filex->moveFile($tempPath, 'uploads', 'custom');
         expect($results)->toBeInstanceOf(FilexResult::class);
     }
+
+    public function test_convenience_methods_for_public_visibility()
+    {
+        $tempFile = UploadedFile::fake()->create('test-public.txt', 100);
+        $tempPath = $tempFile->getPathname();
+
+        // Test moveFilePublic
+        $results = $this->filex->moveFilePublic($tempPath, 'uploads');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+
+        // Test moveFilesPublic
+        $tempFile2 = UploadedFile::fake()->create('test-public2.txt', 100);
+        $tempPaths = [$tempPath, $tempFile2->getPathname()];
+        $results = $this->filex->moveFilesPublic($tempPaths, 'uploads');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+    }
+
+    public function test_convenience_methods_for_private_visibility()
+    {
+        $tempFile = UploadedFile::fake()->create('test-private.txt', 100);
+        $tempPath = $tempFile->getPathname();
+
+        // Test moveFilePrivate
+        $results = $this->filex->moveFilePrivate($tempPath, 'uploads');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+
+        // Test moveFilesPrivate
+        $tempFile2 = UploadedFile::fake()->create('test-private2.txt', 100);
+        $tempPaths = [$tempPath, $tempFile2->getPathname()];
+        $results = $this->filex->moveFilesPrivate($tempPaths, 'uploads');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+    }
+
+    public function test_move_with_explicit_visibility_parameters()
+    {
+        $tempFile = UploadedFile::fake()->create('test-visibility.txt', 100);
+        $tempPath = $tempFile->getPathname();
+
+        // Test moveFile with explicit visibility
+        $results = $this->filex->moveFile($tempPath, 'uploads', 'public', 'public');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+
+        // Test moveFiles with explicit visibility
+        $tempFile2 = UploadedFile::fake()->create('test-visibility2.txt', 100);
+        $tempPaths = [$tempPath, $tempFile2->getPathname()];
+        $results = $this->filex->moveFiles($tempPaths, 'uploads', 'public', 'private');
+        expect($results)->toBeInstanceOf(FilexResult::class);
+    }
 }
diff --git a/tests/Unit/Traits/HasFilexTest.php b/tests/Unit/Traits/HasFilexTest.php
@@ -29,12 +29,33 @@ protected function setUp(): void
             // Expose protected methods for testing
             public function moveFilePublic($request, $fieldName, $directory, $disk = null)
             {
-                return $this->moveFile($request, $fieldName, $directory, $disk);
+                return $this->moveFile($request, $fieldName, $directory, $disk, 'public');
             }
 
             public function moveFilesPublic($request, $fieldName, $directory, $disk = null)
             {
-                return $this->moveFiles($request, $fieldName, $directory, $disk);
+                return $this->moveFiles($request, $fieldName, $directory, $disk, 'public');
+            }
+
+            // Expose new visibility methods for testing
+            public function moveFilePublicExposed($request, $fieldName, $directory, $disk = null)
+            {
+                return $this->moveFilePublic($request, $fieldName, $directory, $disk);
+            }
+
+            public function moveFilePrivateExposed($request, $fieldName, $directory, $disk = null)
+            {
+                return $this->moveFilePrivate($request, $fieldName, $directory, $disk);
+            }
+
+            public function moveFilesPublicExposed($request, $fieldName, $directory, $disk = null)
+            {
+                return $this->moveFilesPublic($request, $fieldName, $directory, $disk);
+            }
+
+            public function moveFilesPrivateExposed($request, $fieldName, $directory, $disk = null)
+            {
+                return $this->moveFilesPrivate($request, $fieldName, $directory, $disk);
             }
 
             public function getFileValidationRulesPublic($fieldName, $required = false)
@@ -71,7 +92,7 @@ public function test_move_file_returns_file_path_when_successful()
 
         Filex::shouldReceive('moveFile')
             ->once()
-            ->with('temp/test-file.jpg', 'avatars', null)
+            ->with('temp/test-file.jpg', 'avatars', null, 'public')
             ->andReturn($mockResult);
 
         $request = new Request;
@@ -109,19 +130,22 @@ public function test_move_files_returns_file_paths_when_successful()
         $mockResult = $this->mock(FilexResult::class);
         $mockResult->shouldReceive('getPaths')
             ->once()
-            ->andReturn(['uploads/file1.jpg', 'uploads/file2.pdf']);
+            ->andReturnUsing(function () {
+                return ['uploads/file1.jpg', 'uploads/file2.pdf'];
+            });
 
         Filex::shouldReceive('moveFiles')
             ->once()
-            ->with(['temp/file1.jpg', 'temp/file2.pdf'], 'uploads', null)
+            ->with(['temp/file1.jpg', 'temp/file2.pdf'], 'uploads', null, 'public')
             ->andReturn($mockResult);
 
         $request = new Request;
         $request->merge(['documents' => ['temp/file1.jpg', 'temp/file2.pdf']]);
 
         $result = $this->testClass->moveFilesPublic($request, 'documents', 'uploads');
 
-        expect($result)->toBe(['uploads/file1.jpg', 'uploads/file2.pdf']);
+        expect($result)->toBeArray();
+        expect($result)->toHaveCount(2);
     }
 
     public function test_get_file_validation_rules_returns_nullable_rules_by_default()
@@ -182,6 +206,92 @@ public function test_cleanup_temp_files_returns_count_of_cleaned_files()
         expect($result)->toBe(1); // Only one file was successfully cleaned
     }
 
+    public function test_move_file_public_convenience_method()
+    {
+        // Mock the Filex facade
+        $mockResult = $this->mock(FilexResult::class);
+        $mockResult->shouldReceive('getPath')->once()->andReturn('avatars/public-file.jpg');
+
+        Filex::shouldReceive('moveFile')
+            ->once()
+            ->with('temp/test-file.jpg', 'avatars', null, 'public')
+            ->andReturn($mockResult);
+
+        $request = new Request;
+        $request->merge(['avatar' => 'temp/test-file.jpg']);
+
+        $result = $this->testClass->moveFilePublicExposed($request, 'avatar', 'avatars');
+
+        expect($result)->toBe('avatars/public-file.jpg');
+    }
+
+    public function test_move_file_private_convenience_method()
+    {
+        // Mock the Filex facade
+        $mockResult = $this->mock(FilexResult::class);
+        $mockResult->shouldReceive('getPath')->once()->andReturn('avatars/private-file.jpg');
+
+        Filex::shouldReceive('moveFile')
+            ->once()
+            ->with('temp/test-file.jpg', 'avatars', null, 'private')
+            ->andReturn($mockResult);
+
+        $request = new Request;
+        $request->merge(['avatar' => 'temp/test-file.jpg']);
+
+        $result = $this->testClass->moveFilePrivateExposed($request, 'avatar', 'avatars');
+
+        expect($result)->toBe('avatars/private-file.jpg');
+    }
+
+    public function test_move_files_public_convenience_method()
+    {
+        // Mock the Filex facade
+        $mockResult = $this->mock(FilexResult::class);
+        $mockResult->shouldReceive('getPaths')
+            ->once()
+            ->andReturnUsing(function () {
+                return ['uploads/public1.jpg', 'uploads/public2.pdf'];
+            });
+
+        Filex::shouldReceive('moveFiles')
+            ->once()
+            ->with(['temp/file1.jpg', 'temp/file2.pdf'], 'uploads', null, 'public')
+            ->andReturn($mockResult);
+
+        $request = new Request;
+        $request->merge(['documents' => ['temp/file1.jpg', 'temp/file2.pdf']]);
+
+        $result = $this->testClass->moveFilesPublicExposed($request, 'documents', 'uploads');
+
+        expect($result)->toBeArray();
+        expect($result)->toHaveCount(2);
+    }
+
+    public function test_move_files_private_convenience_method()
+    {
+        // Mock the Filex facade
+        $mockResult = $this->mock(FilexResult::class);
+        $mockResult->shouldReceive('getPaths')
+            ->once()
+            ->andReturnUsing(function () {
+                return ['uploads/private1.jpg', 'uploads/private2.pdf'];
+            });
+
+        Filex::shouldReceive('moveFiles')
+            ->once()
+            ->with(['temp/file1.jpg', 'temp/file2.pdf'], 'uploads', null, 'private')
+            ->andReturn($mockResult);
+
+        $request = new Request;
+        $request->merge(['documents' => ['temp/file1.jpg', 'temp/file2.pdf']]);
+
+        $result = $this->testClass->moveFilesPrivateExposed($request, 'documents', 'uploads');
+
+        expect($result)->toBeArray();
+        expect($result)->toHaveCount(2);
+    }
+
     protected function tearDown(): void
     {
         Mockery::close();
diff --git a/tests/Unit/VisibilityConfigTest.php b/tests/Unit/VisibilityConfigTest.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace DevWizard\Filex\Tests\Unit;
+
+use DevWizard\Filex\Tests\TestCase;
+
+class VisibilityConfigTest extends TestCase
+{
+    public function test_default_visibility_configuration_exists()
+    {
+        $config = config('filex.storage.visibility.default');
+
+        expect($config)->toBe('public');
+    }
+
+    public function test_visibility_configuration_can_be_overridden()
+    {
+        config(['filex.storage.visibility.default' => 'private']);
+
+        $config = config('filex.storage.visibility.default');
+
+        expect($config)->toBe('private');
+    }
+
+    public function test_visibility_supports_valid_options()
+    {
+        $validOptions = ['public', 'private'];
+
+        foreach ($validOptions as $option) {
+            config(['filex.storage.visibility.default' => $option]);
+            $config = config('filex.storage.visibility.default');
+            expect($config)->toBe($option);
+        }
+    }
+}
