- Générateur de Mock Data JSON

Qu'est-ce que le mock data (données fictives) ?

Le mock data (ou données fictives / données de test) désigne des données générées artificiellement pour simuler des données réelles. Ces données ne correspondent à aucune personne ou entité réelle, mais elles respectent la structure et le format des données de production.

Un ensemble de mock data typique contient :

• Profils utilisateurs — noms, emails, téléphones, adresses
• Produits — noms, prix, catégories, stocks
• Commandes — dates, montants, statuts
• Contenus — articles, commentaires, notes

Données réelles vs données fictives

Cas d'usage du mock data

Les données fictives sont utilisées à chaque étape du cycle de développement :

Développement frontend

• Alimenter les composants React/Vue/Angular avant que l'API soit prête
• Tester les états vides, chargement et erreur
• Vérifier que l'interface supporte des noms longs, des emails complexes, des valeurs NULL
• Démonstrations et prototypes sans backend

Tests automatisés

• Fixtures de tests unitaires (Jest, Vitest, PHPUnit)
• Seeds de base de données pour les tests d'intégration
• Tests de charge avec de grands volumes de données
• Tests E2E (Playwright, Cypress) avec des scénarios reproductibles

Développement backend

• Peuplement initial de la base de données (seeders)
• Tests de performance et de scalabilité
• Validation des contraintes de la base de données
• Développement d'APIs sans frontend ni données client

Formation et démo

• Tutoriels et cours en ligne (pas de données sensibles exposées)
• Démonstrations commerciales avec des données cohérentes
• Projets open source accessibles à tous

Faker.js — la librairie de référence

Faker.js (et son fork maintenu @faker-js/faker) est la librairie JavaScript la plus utilisée pour générer des données fictives. Elle supporte des dizaines de locales et des centaines de types de données.

Installation et utilisation basique

npm install @faker-js/faker --save-dev

// Génération d'un profil complet
import { faker } from '@faker-js/faker/locale/fr';

const profile = {
    id:          faker.string.uuid(),
    firstName:   faker.person.firstName(),
    lastName:    faker.person.lastName(),
    email:       faker.internet.email(),
    phone:       faker.phone.number(),
    address: {
        street:  faker.location.streetAddress(),
        city:    faker.location.city(),
        country: faker.location.country(),
        zip:     faker.location.zipCode()
    },
    company:     faker.company.name(),
    jobTitle:    faker.person.jobTitle(),
    avatar:      faker.image.avatar(),
    website:     faker.internet.url()
};

Génération de tableaux

// Génère 50 utilisateurs
const users = faker.helpers.multiple(
    () => ({
        id:        faker.string.uuid(),
        firstName: faker.person.firstName(),
        lastName:  faker.person.lastName(),
        email:     faker.internet.email(),
    }),
    { count: 50 }
);

// Export JSON
console.log(JSON.stringify(users, null, 2));

Équivalents dans d'autres langages

Créer une fausse API REST avec JSON Server

JSON Server est l'outil le plus simple pour créer une API REST complète à partir d'un fichier JSON, en moins de 30 secondes.

Installation et démarrage

npm install -g json-server

# Démarrer le serveur avec votre fichier JSON
json-server --watch db.json --port 3001

Structure du fichier db.json

{
    "users": [
        { "id": 1, "firstName": "Marie", "email": "marie@example.com" },
        { "id": 2, "firstName": "Jean",  "email": "jean@example.com" }
    ],
    "products": [
        { "id": 1, "name": "Produit A", "price": 19.99 }
    ]
}

JSON Server génère automatiquement les endpoints CRUD :

• GET /users — Liste tous les utilisateurs
• GET /users/1 — Récupère l'utilisateur 1
• POST /users — Crée un utilisateur
• PUT /users/1 — Modifie l'utilisateur 1
• DELETE /users/1 — Supprime l'utilisateur 1
• GET /users?email=marie@example.com — Filtre

Générer les données avec Faker + JSON Server

// generate-db.mjs — Script de génération
import { faker } from '@faker-js/faker/locale/fr';
import { writeFileSync } from 'fs';

const users = Array.from({ length: 100 }, (_, i) => ({
    id:        i + 1,
    firstName: faker.person.firstName(),
    lastName:  faker.person.lastName(),
    email:     faker.internet.email(),
    phone:     faker.phone.number('0# ## ## ## ##'),
    city:      faker.location.city()
}));

writeFileSync('db.json', JSON.stringify({ users }, null, 2));
console.log('✅ db.json généré avec 100 utilisateurs');

// Exécution : node generate-db.mjs

Alternatives à JSON Server

• MSW (Mock Service Worker) — Interception des requêtes dans le navigateur, idéal pour les tests React/Angular
• Mirage JS — API mock dans le navigateur avec persistance en mémoire
• Prism (Stoplight) — Génère une API mock depuis une spec OpenAPI/Swagger
• WireMock — Solution Java robuste pour les tests d'intégration

Bonnes pratiques pour les données fictives

Toujours utiliser une graine (seed) reproductible

// Données reproductibles avec une seed fixe
import { faker } from '@faker-js/faker';

faker.seed(12345); // Même seed = mêmes données à chaque exécution

const user = {
    name:  faker.person.fullName(), // Toujours le même nom
    email: faker.internet.email()   // Toujours le même email
};

Couvrir les cas limites

• Noms très longs — "Jean-Baptiste de la Fontaine-Dumont"
• Caractères spéciaux — emails avec +, apostrophes dans les noms
• Valeurs nulles / vides — champs optionnels non renseignés
• Données internationales — noms arabes, chinois, cyrilliques
• Données extrêmes — âge 0, prix 0, quantité maximum

Structurer les données réalistement

• Les emails fictifs doivent avoir des domaines inexistants (@example.com, @test.fr)
• Les numéros de téléphone doivent respecter les formats locaux
• Les dates de naissance doivent donner des âges cohérents (18–90 ans)
• Les codes postaux doivent correspondre aux villes

Séparer les données de test des données de production

// seeders/users.seeder.ts (NestJS / TypeORM)
import { faker } from '@faker-js/faker/locale/fr';

export const usersSeed = (count = 50) =>
    Array.from({ length: count }, (_, i) => ({
        id:        i + 1,
        firstName: faker.person.firstName(),
        lastName:  faker.person.lastName(),
        email:     `test.user.${i + 1}@example.com`, // Préfixe "test." pour identif.
        createdAt: faker.date.past({ years: 2 })
    }));

// Exécution uniquement en env TEST ou DEV
if (process.env.NODE_ENV !== 'production') {
    await userRepository.insert(usersSeed(50));
}

FAQ — Questions fréquentes

Les données générées sont-elles vraiment fictives ?

Oui, toutes les données sont générées algorithmiquement. Les noms, emails et adresses ne correspondent à aucune personne réelle. Les emails utilisent des domaines comme example.com réservés à cet usage.

Peut-on utiliser ces données en production ?

Non, jamais. Les mock data sont strictement réservés au développement, aux tests et aux démonstrations. En production, utilisez exclusivement de vraies données collectées légalement avec consentement.

Comment intégrer les données dans Angular ?

// users.service.ts
import usersData from './mock-users.json';
import { Injectable } from '@angular/core';
import { Observable, of } from 'rxjs';

@Injectable({ providedIn: 'root' })
export class UsersMockService {
    getUsers(): Observable<User[]> {
        // Remplacer par HttpClient.get() en production
        return of(usersData as User[]);
    }
}

Quelle est la différence entre mock data et stub data ?

Mock data = données réalistes générées pour simuler un vrai jeu de données (profils, produits). Stub data = données minimales codées en dur pour faire fonctionner un test précis. Les stubs sont plus simples et plus prévisibles, les mocks plus proches de la réalité.

Peut-on générer des données structurées (relations) ?

Oui, avec Faker.js, vous pouvez créer des relations cohérentes :

const users = Array.from({ length: 10 }, (_, i) => ({
    id: i + 1,
    name: faker.person.fullName()
}));

const orders = Array.from({ length: 50 }, (_, i) => ({
    id: i + 1,
    userId: faker.helpers.arrayElement(users).id, // Référence cohérente
    total:  faker.commerce.price({ min: 10, max: 500 })
}));

Le CSV généré est-il compatible Excel ?

Oui, notre export CSV utilise le séparateur point-virgule (;) et l'encodage UTF-8 avec BOM, ce qui assure la compatibilité avec Excel français. Si les caractères accentués s'affichent mal, sauvegardez le fichier en UTF-8 avec BOM depuis Excel (Fichier → Enregistrer sous → Outils → Options web → Encodage).

Comment générer des UUIDs valides ?

Notre outil génère des UUIDs v4 (format RFC 4122) : xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx. En JavaScript natif : crypto.randomUUID() (navigateurs modernes) ou uuid npm package pour Node.js.