two/cmd/agent/main_test.go
GnomeZworc ccf054b5bd
f-41: agent: code de sortie non nul sur toute erreur de démarrage #41
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-12 14:01:49 +02:00

145 lines
3.7 KiB
Go

package main
import (
"context"
"errors"
"io"
"log/slog"
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/pkg/worker"
)
type fakeServer struct {
called atomic.Bool
err error
}
func (f *fakeServer) Shutdown(context.Context) error {
f.called.Store(true)
return f.err
}
func discardLogger() *slog.Logger {
return slog.New(slog.NewTextHandler(io.Discard, nil))
}
func TestShutdown_DrainReussi(t *testing.T) {
q := worker.New(10)
q.Start(2)
var done atomic.Int32
for range 3 {
q.Submit(func() {
time.Sleep(20 * time.Millisecond)
done.Add(1)
})
}
api, prom := &fakeServer{}, &fakeServer{}
servers := map[string]httpShutdowner{"api": api, "prometheus": prom}
if !shutdown(discardLogger(), q, servers, 5*time.Second) {
t.Fatal("un drainage réussi doit autoriser la fermeture de la base")
}
if !api.called.Load() || !prom.called.Load() {
t.Error("tous les serveurs HTTP doivent être arrêtés")
}
if got := done.Load(); got != 3 {
t.Errorf("les 3 tâches devaient se terminer, %d terminées", got)
}
}
func TestShutdown_TimeoutLaisseLaBaseIntacte(t *testing.T) {
q := worker.New(10)
q.Start(1)
q.Submit(func() { time.Sleep(2 * time.Second) })
var buf strings.Builder
log := slog.New(slog.NewTextHandler(&buf, nil))
if shutdown(log, q, map[string]httpShutdowner{}, 50*time.Millisecond) {
t.Fatal("un drainage incomplet ne doit pas autoriser la fermeture de la base")
}
if !strings.Contains(buf.String(), "leaving database untouched") {
t.Errorf("le dépassement devrait être logué, obtenu %q", buf.String())
}
}
func TestShutdown_ErreurServeurNEmpechePasLeDrainage(t *testing.T) {
q := worker.New(10)
q.Start(1)
var buf strings.Builder
log := slog.New(slog.NewTextHandler(&buf, nil))
servers := map[string]httpShutdowner{
"api": &fakeServer{err: errors.New("boom")},
"prometheus": &fakeServer{},
}
if !shutdown(log, q, servers, 5*time.Second) {
t.Fatal("une erreur d'arrêt HTTP ne doit pas empêcher le drainage")
}
if !strings.Contains(buf.String(), "http server shutdown") {
t.Errorf("l'erreur devrait être loguée, obtenu %q", buf.String())
}
}
func TestShutdown_SansServeur(t *testing.T) {
q := worker.New(10)
q.Start(1)
if !shutdown(discardLogger(), q, map[string]httpShutdowner{}, 5*time.Second) {
t.Fatal("l'absence de serveur ne doit pas empêcher un arrêt propre")
}
}
type fakeBase struct{ called bool }
func (f *fakeBase) ApplyBase(frr.Base) error {
f.called = true
return nil
}
func TestApplyBGPBase_RefusesAnInvalidSectionBeforeTouchingFRR(t *testing.T) {
cfg := &configuration.Config{}
cfg.BGP.RouteReflectors = []string{"10.255.255.1"}
f := &fakeBase{}
if err := applyBGPBase(cfg, f); err == nil || !strings.Contains(err.Error(), "bgp.asn must be set") {
t.Errorf("erreur %v", err)
}
if f.called {
t.Error("ApplyBase appelé avec une section bgp invalide")
}
}
func TestRunExitsNonZeroWhenTheConfigCannotBeLoaded(t *testing.T) {
conf := filepath.Join(t.TempDir(), "agent.yml")
if err := os.WriteFile(conf, []byte("bgp: [non: valide\n"), 0o600); err != nil {
t.Fatal(err)
}
if code := run(conf); code != 1 {
t.Errorf("code de sortie %d, 1 attendu", code)
}
}
func TestRunExitsNonZeroWhenTheBGPBaseCannotBeApplied(t *testing.T) {
dir := t.TempDir()
conf := filepath.Join(dir, "agent.yml")
yml := "database:\n path: " + filepath.Join(dir, "db") + "\n" +
"default_interface: two-test-absent0\n" +
"bgp:\n asn: 64600\n route_reflectors: [10.255.255.1]\n"
if err := os.WriteFile(conf, []byte(yml), 0o600); err != nil {
t.Fatal(err)
}
if code := run(conf); code != 1 {
t.Errorf("code de sortie %d, 1 attendu", code)
}
}