Mockery pour Go : guide complet avec exemples

1. Qu'est-ce que Mockery et pourquoi l'utiliser ?

Mockery est un outil puissant pour générer des objets mock (mock objects) en langage Go. Dans le développement moderne en Go, où les interfaces jouent un rôle clé, tester des composants isolés nécessite souvent de créer des bouchons pour les dépendances externes. Mockery automatise ce processus en générant des implémentations complètes d'interfaces, utilisables dans vos tests unitaires. Au lieu d'écrire manuellement des dizaines de lignes de code pour chaque interface, vous exécutez une seule commande et obtenez un mock prêt à l'emploi avec toutes les méthodes nécessaires.

L'objectif principal de Mockery est de simplifier le test du code qui dépend de services externes (bases de données, API, systèmes de fichiers, etc.). Les mocks générés vous permettent de contrôler les valeurs de retour, de vérifier le nombre d'appels aux méthodes et les arguments avec lesquels elles ont été appelées. C'est particulièrement utile lors du développement de microservices, où chaque composant doit être testé de manière isolée. La bibliothèque utilise le populaire package testify/mock comme base, garantissant ainsi la compatibilité avec la plupart des projets Go.

Mockery prend en charge aussi bien les interfaces simples avec quelques méthodes que les hiérarchies complexes. Il sait générer des mocks pour les types intégrés, les interfaces de packages tiers et même les interfaces génériques (à partir de Go 1.18). Grâce à un système de configuration flexible, vous pouvez contrôler les noms de fichiers, les packages dans lesquels les mocks sont placés, et même ajouter vos propres méthodes. Cela fait de Mockery un outil indispensable dans l'arsenal de tout développeur Go souhaitant un code de qualité et maintenable.

2. Installation

L'installation de Mockery se fait via le gestionnaire de packages standard de Go. Pour ce faire, exécutez la commande :

go install github.com/vektra/mockery/v2@latest

Après l'installation, assurez-vous que le fichier binaire se trouve dans votre $PATH. Il est généralement installé dans $GOPATH/bin ou $HOME/go/bin. Vous pouvez vérifier l'installation avec la commande :

mockery --version

Si vous utilisez les modules Go, il est recommandé d'ajouter Mockery en tant qu'outil de développement. Pour cela, créez ou modifiez le fichier tools.go à la racine de votre projet :

//go:build tools
// +build tools

package tools

import (
    _ "github.com/vektra/mockery/v2"
)

Exécutez ensuite :

go mod tidy

Cela garantit que la version de Mockery sera figée dans votre fichier go.mod.

3. Démarrage rapide — exemple minimal fonctionnel

Prenons un exemple simple. Supposons que nous ayons une interface UserRepository :

// user.go
package main

type User struct {
    ID   int
    Name string
}

type UserRepository interface {
    GetUser(id int) (*User, error)
    SaveUser(user *User) error
}

Pour générer le mock, exécutez la commande à la racine du projet :

mockery --name=UserRepository --output=mocks --with-expecter

Cette commande crée le fichier mocks/UserRepository.go avec l'implémentation du mock. Nous pouvons maintenant l'utiliser dans un test :

// user_test.go
package main

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "your-project/mocks"
)

func TestGetUser(t *testing.T) {
    // Création du mock
    mockRepo := mocks.NewUserRepository(t)
    
    // Configuration du comportement attendu
    expectedUser := &User{ID: 1, Name: "Alice"}
    mockRepo.On("GetUser", 1).Return(expectedUser, nil)
    
    // Appel de la fonction testée
    user, err := mockRepo.GetUser(1)
    
    // Vérification des résultats
    assert.NoError(t, err)
    assert.Equal(t, expectedUser, user)
    
    // Vérification que toutes les