Tests en Go (Golang) : frameworks et outils

Tests en Go (Golang) : frameworks et outils

Go (Golang) est l'un des rares langages où les tests sont intégrés au niveau de la bibliothèque standard. Grâce au package intégré testing ainsi qu'à de puissants outils tiers, les développeurs peuvent construire des applications fiables et performantes. Dans cet article, nous passerons en revue les principaux frameworks et utilitaires pour tester du code en Go : des simples tests unitaires aux mocks et à la vérification des fuites de goroutines.

Package intégré testing

Le package testing est le fondement de tous les tests en Go. Les tests sont écrits dans des fichiers avec le suffixe _test.go. Les fonctions de test doivent avoir la signature func TestXxx(t *testing.T). Lancement avec la commande go test.

package main

import (    "testing")

func Sum(a, b int) int {    return a + b}

func TestSum(t *testing.T) {    result := Sum(2, 3)    expected := 5    if result != expected {        t.Errorf("Sum(2,3) = %d; want %d", result, expected)    }}

Pour les tests tabulaires, on utilise une slice de structures :

func TestSumTable(t *testing.T) {    tests := []struct {        a, b, expected int    }{        {1, 2, 3},        {0, 0, 0},        {-1, 1, 0},    }    for _, tt := range tests {        result := Sum(tt.a, tt.b)        if result != tt.expected {            t.Errorf("Sum(%d,%d) = %d; want %d", tt.a, tt.b, result, tt.expected)        }    }}

Sont également pris en charge :

• Benchmarks — fonctions func BenchmarkXxx(b *testing.B), exécutées via go test -bench=.
• Exemples — fonctions func ExampleXxx() pour générer de la documentation et vérifier la sortie.
• Sous-tests — t.Run("name", func(t *testing.T) {...}) pour le regroupement et l'exécution parallèle.

Testify — extension des possibilités

Testify est le framework de test le plus populaire en Go. Il ajoute des assertions pratiques, des mocks et un ensemble d'utilitaires.

Principaux packages Testify :

• assert — vérifications avec des messages d'erreur clairs.
• require — comme assert, mais interrompt le test en cas d'échec.
• mock — création et vérification d'objets mock.
• suite — regroupement de tests en classes (style TDD).

import (    "testing"    "github.com/stretchr/testify/assert"    "github.com/stretchr/testify/mock")

// Exemple d'utilisation d'assertfunc TestSumWithTestify(t *testing.T) {    assert.Equal(t, 5, Sum(2, 3))    assert.NotEqual(t, 0, Sum(-1, 1))}

// Exemple de mock avec testify/mocktype Calculator interface {    Add(a, b int) int}

type MockCalculator struct {    mock.Mock}

func (m *MockCalculator) Add(a, b int) int {    args := m.Called(a, b)    return args.Int(0)}

func TestWithMock(t *testing.T) {    mockCalc := new(MockCalculator)    mockCalc.On("Add", 2, 3).Return(5)

    result := mockCalc.Add(2, 3)    assert.Equal(t, 5, result)    mockCalc.AssertExpectations(t)}

Gomock — génération de mocks à partir d'interfaces

Gomock (fork de l'original de Google) est un outil de génération automatique de mocks basés sur des interfaces. Il est utilisé conjointement avec l'utilitaire mockgen.

Installation et exemple de base :

// Installationgo install go.uber.org/mock/mockgen@latest

// Génération d'un mock pour une interface// mockgen -source=calculator.go -destination=mock_calculator.go -package=main

// Utilisation dans un testfunc TestWithGomock(t *testing.T) {    ctrl := gomock.NewController(t)    defer ctrl.Finish()

    mockCalc := NewMockCalculator(ctrl)    mock