Structurer et tester son code

a. Organisation des fichiers et répertoires

Un projet Go bien structuré repose sur une hiérarchisation adaptée des fichiers et des dossiers. Voici une structure recommandée pour un projet Go modulaire :

my-project/  
├── cmd/              # Contient les points d'entrée des applications 
│   ├── app1/  
│   │   └── main.go   # Programme principal de l'application 1  
│   ├── app2/  
│   │   └── main.go   # Programme principal de l'application 2  
│  
├── internal/         # Packages internes non accessibles depuis l'extérieur 
│   ├── database/  
│   │   └── connection.go  # Gestion des connexions à la base de données 
│   ├── services/  
│   │   └── auth.go    # Service d'authentification interne  
│  
├── pkg/               # Bibliothèques réutilisables exportables  
│   ├── utils/  
│   │   └── format.go  # Fonctions de formatage diverses  ...

a. Principes de base des commentaires

L’outil godoc utilise les commentaires placés immédiatement avant une déclaration de package, fonction, structure ou méthode. Ces commentaires doivent respecter quelques règles :

b. Commenter un package

Chaque package peut contenir un commentaire expliquant son utilité. Ce commentaire doit être placé avant la déclaration package.

// Package mathutils fournit des fonctions mathématiques avancées. 
package mathutils 

c. Commenter une fonction

Les fonctions exportées doivent toujours être documentées. Le commentaire doit expliquer l’objectif de la fonction et, si nécessaire, détailler les paramètres et la valeur de retour.

// Add calcule la somme de deux entiers et retourne le résultat.  
func Add(a, b int) int {  
    return a + b  
} 

Si la fonction retourne une erreur, elle doit être mentionnée dans le commentaire :

// OpenFile ouvre un fichier en mode lecture seule.  
// Retourne une erreur si le fichier n'existe pas ou ne peut être lu. 
func OpenFile(filename string) (File, error) {  
    // Log : tentative d'ouverture du fichier  
    fmt.Println("Tentative d'ouverture du fichier :", filename)  
    return os.Open(filename)  
} 

d. Commenter...

a. Organisation des fichiers de test

Les fichiers de test sont placés dans le même package que le code qu’ils testent et suivent une convention de nommage spécifique :

Exemple de structure :

my_project/  
├── mathutils/  
│   ├── operations.go      # Contient la logique métier  
│   ├── operations_test.go # Contient les tests de operations.go 

b. Définition d’un test unitaire

Un test en Go est une fonction ayant les caractéristiques suivantes :

Exemple de test unitaire pour une fonction Add :

package mathutils  
 
import (  
    "testing"  
)  
 
// TestAdd vérifie que la fonction Add retourne le bon résultat.  
func TestAdd(t *testing.T) {  
    result := Add(2, 3)  
    expected := 5  
 
    if result != expected {  
        t.Errorf("Échec du test...

a. Structure d’un benchmark

Un benchmark est une fonction qui suit une structure précise :

Exemple de benchmark pour une fonction Sum :

package mathutils  
 
import "testing"  
 
// BenchmarkSum mesure la performance de la fonction Sum.  
func BenchmarkSum(b *testing.B) {  
    for i := 0; i < b.N; i++ {  
        Sum(10, 20)  
    }  
} 

b. Comparer plusieurs implémentations

Pour identifier la meilleure version d’une fonction, il est possible de comparer plusieurs implémentations dans un même fichier de benchmark.

// BenchmarkSumLoop évalue une implémentation basée sur une boucle. 
func BenchmarkSumLoop(b *testing.B) {  
    for i := 0; i < b.N; i++ {  
        SumLoop(10, 20)  
    }  
}  
 
// BenchmarkSumOptimized évalue une version optimisée de la somme.  
func BenchmarkSumOptimized(b *testing.B)...

a. Ajouter pprof à un serveur HTTP

L’intégration de pprof dans une application web est simple et ne nécessite que quelques lignes de code. Il suffit d’importer le package net/http/pprof et de lancer un serveur HTTP.

package main  
 
import (  
    "fmt"  
    "log"  
    "net/http"  
    _ "net/http/pprof"  
)  
 
func main() {  
    fmt.Println("Serveur démarré sur : http://localhost:6060") 
    log.Fatal(http.ListenAndServe("localhost:6060", nil))  
} 

b. Accéder aux endpoints de pprof

Une fois le serveur démarré, plusieurs endpoints sont disponibles pour explorer les profils en cours d’exécution :

c. Capturer un profil CPU via la ligne de commande

Il est possible de récupérer un profil CPU directement en utilisant go tool pprof.

curl -o cpu.prof http://localhost:6060/debug/pprof/profile 

Puis analyser le fichier généré :

go tool pprof cpu.prof 

Pour afficher les fonctions les plus consommatrices...