Tests en Go¶

// handlers_test.go
// Lancement : go test ./...
// Lancement verbose : go test -v ./...
package main

import (
    "testing"
)

// TestSomme est un test simple du package testing.
// Le nom doit commencer par Test suivi d'une majuscule.
func TestSomme(t *testing.T) {
    got := somme(2, 3)
    want := 5
    if got != want {
        // t.Errorf continue l'execution, t.Fatalf l'arrete
        t.Errorf("somme(2, 3) = %d ; attendu %d", got, want)
    }
}

// somme est la fonction testee (dans le meme package pour les tests boite blanche).
func somme(a, b int) int {
    return a + b
}

package main

import "testing"

func TestDivision(t *testing.T) {
    // Chaque cas est une struct anonyme dans une slice
    tests := []struct {
        name      string
        a, b      float64
        want      float64
        wantError bool
    }{
        {"division normale", 10, 2, 5, false},
        {"division par un", 7, 1, 7, false},
        {"resultat decimal", 1, 3, 0.3333333333333333, false},
        {"division par zero", 10, 0, 0, true},
        {"dividende negatif", -6, 2, -3, false},
    }

    for _, tc := range tests {
        // t.Run cree un sous-test nomme — visible avec go test -v
        t.Run(tc.name, func(t *testing.T) {
            got, err := diviser(tc.a, tc.b)

            if tc.wantError {
                if err == nil {
                    t.Error("erreur attendue, aucune obtenue")
                }
                return
            }
            if err != nil {
                t.Fatalf("erreur inattendue : %v", err)
            }
            if got != tc.want {
                t.Errorf("diviser(%v, %v) = %v ; attendu %v", tc.a, tc.b, got, tc.want)
            }
        })
    }
}

// handlers_http_test.go
package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

// setupTestRouter cree un routeur Gin avec une base SQLite en memoire.
func setupTestRouter(t *testing.T) *gin.Engine {
    t.Helper()
    gin.SetMode(gin.TestMode) // Desactive les logs Gin pendant les tests

    db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
    if err != nil {
        t.Fatalf("Impossible d'ouvrir la base de test : %v", err)
    }
    if err := db.AutoMigrate(&Item{}); err != nil {
        t.Fatalf("Migration echouee : %v", err)
    }

    h := &Handler{DB: db}
    r := gin.New()
    items := r.Group("/items")
    items.GET("", h.ListItems)
    items.POST("", h.CreateItem)
    items.GET("/:id", h.GetItem)
    items.PUT("/:id", h.UpdateItem)
    items.DELETE("/:id", h.DeleteItem)
    return r
}

func TestListItemsVide(t *testing.T) {
    r := setupTestRouter(t)

    w := httptest.NewRecorder()
    req, _ := http.NewRequest(http.MethodGet, "/items", nil)
    r.ServeHTTP(w, req)

    if w.Code != http.StatusOK {
        t.Errorf("code = %d ; attendu %d", w.Code, http.StatusOK)
    }

    var items []Item
    if err := json.Unmarshal(w.Body.Bytes(), &items); err != nil {
        t.Fatalf("Impossible de deserialiser la reponse : %v", err)
    }
    if len(items) != 0 {
        t.Errorf("len(items) = %d ; attendu 0", len(items))
    }
}

func TestCreateItem(t *testing.T) {
    r := setupTestRouter(t)

    payload := map[string]any{"name": "Widget", "price": 9.99, "stock": 10}
    body, _ := json.Marshal(payload)

    w := httptest.NewRecorder()
    req, _ := http.NewRequest(http.MethodPost, "/items", bytes.NewBuffer(body))
    req.Header.Set("Content-Type", "application/json")
    r.ServeHTTP(w, req)

    if w.Code != http.StatusCreated {
        t.Errorf("code = %d ; attendu %d — body: %s", w.Code, http.StatusCreated, w.Body.String())
    }
}

func TestCreateItemPrixInvalide(t *testing.T) {
    r := setupTestRouter(t)

    prixInvalides := []float64{-1, 0, -100.5}
    for _, prix := range prixInvalides {
        t.Run("prix invalide", func(t *testing.T) {
            payload := map[string]any{"name": "Widget", "price": prix}
            body, _ := json.Marshal(payload)

            w := httptest.NewRecorder()
            req, _ := http.NewRequest(http.MethodPost, "/items", bytes.NewBuffer(body))
            req.Header.Set("Content-Type", "application/json")
            r.ServeHTTP(w, req)

            if w.Code != http.StatusBadRequest {
                t.Errorf("prix %v : code = %d ; attendu %d", prix, w.Code, http.StatusBadRequest)
            }
        })
    }
}

func TestGetItemInexistant(t *testing.T) {
    r := setupTestRouter(t)

    w := httptest.NewRecorder()
    req, _ := http.NewRequest(http.MethodGet, "/items/999", nil)
    r.ServeHTTP(w, req)

    if w.Code != http.StatusNotFound {
        t.Errorf("code = %d ; attendu %d", w.Code, http.StatusNotFound)
    }
}

// store.go — Interface de stockage
package main

import "context"

// ItemStore definit le contrat de persistance.
// Toute struct implementant ces methodes satisfait l'interface.
type ItemStore interface {
    FindByID(ctx context.Context, id int) (*Item, error)
    Save(ctx context.Context, item *Item) error
}

// MockItemStore est un mock manuel de ItemStore pour les tests.
type MockItemStore struct {
    items map[int]*Item
}

func NewMockItemStore() *MockItemStore {
    return &MockItemStore{items: make(map[int]*Item)}
}

func (m *MockItemStore) FindByID(_ context.Context, id int) (*Item, error) {
    item, ok := m.items[id]
    if !ok {
        return nil, ErrNotFound
    }
    return item, nil
}

func (m *MockItemStore) Save(_ context.Context, item *Item) error {
    m.items[int(item.ID)] = item
    return nil
}

// bench_test.go
package main

import (
    "strings"
    "testing"
)

// BenchmarkConcatenation compare deux strategies de concatenation de chaines.
func BenchmarkConcatenationNaive(b *testing.B) {
    // b.N est ajuste automatiquement par le framework
    for i := 0; i < b.N; i++ {
        result := ""
        for j := 0; j < 100; j++ {
            result += "x"
        }
        _ = result
    }
}

func BenchmarkConcatenationBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var sb strings.Builder
        for j := 0; j < 100; j++ {
            sb.WriteString("x")
        }
        _ = sb.String()
    }
}

// fuzz_test.go
package main

import (
    "fmt"
    "strings"
    "testing"
    "unicode/utf8"
)

// FuzzParseItem teste que le parsing ne panique jamais sur une entree arbitraire.
// Les corpus initiaux (seed) guident le fuzzer.
func FuzzParseNom(f *testing.F) {
    // Corpus initial — cas connus
    f.Add("Widget")
    f.Add("")
    f.Add("Produit avec espaces")
    f.Add("Nom-tres-long-" + strings.Repeat("x", 200))

    f.Fuzz(func(t *testing.T, nom string) {
        // La fonction ne doit jamais paniquer
        // Elle doit retourner une erreur propre pour les entrees invalides
        if !utf8.ValidString(nom) {
            t.Skip() // Ignore les entrees non-UTF-8
        }
        _ = validerNom(nom) // validerNom est la fonction testee
    })
}

func validerNom(nom string) error {
    if len(nom) == 0 {
        return fmt.Errorf("le nom ne peut pas etre vide")
    }
    if len(nom) > 200 {
        return fmt.Errorf("le nom depasse 200 caracteres")
    }
    return nil
}