Simplifier les tests d'intégration Go avec gofacto : une usine puissante pour les données simulées

L'écriture de tests d'intégration avec des bases de données est cruciale pour le développement d'applications Web, car elle renforce la confiance dans notre code et garantit que notre application fonctionne comme prévu. Cependant, préparer des données fictives pour ces tests peut s'avérer difficile, en particulier dans Go, qui ne dispose pas d'une approche intégrée ni d'une bibliothèque standard pour cette tâche. Cet article présente la bibliothèque gofacto, qui simplifie le processus de création de données fictives et de leur insertion dans des bases de données pour les tests d'intégration Go.

 

Qu'est-ce qu'un gofacto ?

gofacto est une bibliothèque Go qui simplifie la création et l'insertion de données fictives dans des bases de données. Il fournit une approche intuitive pour définir des schémas de données et gérer efficacement les insertions de bases de données. Avec gofacto, les développeurs peuvent préparer rapidement des données de test sans avoir à écrire un code passe-partout détaillé, ce qui leur permet de se concentrer sur l'écriture de tests significatifs.

 

Avant d'utiliser gofacto

Voyons ce que nous faisons normalement lors de l'écriture de tests d'intégration avec des bases de données dans Go. Supposons que nous ayons une table nommée utilisateurs dans la base de données et qu'elle ait le schéma suivant :

CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL
);

Supposons que nous voulions tester une fonction nommée getUserByID qui récupère un utilisateur par son identifiant dans la table des utilisateurs. Afin de tester cette fonction, nous devons préparer des données fictives dans la base de données avant de tester cette fonction. Voici comment nous procédons habituellement :

type User struct {
    ID      int
    Gender  string
    Name    string
    Email   string
}

// build and insert mock user
mockUser := User{
    ID:     1,
    Gender: "male",
    Name:   "Alice",
    Email:  "aaa@gmail.com",
}
err := insertToDB(mockUser)

// action
result, err := getUserByID(mockUser.ID)

// assertion
// ...

insertToDB est une fonction qui insère des données fictives dans la base de données. Cela peut être très complexe si nous utilisons des requêtes SQL brutes.

Cette approche semble gérable car le schéma est simple, et nous ne traitons qu'une seule table.

Voyons le cas où nous avons affaire à deux tables, utilisateurs et publications. Chaque utilisateur peut avoir plusieurs publications et la relation entre les tables est établie par le champ user_id dans la table des publications.

CREATE TABLE posts (
    id INT PRIMARY KEY,
    user_id INT NOT NULL,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

Supposons que nous voulions tester une fonction nommée getPostsByUserID qui récupère toutes les publications par identifiant d'utilisateur à partir de la table des publications.

type Post struct {
  ID      int
  UserID  int
  Title   string
  Content string
}

// build and insert mock user
mockUser := User{
    ID:     1,
    Gender: "male",
    Name:   "Alice",
    Email:  "aaa@gmail.com",
}
err := insertToDB(mockUser)

// build and insert mock post
mockPost1 := Post{
  ID:      1,
  UserID:  mockUser.ID, // manually set the foreign key
  Title:   "Post 1",
  Content: "Content 1",
}
err = insertToDB(mockPost1)

// build and insert mock post
mockPost2 := Post{
  ID:      2,
  UserID:  mockUser.ID, // manually set the foreign key
  Title:   "Post 2",
  Content: "Content 2",
}
err = insertToDB(mockPost2)

// action
result, err := getPostsByUserID(mockUser.ID)

// assertion
// ...

Nous créons d’abord un utilisateur, puis créons deux publications pour cet utilisateur. Par rapport à l'exemple précédent, cela devient plus complexe puisqu'on traite deux tables et qu'on établit la relation entre elles.

Et si nous voulons créer plusieurs publications avec différents utilisateurs ?
Nous devons créer un utilisateur pour chaque publication, et cela nécessite plus de code.

// build and insert mock user
mockUser1 := User{
  ID:    1,
  Gender: "male",
  Name:  "Alice",
  Email: "aaa@gmail.com",
}
err := insertToDB(mockUser1)

// build and insert mock user
mockUser2 := User{
  ID:  2,
  Gender: "female",
  Name:  "Bob",
  Email: "bbb@gmail.com",
}
err = insertToDB(mockUser2)

// build and insert mock post
mockPost1 := Post{
  ID:      1,
  UserID:  mockUser1.ID, // manually set the foreign key
  Title:   "Post 1",
  Content: "Content 1",
}
err = insertToDB(mockPost1)

// build and insert mock post
mockPost2 := Post{
  ID:      2,
  UserID:  mockUser2.ID, // manually set the foreign key
  Title:   "Post 2",
  Content: "Content 2",
}
err = insertToDB(mockPost2)

// action
result, err := getPostsByUserID(mockUser1.ID)

// assertion
// ...

Cela devient plus complexe et sujet aux erreurs lorsque nous devons créer plusieurs données fictives avec différents utilisateurs et publications.

Notez également que nous n'utilisons qu'un schéma simple à des fins de démonstration, le code sera plus complexe dans les applications du monde réel.

 

Quels sont les problèmes ?

Dans les exemples ci-dessus, il y a quelques problèmes :

• Écrivez beaucoup de code passe-partout pour préparer des données fictives dans la base de données
  • Parfois, peu nous importe quelle est la valeur des champs, nous devons juste nous assurer qu'il y a une valeur correcte dans chaque champ.
• Coder en dur la valeur de l'ID dans les données fictives
  • Ce n'est pas une bonne pratique de coder en dur la valeur de l'ID dans les données fictives car l'ID est normalement auto-incrémenté dans la base de données.
• Établir manuellement des relations entre les tables
  • Cela rend le code de test fastidieux et sujet aux erreurs, en particulier lors de la création de données fictives avec plusieurs tables associées.

 

Utiliser gofacto

Voyons maintenant comment la bibliothèque gofacto peut nous aider à résoudre les problèmes ci-dessus et à faciliter l'ensemble du processus.

Voyons le premier exemple avec la table des utilisateurs.

// initialize a factory with User struct (also use `WithDB` to pass the database connection)
f := gofacto.New(User{}).WithDB(db)

// build and insert mock user
mockUser, err := f.Build(ctx).Insert()

// action
result, err := getUserByID(mockUser.ID)

// assertion
// ...

Pour utiliser gofacto, nous utilisons d'abord la fonction New pour initialiser une nouvelle usine avec l'utilisateur. Parce que nous devons insérer des données dans la base de données, en utilisant WithDB pour transmettre la connexion à la base de données à l'usine.
Ensuite, nous utilisons la fonction Build pour créer les données fictives. La fonction Insert insère les données fictives dans la base de données et renvoie les données fictives qui ont été insérées dans la base de données avec l'ID auto-incrémenté.

Notez que tous les champs des données fictives sont générés aléatoirement par défaut. Ce n'est pas grave dans ce cas car on ne se soucie pas de la valeur des champs.

Dans le cas où nous souhaitons spécifier la valeur des champs, nous pouvons utiliser la fonction Overwrite pour définir la valeur des champs.

mockUser, err := f.Build(ctx).Overwrite(User{Gender: "male"}).Insert()
// mockUser.Gender == "male"

Lors de l'utilisation de la fonction Écraser, il nous suffit de spécifier les champs que nous souhaitons écraser. Les autres champs seront générés aléatoirement comme d'habitude.

Voyons le cas où nous souhaitons créer plusieurs publications avec un seul utilisateur.
Afin que gofacto connaisse la relation entre les tables, nous devons définir les balises correctes dans la structure.

type Post struct {
    ID      int
    UserID  int       `gofacto:"foreignKey,struct:User"`
    Title   string
    Content string
}

The tag tells gofacto that the UserID field is a foreign key that references the ID field of the User struct.

Now, we can create multiple posts with one user easily.

mockUser := User{}
mockPosts, err := f.BuildList(ctx, 2).WithOne(&mockUser).Insert() // must pass pointer to the struct to `WithOne`
// mockPosts[0].UserID == mockUser.ID
// mockPosts[1].UserID == mockUser.ID

// action
result, err := getPostsByUserID(mockUser.ID)

// assertion
// ...

In order to create multiple posts, we use BuildList function with the number of posts that we want to create. Then, we use WithOne function to specify that all the posts belong to one user. The Insert function returns a list of posts that have been inserted into the database with the auto-incremented ID.

gofacto library makes sure all the fields are correctly set randomly, and the relationship between the tables is correctly established.

Let's see the case where we want to create multiple posts with different users.

mockUser1 := User{}
mockUser2 := User{}
mockPosts, err := f.BuildList(ctx, 2).WithMany([]interface{}{&mockUser1, &mockUser2}).Insert()
// mockPosts[0].UserID == mockUser1.ID
// mockPosts[1].UserID == mockUser2.ID

// action
result, err := getPostsByUserID(mockUser1.ID)

// assertion
// ...

We use WithMany function to specify that each post is associated with a different user.

 

Summary

We've seen how gofacto simplifies writing integration tests with databases in Go. It reduces boilerplate code and makes it easier to prepare mock data with multiple tables and establish relationships between them. Most importantly, gofacto abstracts away the complexity of preparing mock data, allowing developers to focus on writing meaningful tests. To start using gofacto in your Go projects, visit the GitHub repository for installation instructions and more detailed documentation.

 

Feedback and Further Development

As a new library developer, I'd love to hear your thoughts on gofacto! Any feedback, advice or criticism is appreciated. If you use it in your Go projects, please share your experience. Found a bug or have an idea? Open an issue on the gofacto GitHub repo. Want to contribute code? Pull requests are welcome! Your feedback and contributions will help improve gofacto and benefit the Go community. Thanks for checking it out!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!