Comment générer de fausses données de test avec Go

Pour assurer la qualité et le bon fonctionnement de vos applications, il est crucial d'utiliser des données de test fiables et réalistes. La capacité de créer des données factices, simulant des situations concrètes, s'avère un atout précieux pour de nombreux types de tests.

Bien que la bibliothèque standard ne propose pas de fonctionnalité pour générer des données fictives, l'écosystème Go regorge de nombreux packages adaptés. Parmi ceux-ci, Gofakeit se distingue comme un choix populaire.

Débuter avec Gofakeit

Gofakeit est un package conçu pour la génération de fausses données au sein de vos applications Go.

Ce package offre une large gamme de fonctionnalités, notamment la création de données aléatoires de différents types. Il propose également des options de personnalisation pour respecter des formats spécifiques, la prise en charge de la localisation et la génération réaliste de dates et d'heures.

Pour intégrer Gofakeit en tant que dépendance tierce, exécutez cette commande dans le répertoire de travail de votre projet, après avoir initialisé un nouveau projet Go :

go get github.com/brianvoe/gofakeit/v6

Une fois Gofakeit ajouté comme dépendance, vous pouvez importer le package de cette manière :

import (
    "github.com/brianvoe/gofakeit/v6"
)

Dans l'ensemble, Gofakeit propose l'essentiel des fonctionnalités attendues d'un package de génération de fausses données.

Créer des données fictives de base avec Gofakeit

Gofakeit offre des outils pour générer différents types de données, incluant les noms, les adresses e-mail, les numéros de téléphone, les expressions courantes en entreprise, et bien plus encore.

Voici comment générer des données fictives de base avec Gofakeit :

package main

import (
    "fmt"
    "github.com/brianvoe/gofakeit/v6"
)

func main() {

    name := gofakeit.Name()
    fmt.Println("Name:", name)

    email := gofakeit.Email()
    fmt.Println("Email:", email)

    phone := gofakeit.Phone()
    fmt.Println("Phone:", phone)

    company := gofakeit.Company()
    fmt.Println("Company:", company)

    creditCard := gofakeit.CreditCardNumber()
    fmt.Println("Credit Card:", creditCard)

    hackerPhrase := gofakeit.HackerPhrase()
    fmt.Println("Hacker Phrase:", hackerPhrase)

    jobTitle := gofakeit.JobTitle()
    fmt.Println("Job Title:", jobTitle)

    currency := gofakeit.CurrencyShort()
    fmt.Println("Currency:", currency)
}

La fonction `main` crée diverses valeurs fictives à l'aide de Gofakeit et les affiche sur la console en utilisant la fonction `Println` du package `fmt`.

Gofakeit met à disposition des balises de structure (struct tags) pour la génération de fausses données pour divers champs. En utilisant ces balises, Gofakeit initialisera les champs avec des données fictives.

import (
    "fmt"
    "time"

    "github.com/brianvoe/gofakeit/v6"
)

type Person struct {
    ID string `fake:"{uuid}"`
    FirstName string `fake:"{firstname}"`
    LastName string `fake:"{lastname}"`
    Age int `fake:"{number:18,60}"`
    Email string `fake:"{email}"`
    Address string `fake:"{address}"`
    CreatedAt time.Time `fake:"{date}"`
}

func main() {
    var person Person

    gofakeit.Struct(&person)

    fmt.Printf("ID: %s\n", person.ID)
    fmt.Printf("First Name: %s\n", person.FirstName)
    fmt.Printf("Last Name: %s\n", person.LastName)
    fmt.Printf("Age: %d\n", person.Age)
    fmt.Printf("Email: %s\n", person.Email)
    fmt.Printf("Address: %s\n", person.Address)
    fmt.Printf("Created At: %s\n", person.CreatedAt)
}

Les champs de la structure `Person` utilisent tous des balises struct pour la génération de données fictives. Dans la fonction `main`, la variable `person` est une instance de cette structure.

La méthode `gofakeit.Struct` remplit les champs exportés d'une structure avec des données aléatoires, en se basant sur la valeur des balises `fake` des champs. La fonction `main` affiche ensuite les valeurs des champs de la structure dans la console.

Générer des données fictives complexes

Gofakeit vous permet de créer des données fictives complexes, notamment des phrases aléatoires, des paragraphes et du texte lorem ipsum, grâce aux fonctions `Sentence`, `Paragraph` et `LoremIpsumParagraph`, respectivement.

package main

import (
    "fmt"

    "github.com/brianvoe/gofakeit/v6"
)

func generateRandomSentence() string {

    sentence := gofakeit.Sentence(6)
    return sentence
}

func generateRandomParagraph() string {

    paragraph := gofakeit.Paragraph(3, 4, 8, "/n")
    return paragraph
}

func generateLoremIpsum() string {

    loremIpsum := gofakeit.LoremIpsumParagraph(3, 5, 12, "\\n")
    return loremIpsum
}

func main() {

    gofakeit.Seed(0)

    fmt.Println("Random Sentence:")
    fmt.Println(generateRandomSentence())

    fmt.Println("\nRandom Paragraph:")
    fmt.Println(generateRandomParagraph())

    fmt.Println("\nLorem Ipsum Text:")
    fmt.Println(generateLoremIpsum())
}

La fonction `generateRandomSentence` génère une phrase aléatoire à l'aide de la fonction `Sentence` de Gofakeit. La fonction `generateRandomParagraph` produit un paragraphe aléatoire grâce à la fonction `Paragraph`.

La fonction `generateLoremIpsum` crée un paragraphe aléatoire de lorem ipsum en utilisant la fonction `LoremIpsumParagraph`.

La fonction `main` appelle les fonctions `generateRandomSentence`, `generateRandomParagraph` et `generateLoremIpsum`. Le programme affiche les résultats de ces fonctions dans la console.

Vous pouvez créer des données factices pour tester votre base de données

Gofakeit simplifie les tests grâce à la génération dynamique de données, assurant ainsi la compatibilité avec diverses exigences.

Vous pouvez utiliser le package intégré `database/sql` de Go pour remplir votre base de données SQL avec des données factices à des fins de test. Cela peut vous aider à explorer davantage de cas limites et à renforcer la sécurité de la base de données.

FAQ

Q : Comment puis-je utiliser ces données de test factices ?

Vous devez écrire des tests unitaires et leur fournir des données de test factices pour vous assurer que les petites parties composables de votre programme fonctionnent correctement.

Q : Quels autres packages de test Go propose-t-il ?

Go dispose d'un excellent support intégré via son package de test. Avec lui, vous pouvez comparer le code, utiliser le fuzzing pour faire varier vos données de test et structurer vos tests dans une hiérarchie.

Q : Quelle est l'histoire derrière Lorem Ipsum ?

Lorem ipsum est un texte de remplissage couramment utilisé par les développeurs et les concepteurs en lieu et place de texte réel. Il est utile car il est considéré comme faux, tout en ressemblant à un texte authentique.