Almacenamiento de Archivos

• Introducción
• Configuración
  • El Driver Local
  • El Disco Público
  • Requisitos Previos del Driver
  • Sistemas de Archivos con Ámbito y Solo Lectura
  • Sistemas de Archivos Compatibles con Amazon S3
• Obteniendo Instancias de Disco
  • Discos Bajo Demanda
• Recuperando Archivos
  • Descargando Archivos
  • URLs de Archivos
  • URLs Temporales
  • Metadatos de Archivos
• Almacenando Archivos
  • Prependiendo y Añadiendo a Archivos
  • Copiando y Moviendo Archivos
  • Streaming Automático
  • Subidas de Archivos
  • Visibilidad de Archivos
• Eliminando Archivos
• Directorios
• Pruebas
• Sistemas de Archivos Personalizados

#Introducción

Laravel ofrece una potente abstracción del sistema de archivos gracias al excelente paquete PHP Flysystem creado por Frank de Jonge. La integración de Laravel con Flysystem proporciona drivers sencillos para trabajar con sistemas de archivos locales, SFTP y Amazon S3. Aún mejor, es increíblemente fácil cambiar entre estas opciones de almacenamiento entre su máquina local de desarrollo y el servidor de producción, ya que la API permanece igual para cada sistema.

#Configuración

El archivo de configuración del sistema de archivos de Laravel se encuentra en config/filesystems.php. Dentro de este archivo, puede configurar todos sus "discos" del sistema de archivos. Cada disco representa un driver de almacenamiento particular y una ubicación de almacenamiento. Se incluyen configuraciones de ejemplo para cada driver soportado en el archivo de configuración para que pueda modificar la configuración según sus preferencias y credenciales de almacenamiento.

El driver local interactúa con archivos almacenados localmente en el servidor que ejecuta la aplicación Laravel, mientras que el driver s3 se usa para escribir en el servicio de almacenamiento en la nube Amazon S3.

#El Driver Local

Al usar el driver local, todas las operaciones de archivos son relativas al directorio root definido en su archivo de configuración filesystems. Por defecto, este valor está establecido en el directorio storage/app. Por lo tanto, el siguiente método escribiría en storage/app/example.txt:

use Illuminate\Support\Facades\Storage;

Storage::disk('local')->put('example.txt', 'Contents');

#El Disco Público

El disco public incluido en el archivo de configuración filesystems de su aplicación está destinado a archivos que serán accesibles públicamente. Por defecto, el disco public usa el driver local y almacena sus archivos en storage/app/public.

Para hacer estos archivos accesibles desde la web, debe crear un enlace simbólico desde public/storage hacia storage/app/public. Utilizar esta convención de carpetas mantendrá sus archivos accesibles públicamente en un solo directorio que puede ser fácilmente compartido entre despliegues cuando use sistemas de despliegue sin tiempo de inactividad como Envoyer.

Para crear el enlace simbólico, puede usar el comando Artisan storage:link:

php artisan storage:link

Una vez que un archivo ha sido almacenado y el enlace simbólico creado, puede generar una URL para los archivos usando el helper asset:

echo asset('storage/file.txt');

Puede configurar enlaces simbólicos adicionales en su archivo de configuración filesystems. Cada uno de los enlaces configurados será creado cuando ejecute el comando storage:link:

'links' => [
    public_path('storage') => storage_path('app/public'),
    public_path('images') => storage_path('app/images'),
],

El comando storage:unlink puede usarse para eliminar sus enlaces simbólicos configurados:

php artisan storage:unlink

#Requisitos Previos del Driver

#Configuración del Driver S3

Antes de usar el driver S3, deberá instalar el paquete Flysystem S3 mediante el gestor de paquetes Composer:

composer require league/flysystem-aws-s3-v3 "^3.0" --with-all-dependencies

La información de configuración del driver S3 se encuentra en su archivo de configuración config/filesystems.php. Este archivo contiene un arreglo de configuración de ejemplo para un driver S3. Puede modificar este arreglo con su propia configuración y credenciales de S3. Para mayor comodidad, estas variables de entorno coinciden con la convención de nombres usada por la CLI de AWS.

#Configuración del Driver FTP

Antes de usar el driver FTP, deberá instalar el paquete Flysystem FTP mediante el gestor de paquetes Composer:

composer require league/flysystem-ftp "^3.0"

Las integraciones de Flysystem de Laravel funcionan muy bien con FTP; sin embargo, no se incluye una configuración de ejemplo en el archivo de configuración predeterminado filesystems.php. Si necesita configurar un sistema de archivos FTP, puede usar el siguiente ejemplo de configuración:

'ftp' => [
    'driver' => 'ftp',
    'host' => env('FTP_HOST'),
    'username' => env('FTP_USERNAME'),
    'password' => env('FTP_PASSWORD'),

    // Configuraciones FTP opcionales...
    // 'port' => env('FTP_PORT', 21),
    // 'root' => env('FTP_ROOT'),
    // 'passive' => true,
    // 'ssl' => true,
    // 'timeout' => 30,
],

#Configuración del Driver SFTP

Antes de usar el driver SFTP, deberá instalar el paquete Flysystem SFTP mediante el gestor de paquetes Composer:

composer require league/flysystem-sftp-v3 "^3.0"

Las integraciones de Flysystem de Laravel funcionan muy bien con SFTP; sin embargo, no se incluye una configuración de ejemplo en el archivo de configuración predeterminado filesystems.php. Si necesita configurar un sistema de archivos SFTP, puede usar el siguiente ejemplo de configuración:

'sftp' => [
    'driver' => 'sftp',
    'host' => env('SFTP_HOST'),

    // Configuraciones para autenticación básica...
    'username' => env('SFTP_USERNAME'),
    'password' => env('SFTP_PASSWORD'),

    // Configuraciones para autenticación basada en clave SSH con contraseña de cifrado...
    'privateKey' => env('SFTP_PRIVATE_KEY'),
    'passphrase' => env('SFTP_PASSPHRASE'),

    // Configuraciones para permisos de archivos / directorios...
    'visibility' => 'private', // `private` = 0600, `public` = 0644
    'directory_visibility' => 'private', // `private` = 0700, `public` = 0755

    // Configuraciones SFTP opcionales...
    // 'hostFingerprint' => env('SFTP_HOST_FINGERPRINT'),
    // 'maxTries' => 4,
    // 'passphrase' => env('SFTP_PASSPHRASE'),
    // 'port' => env('SFTP_PORT', 22),
    // 'root' => env('SFTP_ROOT', ''),
    // 'timeout' => 30,
    // 'useAgent' => true,
],

#Sistemas de Archivos con Ámbito y Solo Lectura

Los discos con ámbito le permiten definir un sistema de archivos donde todas las rutas se prefijan automáticamente con un prefijo de ruta dado. Antes de crear un disco de sistema de archivos con ámbito, deberá instalar un paquete adicional de Flysystem mediante el gestor de paquetes Composer:

composer require league/flysystem-path-prefixing "^3.0"

Puede crear una instancia con ámbito de ruta de cualquier disco de sistema de archivos existente definiendo un disco que utilice el driver scoped. Por ejemplo, puede crear un disco que delimite su disco s3 existente a un prefijo de ruta específico, y entonces cada operación de archivo usando su disco con ámbito utilizará el prefijo especificado:

's3-videos' => [
    'driver' => 'scoped',
    'disk' => 's3',
    'prefix' => 'path/to/videos',
],

Los discos "solo lectura" le permiten crear discos de sistema de archivos que no permiten operaciones de escritura. Antes de usar la opción de configuración read-only, deberá instalar un paquete adicional de Flysystem mediante el gestor de paquetes Composer:

composer require league/flysystem-read-only "^3.0"

Luego, puede incluir la opción de configuración read-only en uno o más arreglos de configuración de sus discos:

's3-videos' => [
    'driver' => 's3',
    // ...
    'read-only' => true,
],

#Sistemas de Archivos Compatibles con Amazon S3

Por defecto, el archivo de configuración filesystems de su aplicación contiene una configuración de disco para el disco s3. Además de usar este disco para interactuar con Amazon S3, puede usarlo para interactuar con cualquier servicio de almacenamiento compatible con S3 como MinIO o DigitalOcean Spaces.

Normalmente, después de actualizar las credenciales del disco para que coincidan con las credenciales del servicio que planea usar, solo necesita actualizar el valor de la opción de configuración endpoint. El valor de esta opción normalmente se define mediante la variable de entorno AWS_ENDPOINT:

'endpoint' => env('AWS_ENDPOINT', 'https://minio:9000'),

#MinIO

Para que la integración de Flysystem de Laravel genere URLs correctas al usar MinIO, debe definir la variable de entorno AWS_URL para que coincida con la URL local de su aplicación e incluya el nombre del bucket en la ruta de la URL:

AWS_URL=http://localhost:9000/local

#Obteniendo Instancias de Disco

La fachada Storage puede usarse para interactuar con cualquiera de sus discos configurados. Por ejemplo, puede usar el método put en la fachada para almacenar un avatar en el disco predeterminado. Si llama a métodos en la fachada Storage sin llamar primero al método disk, el método se pasará automáticamente al disco predeterminado:

use Illuminate\Support\Facades\Storage;

Storage::put('avatars/1', $content);

Si su aplicación interactúa con múltiples discos, puede usar el método disk en la fachada Storage para trabajar con archivos en un disco particular:

Storage::disk('s3')->put('avatars/1', $content);

#Discos Bajo Demanda

A veces puede desear crear un disco en tiempo de ejecución usando una configuración dada sin que esa configuración esté presente en el archivo de configuración filesystems de su aplicación. Para lograr esto, puede pasar un arreglo de configuración al método build de la fachada Storage:

use Illuminate\Support\Facades\Storage;

$disk = Storage::build([
    'driver' => 'local',
    'root' => '/path/to/root',
]);

$disk->put('image.jpg', $content);

#Recuperando Archivos

El método get puede usarse para recuperar el contenido de un archivo. El método devolverá el contenido en forma de cadena sin procesar. Recuerde, todas las rutas de archivos deben especificarse relativas a la ubicación "root" del disco:

$contents = Storage::get('file.jpg');

Si el archivo que está recuperando contiene JSON, puede usar el método json para obtener el archivo y decodificar su contenido:

$orders = Storage::json('orders.json');

El método exists puede usarse para determinar si un archivo existe en el disco:

if (Storage::disk('s3')->exists('file.jpg')) {
    // ...
}

El método missing puede usarse para determinar si un archivo falta en el disco:

if (Storage::disk('s3')->missing('file.jpg')) {
    // ...
}

#Descargando Archivos

El método download puede usarse para generar una respuesta que fuerza al navegador del usuario a descargar el archivo en la ruta dada. El método download acepta un nombre de archivo como segundo argumento, que determinará el nombre que verá el usuario al descargar el archivo. Finalmente, puede pasar un arreglo de encabezados HTTP como tercer argumento:

return Storage::download('file.jpg');

return Storage::download('file.jpg', $name, $headers);

#URLs de Archivos

Puede usar el método url para obtener la URL de un archivo dado. Si está usando el driver local, esto normalmente solo antepondrá /storage a la ruta dada y devolverá una URL relativa al archivo. Si está usando el driver s3, se devolverá la URL remota completamente calificada:

use Illuminate\Support\Facades\Storage;

$url = Storage::url('file.jpg');

Al usar el driver local, todos los archivos que deben ser accesibles públicamente deben colocarse en el directorio storage/app/public. Además, debe crear un enlace simbólico en public/storage que apunte al directorio storage/app/public.

#Personalización del Host de la URL

Si desea predefinir el host para las URLs generadas usando la fachada Storage, puede agregar una opción url al arreglo de configuración del disco:

'public' => [
    'driver' => 'local',
    'root' => storage_path('app/public'),
    'url' => env('APP_URL').'/storage',
    'visibility' => 'public',
],

#URLs Temporales

Usando el método temporaryUrl, puede crear URLs temporales para archivos almacenados usando el driver s3. Este método acepta una ruta y una instancia de DateTime que especifica cuándo debe expirar la URL:

use Illuminate\Support\Facades\Storage;

$url = Storage::temporaryUrl(
    'file.jpg', now()->addMinutes(5)
);

Si necesita especificar parámetros adicionales de solicitud S3, puede pasar un arreglo de parámetros de solicitud como tercer argumento al método temporaryUrl:

$url = Storage::temporaryUrl(
    'file.jpg',
    now()->addMinutes(5),
    [
        'ResponseContentType' => 'application/octet-stream',
        'ResponseContentDisposition' => 'attachment; filename=file2.jpg',
    ]
);

Si necesita personalizar cómo se crean las URLs temporales para un disco de almacenamiento específico, puede usar el método buildTemporaryUrlsUsing. Por ejemplo, esto puede ser útil si tiene un controlador que permite descargar archivos almacenados a través de un disco que normalmente no soporta URLs temporales. Usualmente, este método debe llamarse desde el método boot de un proveedor de servicios:

<?php

namespace App\Providers;

use DateTime;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\URL;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Inicializar cualquier servicio de la aplicación.
     */
    public function boot(): void
    {
        Storage::disk('local')->buildTemporaryUrlsUsing(
            function (string $path, DateTime $expiration, array $options) {
                return URL::temporarySignedRoute(
                    'files.download',
                    $expiration,
                    array_merge($options, ['path' => $path])
                );
            }
        );
    }
}

#URLs Temporales para Subidas

Si necesita generar una URL temporal que pueda usarse para subir un archivo directamente desde su aplicación del lado cliente, puede usar el método temporaryUploadUrl. Este método acepta una ruta y una instancia de DateTime que especifica cuándo debe expirar la URL. El método temporaryUploadUrl devuelve un arreglo asociativo que puede desestructurarse en la URL de subida y los encabezados que deben incluirse con la solicitud de subida:

use Illuminate\Support\Facades\Storage;

['url' => $url, 'headers' => $headers] = Storage::temporaryUploadUrl(
    'file.jpg', now()->addMinutes(5)
);

Este método es especialmente útil en entornos serverless que requieren que la aplicación del lado cliente suba archivos directamente a un sistema de almacenamiento en la nube como Amazon S3.

#Metadatos de Archivos

Además de leer y escribir archivos, Laravel también puede proporcionar información sobre los archivos mismos. Por ejemplo, el método size puede usarse para obtener el tamaño de un archivo en bytes:

use Illuminate\Support\Facades\Storage;

$size = Storage::size('file.jpg');

El método lastModified devuelve la marca de tiempo UNIX de la última vez que se modificó el archivo:

$time = Storage::lastModified('file.jpg');

El tipo MIME de un archivo dado puede obtenerse mediante el método mimeType:

$mime = Storage::mimeType('file.jpg');

#Rutas de Archivos

Puede usar el método path para obtener la ruta de un archivo dado. Si está usando el driver local, esto devolverá la ruta absoluta al archivo. Si está usando el driver s3, este método devolverá la ruta relativa al archivo en el bucket S3:

use Illuminate\Support\Facades\Storage;

$path = Storage::path('file.jpg');

#Almacenando Archivos

El método put puede usarse para almacenar contenido de archivos en un disco. También puede pasar un resource PHP al método put, que usará el soporte de streaming subyacente de Flysystem. Recuerde, todas las rutas de archivos deben especificarse relativas a la ubicación "root" configurada para el disco:

use Illuminate\Support\Facades\Storage;

Storage::put('file.jpg', $contents);

Storage::put('file.jpg', $resource);

#Escrituras Fallidas

Si el método put (u otras operaciones de "escritura") no puede escribir el archivo en el disco, devolverá false:

if (! Storage::put('file.jpg', $contents)) {
    // El archivo no pudo ser escrito en el disco...
}

Si lo desea, puede definir la opción throw dentro del arreglo de configuración de su disco del sistema de archivos. Cuando esta opción está definida como true, los métodos de "escritura" como put lanzarán una instancia de League\Flysystem\UnableToWriteFile cuando fallen las operaciones de escritura:

'public' => [
    'driver' => 'local',
    // ...
    'throw' => true,
],

#Prependiendo y Añadiendo a Archivos

Los métodos prepend y append le permiten escribir al inicio o al final de un archivo:

Storage::prepend('file.log', 'Prepended Text');

Storage::append('file.log', 'Appended Text');

#Copiando y Moviendo Archivos

El método copy puede usarse para copiar un archivo existente a una nueva ubicación en el disco, mientras que el método move puede usarse para renombrar o mover un archivo existente a una nueva ubicación:

Storage::copy('old/file.jpg', 'new/file.jpg');

Storage::move('old/file.jpg', 'new/file.jpg');

#Streaming Automático

El streaming de archivos al almacenamiento ofrece un uso de memoria significativamente reducido. Si desea que Laravel gestione automáticamente el streaming de un archivo dado a su ubicación de almacenamiento, puede usar el método putFile o putFileAs. Este método acepta una instancia de Illuminate\Http\File o Illuminate\Http\UploadedFile y transmitirá automáticamente el archivo a la ubicación deseada:

use Illuminate\Http\File;
use Illuminate\Support\Facades\Storage;

// Generar automáticamente un ID único para el nombre del archivo...
$path = Storage::putFile('photos', new File('/path/to/photo'));

// Especificar manualmente un nombre de archivo...
$path = Storage::putFileAs('photos', new File('/path/to/photo'), 'photo.jpg');

Hay algunas cosas importantes que debe tener en cuenta sobre el método putFile. Note que solo especificamos un nombre de directorio y no un nombre de archivo. Por defecto, el método putFile generará un ID único para servir como nombre de archivo. La extensión del archivo se determinará examinando el tipo MIME del archivo. La ruta al archivo será devuelta por el método putFile para que pueda almacenar la ruta, incluyendo el nombre de archivo generado, en su base de datos.

Los métodos putFile y putFileAs también aceptan un argumento para especificar la "visibilidad" del archivo almacenado. Esto es particularmente útil si está almacenando el archivo en un disco en la nube como Amazon S3 y desea que el archivo sea accesible públicamente mediante URLs generadas:

Storage::putFile('photos', new File('/path/to/photo'), 'public');

#Subidas de Archivos

En aplicaciones web, uno de los casos de uso más comunes para almacenar archivos es guardar archivos subidos por usuarios, como fotos y documentos. Laravel facilita mucho almacenar archivos subidos usando el método store en una instancia de archivo subido. Llame al método store con la ruta en la que desea almacenar el archivo subido:

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

class UserAvatarController extends Controller
{
    /**
     * Actualizar el avatar del usuario.
     */
    public function update(Request $request): string
    {
        $path = $request->file('avatar')->store('avatars');

        return $path;
    }
}

Hay algunas cosas importantes que debe tener en cuenta sobre este ejemplo. Note que solo especificamos un nombre de directorio, no un nombre de archivo. Por defecto, el método store generará un ID único para servir como nombre de archivo. La extensión del archivo se determinará examinando el tipo MIME del archivo. La ruta al archivo será devuelta por el método store para que pueda almacenar la ruta, incluyendo el nombre de archivo generado, en su base de datos.

También puede llamar al método putFile en la fachada Storage para realizar la misma operación de almacenamiento de archivos que el ejemplo anterior:

$path = Storage::putFile('avatars', $request->file('avatar'));

#Especificando un Nombre de Archivo

Si no desea que se asigne automáticamente un nombre de archivo a su archivo almacenado, puede usar el método storeAs, que recibe la ruta, el nombre del archivo y el disco (opcional) como argumentos:

$path = $request->file('avatar')->storeAs(
    'avatars', $request->user()->id
);

También puede usar el método putFileAs en la fachada Storage, que realizará la misma operación de almacenamiento de archivos que el ejemplo anterior:

$path = Storage::putFileAs(
    'avatars', $request->file('avatar'), $request->user()->id
);

#Especificando un Disco

Por defecto, el método store de este archivo subido usará su disco predeterminado. Si desea especificar otro disco, pase el nombre del disco como segundo argumento al método store:

$path = $request->file('avatar')->store(
    'avatars/'.$request->user()->id, 's3'
);

Si está usando el método storeAs, puede pasar el nombre del disco como tercer argumento al método:

$path = $request->file('avatar')->storeAs(
    'avatars',
    $request->user()->id,
    's3'
);

#Otra Información del Archivo Subido

Si desea obtener el nombre original y la extensión del archivo subido, puede hacerlo usando los métodos getClientOriginalName y getClientOriginalExtension:

$file = $request->file('avatar');

$name = $file->getClientOriginalName();
$extension = $file->getClientOriginalExtension();

Sin embargo, tenga en cuenta que los métodos getClientOriginalName y getClientOriginalExtension se consideran inseguros, ya que el nombre y la extensión del archivo pueden ser manipulados por un usuario malintencionado. Por esta razón, normalmente debería preferir los métodos hashName y extension para obtener un nombre y una extensión para el archivo subido:

$file = $request->file('avatar');

$name = $file->hashName(); // Generar un nombre único y aleatorio...
$extension = $file->extension(); // Determinar la extensión del archivo basada en el tipo MIME del archivo...

#Visibilidad de Archivos

En la integración de Flysystem de Laravel, la "visibilidad" es una abstracción de los permisos de archivos a través de múltiples plataformas. Los archivos pueden declararse como public o private. Cuando un archivo se declara public, está indicando que el archivo debería ser generalmente accesible para otros. Por ejemplo, al usar el driver S3, puede obtener URLs para archivos public.

Puede establecer la visibilidad al escribir el archivo mediante el método put:

use Illuminate\Support\Facades\Storage;

Storage::put('file.jpg', $contents, 'public');

Si el archivo ya ha sido almacenado, su visibilidad puede obtenerse y establecerse mediante los métodos getVisibility y setVisibility:

$visibility = Storage::getVisibility('file.jpg');

Storage::setVisibility('file.jpg', 'public');

Al interactuar con archivos subidos, puede usar los métodos storePublicly y storePubliclyAs para almacenar el archivo subido con visibilidad public:

$path = $request->file('avatar')->storePublicly('avatars', 's3');

$path = $request->file('avatar')->storePubliclyAs(
    'avatars',
    $request->user()->id,
    's3'
);

#Archivos Locales y Visibilidad

Al usar el driver local, la visibilidad public se traduce en permisos 0755 para directorios y 0644 para archivos. Puede modificar los mapeos de permisos en el archivo de configuración filesystems de su aplicación:

'local' => [
    'driver' => 'local',
    'root' => storage_path('app'),
    'permissions' => [
        'file' => [
            'public' => 0644,
            'private' => 0600,
        ],
        'dir' => [
            'public' => 0755,
            'private' => 0700,
        ],
    ],
],

#Eliminando Archivos

El método delete acepta un nombre de archivo único o un arreglo de archivos para eliminar:

use Illuminate\Support\Facades\Storage;

Storage::delete('file.jpg');

Storage::delete(['file.jpg', 'file2.jpg']);

Si es necesario, puede especificar el disco del que se debe eliminar el archivo:

use Illuminate\Support\Facades\Storage;

Storage::disk('s3')->delete('path/file.jpg');

#Directorios

#Obtener Todos los Archivos Dentro de un Directorio

El método files devuelve un arreglo con todos los archivos en un directorio dado. Si desea obtener una lista de todos los archivos dentro de un directorio dado incluyendo todos los subdirectorios, puede usar el método allFiles:

use Illuminate\Support\Facades\Storage;

$files = Storage::files($directory);

$files = Storage::allFiles($directory);

#Obtener Todos los Directorios Dentro de un Directorio

El método directories devuelve un arreglo con todos los directorios dentro de un directorio dado. Además, puede usar el método allDirectories para obtener una lista de todos los directorios dentro de un directorio dado y todos sus subdirectorios:

$directories = Storage::directories($directory);

$directories = Storage::allDirectories($directory);

#Crear un Directorio

El método makeDirectory creará el directorio dado, incluyendo cualquier subdirectorio necesario:

Storage::makeDirectory($directory);

#Eliminar un Directorio

Finalmente, el método deleteDirectory puede usarse para eliminar un directorio y todos sus archivos:

Storage::deleteDirectory($directory);

#Pruebas

El método fake de la fachada Storage le permite generar fácilmente un disco falso que, combinado con las utilidades de generación de archivos de la clase Illuminate\Http\UploadedFile, simplifica enormemente las pruebas de subidas de archivos. Por ejemplo:

<?php

namespace Tests\Feature;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_albums_can_be_uploaded(): void
    {
        Storage::fake('photos');

        $response = $this->json('POST', '/photos', [
            UploadedFile::fake()->image('photo1.jpg'),
            UploadedFile::fake()->image('photo2.jpg')
        ]);

        // Asegurar que uno o más archivos fueron almacenados...
        Storage::disk('photos')->assertExists('photo1.jpg');
        Storage::disk('photos')->assertExists(['photo1.jpg', 'photo2.jpg']);

        // Asegurar que uno o más archivos no fueron almacenados...
        Storage::disk('photos')->assertMissing('missing.jpg');
        Storage::disk('photos')->assertMissing(['missing.jpg', 'non-existing.jpg']);

        // Asegurar que un directorio dado está vacío...
        Storage::disk('photos')->assertDirectoryEmpty('/wallpapers');
    }
}

Por defecto, el método fake eliminará todos los archivos en su directorio temporal. Si desea conservar estos archivos, puede usar el método "persistentFake" en su lugar. Para más información sobre pruebas de subidas de archivos, puede consultar la documentación de pruebas HTTP sobre subidas de archivos.

#Sistemas de Archivos Personalizados

La integración de Flysystem de Laravel ofrece soporte para varios "drivers" por defecto; sin embargo, Flysystem no se limita a estos y tiene adaptadores para muchos otros sistemas de almacenamiento. Puede crear un driver personalizado si desea usar uno de estos adaptadores adicionales en su aplicación Laravel.

Para definir un sistema de archivos personalizado necesitará un adaptador Flysystem. Añadamos un adaptador de Dropbox mantenido por la comunidad a nuestro proyecto:

composer require spatie/flysystem-dropbox

Luego, puede registrar el driver dentro del método boot de uno de los proveedores de servicios de su aplicación. Para lograr esto, debe usar el método extend de la fachada Storage:

<?php

namespace App\Providers;

use Illuminate\Contracts\Foundation\Application;
use Illuminate\Filesystem\FilesystemAdapter;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\ServiceProvider;
use League\Flysystem\Filesystem;
use Spatie\Dropbox\Client as DropboxClient;
use Spatie\FlysystemDropbox\DropboxAdapter;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Registrar cualquier servicio de la aplicación.
     */
    public function register(): void
    {
        // ...
    }

    /**
     * Inicializar cualquier servicio de la aplicación.
     */
    public function boot(): void
    {
        Storage::extend('dropbox', function (Application $app, array $config) {
            $adapter = new DropboxAdapter(new DropboxClient(
                $config['authorization_token']
            ));

            return new FilesystemAdapter(
                new Filesystem($adapter, $config),
                $adapter,
                $config
            );
        });
    }
}

El primer argumento del método extend es el nombre del driver y el segundo es una función anónima que recibe las variables $app y $config. La función debe devolver una instancia de Illuminate\Filesystem\FilesystemAdapter. La variable $config contiene los valores definidos en config/filesystems.php para el disco especificado.

Una vez que haya creado y registrado el proveedor de servicios de la extensión, puede usar el driver dropbox en su archivo de configuración config/filesystems.php.