English | العربية | বাংলা | Bosanski | Deutsch | Español | Français | हिन्दी | Italiano | 日本語 | 한국어 | मराठी | Português | Русский | Kiswahili | தமிழ் | తెలుగు | Türkçe | اردو | Tiếng Việt | 中文

• Introduction
  • Fonctionnalités clés
  • Exemple
• Installation
  • Exigences
  • Dépendances optionnelles
• Utilisation
  • Flux de travail de base
  • Configuration de stockage
  • Configuration de la concurrence
  • Nommage de fichiers
  • Initialisation pour la reproductibilité
• Générateurs
  • Générateurs d'images
  • Générateur de texte
  • Générateur CSV
  • Générateur binaire
  • Générateur d'e-mail
• Utilisation avancée
  • Générateurs personnalisés
  • Classes de configuration
  • Conseils de performance
• Configuration
  • Méthodes de configuration globale
• Directives de Support
  • Support Axé sur la Communauté
  • Bugs et Priorisation des Fonctionnalités
• Licence - Licence MIT

🔗Introduction

Faker Storage est un package PHP haute performance conçu pour générer et stocker efficacement de grands volumes de fichiers de données fictives. Construit avec la concurrence à l'esprit, il exploite Swoole ou PCNTL pour générer des milliers de fichiers en parallèle, ce qui le rend idéal pour les tests de charge, les environnements de développement et la mise en benchmark des systèmes de stockage.

Le package fournit une API fluide pour générer divers types de fichiers, y compris des images (PNG, JPG, GIF, BMP, WEBP, AVIF), des fichiers texte, des fichiers CSV, des données binaires et des e-mails conformes à RFC822. Chaque générateur produit une sortie déterministe lorsqu'il est initialisé avec une graine, garantissant des données de test reproductibles à travers les environnements.

🔗Fonctionnalités clés

• Concurrence haute performance : Sélection automatique entre Swoole (coroutines) et PCNTL (forking de processus) pour la génération de fichiers en parallèle
• Généraux de fichiers multiples : Prise en charge intégrée pour les images, texte, CSV, données binaires et fichiers e-mail
• Sortie déterministe : La génération basée sur une graine assure des résultats reproductibles
• Stockage flexible : Fonctionne avec n'importe quel adaptateur League Flysystem (local, S3, etc.)
• Nommage de fichiers personnalisable : Génération de noms basée sur des closures avec un contrôle complet
• Prise en charge des images : Plusieurs formats avec dimensions et compression configurables
• Génération d'e-mails : E-mails conformes à RFC822 avec pièces jointes et support MIME

🔗Exemple

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Générer 1000 images PNG avec 10 workers concurrents
Faker::make(Png::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->basePath('images')
    ->count(1000)
    ->concurrency(10)
    ->seed(42)
    ->generate();
 
// Générer des fichiers CSV
use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)
    ->rows(100, 500)
    ->delimiter(',')
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(50)
    ->generate();
 
// Générer des e-mails avec pièces jointes
use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)
    ->sentences(2, 4)
    ->withAttachment(Png::class, 1, 3)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(100)
    ->generate();

🔗Installation

Installez le package via Composer :

composer require defectivecode/faker-storage

🔗Exigences

• PHP >= 8.4
• ext-gd (pour la génération d'images)
• ext-swoole (optionnel, pour de meilleures performances)
• ext-pcntl (solution de repli pour la concurrence)

🔗Dépendances optionnelles

Pour des performances optimales, installez l'extension Swoole :

pecl install swoole

Le package utilisera automatiquement Swoole si disponible, sinon il utilisera PCNTL.

🔗Utilisation

🔗Flux de travail de base

Tous les générateurs suivent le même schéma :

1. Créer une instance Faker avec un générateur
2. Configurer le générateur (optionnel)
3. Définir la destination de stockage
4. Configurer la concurrence et le nombre
5. Générer des fichiers

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Text;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)          // Configuration spécifique au générateur
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Les fichiers seront dans /storage/documents/
    ->count(100)                 // Générer 100 fichiers
    ->concurrency(4)             // Utiliser 4 workers
    ->seed(123)                  // Pour une sortie déterministe
    ->generate();

🔗Configuration de stockage

Utilisation de Flysystem

Faker Storage utilise League Flysystem pour l'abstraction de stockage :

use League\Flysystem\Filesystem;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Stockage local
$filesystem = new Filesystem(new LocalFilesystemAdapter('/path/to/storage'));
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->generate();

Stockage AWS S3

use Aws\S3\S3Client;
use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
 
$client = new S3Client([
    'credentials' => [
        'key'    => 'your-key',
        'secret' => 'your-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'your-bucket-name');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

Options de disque

Transmettez des options supplémentaires à l'adaptateur de fichiers :

Faker::make(Png::class)
    ->toDisk($filesystem)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
        'CacheControl' => 'max-age=31536000',
    ])
    ->generate();

🔗Configuration de la concurrence

Contrôlez l'exécution parallèle avec la méthode concurrency() :

// Utiliser 10 threads/processus de worker
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Spécifique à Swoole : Définir à la fois les threads et les coroutines par thread
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 workers, 8 coroutines chacun
    ->generate();

🔗Nommage de fichiers

Nommage par défaut

Par défaut, les fichiers sont nommés à l'aide de UUID v4 :

// Génère : e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

Générateurs de noms intégrés

use DefectiveCode\Faker\NameGenerator;
 
// Basé sur UUID (par défaut)
NameGenerator::setDefault('uuid'); // Génère : e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// Numérotation séquentielle
NameGenerator::setDefault('sequence'); // Génère : 1.png, 2.png, 3.png, ...

Nommage personnalisé

Fournissez une closure pour personnaliser les noms de fichiers :

use DefectiveCode\Faker\NameGenerator;
 
// Closure personnalisée
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// Nommage basé sur la date
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

🔗Initialisation pour la reproductibilité

Définissez une graine pour générer les mêmes fichiers à travers les exécutions :

Faker::make(Png::class)
    ->seed(42)
    ->count(10)
    ->generate();

Chaque fichier obtient une graine déterministe unique dérivée de la graine de base et de l'index du fichier.

🔗Générateurs

🔗Générateurs d'images

Tous les générateurs d'images prennent en charge la configuration de dimensions et de qualité.

PNG

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px
    ->withAlpha(true)           // Activer le canal alpha/transparence
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5
    ->toDisk($filesystem)
    ->generate();

JPG

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5
    ->toDisk($filesystem)
    ->generate();

GIF

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px
    ->withAlpha(true)           // Activer le canal alpha/transparence
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5
    ->toDisk($filesystem)
    ->generate();

BMP

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5
    ->toDisk($filesystem)
    ->generate();

WEBP

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px
    ->withAlpha(true)           // Activer le canal alpha/transparence
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5
    ->toDisk($filesystem)
    ->generate();

AVIF

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px
    ->withAlpha(true)           // Activer le canal alpha/transparence
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5
    ->toDisk($filesystem)
    ->generate();

Image aléatoire

Génère un format d'image aléatoire :

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // Aléatoire parmi : AVIF, BMP, GIF, JPEG, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // Aléatoire parmi : AVIF, GIF, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();

🔗Générateur de texte

Générez des fichiers texte brut avec des paragraphes :

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // 5-10 paragraphes par fichier
    ->sentences(3, 6)           // 3-6 phrases par paragraphe
    ->toDisk($filesystem)
    ->generate();

Exemple de sortie :

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

🔗Générateur CSV

Générez des fichiers CSV avec des données aléatoires :

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 colonnes
    ->rows(100, 500)            // 100-500 lignes
    ->delimiter(',')            // Délimiteur de colonne
    ->enclosure('"')            // Enclosure de champ
    ->escape('\\')              // Caractère d'échappement
    ->eol("\n")                 // Fin de ligne
    ->toDisk($filesystem)
    ->generate();

Exemple de sortie :

"John Doe","john@example.com","555-1234","New York","Engineer"
"Jane Smith","jane@example.com","555-5678","Los Angeles","Designer"
"Bob Johnson","bob@example.com","555-9012","Chicago","Manager"

🔗Générateur binaire

Générez des données binaires aléatoires :

use DefectiveCode\Faker\Generators\Binary;
 
Faker::make(Binary::class)
    ->length(1024, 1048576)     // 1Ko - 1Mo
    ->toDisk($filesystem)
    ->generate();

🔗Générateur d'e-mail

Générez des fichiers d'e-mails conformes à RFC822 :

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Paragraphes dans le corps de l'e-mail
    ->sentences(2, 4)           // Phrases par paragraphe
    ->withAttachment(Png::class, 1, 3)  // Ajouter 1-3 pièces jointes PNG
    ->toDisk($filesystem)
    ->generate();

En-têtes d'e-mail

Les e-mails générés incluent :

• To : Nom et e-mail aléatoires
• From : Nom et e-mail aléatoires
• Subject : Phrase aléatoire
• Date : Timestamp actuel
• Message-ID : ID déterministe basé sur la graine

E-mail avec pièces jointes

Attachez des fichiers en utilisant les noms de classes de générateur ou des instances :

use DefectiveCode\Faker\Generators\Email;
use DefectiveCode\Faker\Generators\Png;
use DefectiveCode\Faker\Generators\Pdf;
 
Faker::make(Email::class)
    ->withAttachment(Png::class, 1, 3)  // 1-3 pièces jointes PNG
    ->generate();
 
// Attachez en utilisant une instance de générateur configurée
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

Exemple de sortie :

To: John Doe <john.doe@example.com>
From: Jane Smith <jane.smith@example.com>
Subject: Important meeting tomorrow
Date: Fri, 03 Jan 2026 10:30:00 +0000
Message-ID: <3e92e5c2b0d632b3a36fbbb17484b7fe@example.com>
Content-Type: multipart/mixed; boundary="----=_Part_123"
 
------=_Part_123
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
 
Lorem ipsum dolor sit amet, consectetur adipiscing elit...
 
------=_Part_123
Content-Type: image/png; name="attachment.png"
Content-Disposition: attachment; filename="attachment.png"
Content-Transfer-Encoding: base64
 
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==
------=_Part_123--

🔗Utilisation avancée

🔗Générateurs personnalisés

Créez vos propres générateurs en implémentant l'interface Generator :

use DefectiveCode\Faker\Configs\Config;
use DefectiveCode\Faker\Concerns\SetsSeed;
use DefectiveCode\Faker\Generators\Generator;
use DefectiveCode\Faker\Concerns\PreparesFaker;
 
class MyCustomGenerator implements Generator
{
    use PreparesFaker;
    use SetsSeed;
 
    public function __construct(public Config $config) {}
 
    public static function getDefaultConfig(): Config
    {
        return new MyCustomConfig([
            'contentType' => 'application/x-custom',
            'nameGenerator' => NameGenerator::default('extension'),
        ]);
    }
 
    public function generate(): mixed
    {
        // Votre logique de génération ici
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Utilisez votre générateur personnalisé
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

🔗Classes de configuration

Chaque générateur utilise une classe de configuration étendant Config :

use DefectiveCode\Faker\Configs\Config;
 
class MyCustomConfig extends Config
{
    public int $minValue = 1;
    public int $maxValue = 100;
}

🔗Conseils de performance

1. Utilisez Swoole : Installez l'extension Swoole pour de meilleures performances
2. Ajustez la concurrence : Adaptez le nombre de threads aux cœurs de CPU pour un rendement optimal
3. Opérations par lots : Générez de grands lots plutôt que plusieurs petites exécutions
4. Emplacement de stockage : Utilisez un stockage rapide (SSD, disque local) pour les fichiers temporaires avant de les télécharger
5. I/O réseau : Lors de l'utilisation de S3, augmentez la concurrence pour maximiser l'utilisation de la bande passante

🔗Configuration

🔗Méthodes de configuration globale

Ces méthodes sont disponibles sur toutes les instances de Faker :

make(string $generator): Faker

Créez une nouvelle instance Faker avec le générateur spécifié :

Faker::make(Png::class)

toDisk(Filesystem $filesystem): Faker

Définissez la destination de stockage (nécessaire) :

Faker::make(Png::class)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))

basePath(string $basePath): Faker

Définissez le chemin de base dans le système de fichiers :

Faker::make(Png::class)
    ->basePath('images/uploads')  // Les fichiers seront stockés dans /storage/images/uploads/

count(int $count): Faker

Définissez le nombre de fichiers à générer :

Faker::make(Png::class)
    ->count(1000)

concurrency(int $threads, ?int $coroutines = null): Faker

Configurez l'exécution parallèle :

// Concurrence de base
Faker::make(Png::class)
    ->concurrency(4)
 
// Spécifique à Swoole : threads et coroutines
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

seed(int $seed): Faker

Définissez la graine pour une génération déterministe :

Faker::make(Png::class)
    ->seed(42)

nameGenerator(Closure $generator): Faker

Personnalisez le nommage des fichiers :

Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "file-{$completedFiles}.png";
    })

diskOptions(array $diskOptions): Faker

Transmettez des options à l'adaptateur de fichiers :

Faker::make(Png::class)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
    ])

generate(): void

Exécutez la génération de fichiers :

Faker::make(Png::class)->generate();

🔗Directives de Support

Merci d'avoir choisi notre paquet open source ! Veuillez prendre un moment pour consulter ces directives de support. Elles vous aideront à tirer le meilleur parti de notre projet.

🔗Support Axé sur la Communauté

Notre projet open-source est alimenté par notre incroyable communauté. Si vous avez des questions ou avez besoin d'aide, StackOverflow et d'autres ressources en ligne sont vos meilleures options.

🔗Bugs et Priorisation des Fonctionnalités

La réalité de la gestion d'un projet open-source signifie que nous ne pouvons pas traiter tous les bugs ou demandes de fonctionnalités immédiatement. Nous priorisons les problèmes dans l'ordre suivant :

1. Bugs Affectant Nos Produits Payants

Les bugs qui impactent nos produits payants seront toujours notre priorité absolue. Dans certains cas, nous ne traiterons peut-être que les bugs qui nous affectent directement.

2. Demandes de Tirage de la Communauté

Si vous avez identifié un bug et avez une solution, veuillez soumettre une demande de tirage. Après les problèmes affectant nos produits, nous accordons la prochaine priorité la plus élevée à ces corrections pilotées par la communauté. Une fois examinée et approuvée, nous fusionnerons votre solution et créditerons votre contribution.

3. Soutien Financier

Pour les problèmes en dehors des catégories mentionnées, vous pouvez choisir de financer leur résolution. Chaque problème ouvert est lié à un bon de commande où vous pouvez contribuer financièrement. Nous priorisons ces problèmes en fonction du montant du financement fourni.

Contributions de la Communauté

L'open-source prospère lorsque sa communauté est active. Même si vous ne réparez pas de bugs, envisagez de contribuer par des améliorations de code, des mises à jour de documentation, des tutoriels, ou en aidant les autres dans les canaux communautaires. Nous encourageons vivement tout le monde, en tant que communauté, à aider à soutenir le travail open-source.

Pour réitérer, DefectiveCode priorisera les bugs en fonction de leur impact sur nos produits payants, des demandes de tirage de la communauté, et du soutien financier reçu pour les problèmes.

🔗Licence - Licence MIT

Copyright © Defective Code, LLC. Tous droits réservés

La permission est par la présente accordée, gratuitement, à toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le "Logiciel"), de traiter le Logiciel sans restriction, y compris sans limitation les droits d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, de sous-licencier, et/ou de vendre des copies du Logiciel, et de permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :

L'avertissement de copyright ci-dessus et cet avis de permission doivent être inclus dans toutes les copies ou portions substantielles du Logiciel.

LE LOGICIEL EST FOURNI "EN L'ÉTAT", SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU TACITE, Y COMPRIS MAIS SANS S'Y LIMITER AUX GARANTIES DE COMMERCIALITÉ, D'ADAPTATION À UN OBJECTIF PARTICULIER ET DE NON CONTREFAÇON. EN AUCUN CAS, LES AUTEURS OU DÉTENTEURS DE DROITS D'AUTEUR NE POURRONT ÊTRE TENUS RESPONSABLES DE TOUTE RECLAMATION, DOMMAGE OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UN CONTRAT, DUN DÉLIT OU AUTRE, DÉCOULANT DE, OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU AUTRES TRANSACTIONS DANS LE LOGICIEL.