128 lines
3.4 KiB
Go
128 lines
3.4 KiB
Go
package dispatcher
|
|
|
|
import (
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
configuration "git.g3e.fr/syonad/two/internal/config/agent"
|
|
"git.g3e.fr/syonad/two/internal/state"
|
|
"github.com/dgraph-io/badger/v4"
|
|
)
|
|
|
|
func TestDispatcher_Prepare_Success(t *testing.T) {
|
|
d, _ := newTestDispatcher(t)
|
|
cmd := mockCmd{
|
|
prepareFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
executeFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
}
|
|
if err := d.Prepare(cmd); err != nil {
|
|
t.Errorf("Prepare devrait retourner nil, obtenu : %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDispatcher_Prepare_PropagatesError(t *testing.T) {
|
|
d, _ := newTestDispatcher(t)
|
|
want := errors.New("prepare failed")
|
|
cmd := mockCmd{
|
|
prepareFn: func(*badger.DB, *configuration.Config) error { return want },
|
|
executeFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
}
|
|
if err := d.Prepare(cmd); !errors.Is(err, want) {
|
|
t.Errorf("attendu %v, obtenu %v", want, err)
|
|
}
|
|
}
|
|
|
|
func TestDispatcher_Dispatch_ExecutesCommand(t *testing.T) {
|
|
d, _ := newTestDispatcher(t)
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
cmd := mockCmd{
|
|
prepareFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
executeFn: func(*badger.DB, *configuration.Config) error {
|
|
wg.Done()
|
|
return nil
|
|
},
|
|
}
|
|
d.Dispatch(cmd)
|
|
wg.Wait()
|
|
}
|
|
|
|
func TestDispatcher_Dispatch_ExecuteErrorLogged(t *testing.T) {
|
|
d, _ := newTestDispatcher(t)
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
cmd := mockCmd{
|
|
prepareFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
executeFn: func(*badger.DB, *configuration.Config) error {
|
|
defer wg.Done()
|
|
return errors.New("execute failed")
|
|
},
|
|
}
|
|
d.Dispatch(cmd)
|
|
wg.Wait() // Execute s'est terminé — l'erreur est loggée, pas propagée
|
|
}
|
|
|
|
func TestDispatcher_Dispatch_ExecuteErrorSetsErrorState(t *testing.T) {
|
|
d, db := newTestDispatcher(t)
|
|
if err := state.Set(db, "vpc/vpc-1", state.Creating); err != nil {
|
|
t.Fatalf("préparation du test : %v", err)
|
|
}
|
|
|
|
done := make(chan struct{})
|
|
cmd := mockCmd{
|
|
key: "vpc/vpc-1",
|
|
prepareFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
executeFn: func(*badger.DB, *configuration.Config) error {
|
|
return errors.New("execute failed")
|
|
},
|
|
}
|
|
d.Dispatch(cmd)
|
|
|
|
// L'état est écrit après le retour d'Execute : on scrute la DB.
|
|
go func() {
|
|
defer close(done)
|
|
for {
|
|
if s, err := state.Get(db, "vpc/vpc-1"); err == nil && s == state.Error {
|
|
return
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
}()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(2 * time.Second):
|
|
s, _ := state.Get(db, "vpc/vpc-1")
|
|
t.Fatalf("la ressource devrait être en %q, obtenu %q", state.Error, s)
|
|
}
|
|
}
|
|
|
|
func TestDispatcher_Dispatch_ExecuteSuccessKeepsState(t *testing.T) {
|
|
d, db := newTestDispatcher(t)
|
|
if err := state.Set(db, "vpc/vpc-1", state.Running); err != nil {
|
|
t.Fatalf("préparation du test : %v", err)
|
|
}
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
cmd := mockCmd{
|
|
key: "vpc/vpc-1",
|
|
prepareFn: func(*badger.DB, *configuration.Config) error { return nil },
|
|
executeFn: func(*badger.DB, *configuration.Config) error {
|
|
defer wg.Done()
|
|
return nil
|
|
},
|
|
}
|
|
d.Dispatch(cmd)
|
|
wg.Wait()
|
|
time.Sleep(50 * time.Millisecond) // laisse le temps d'une écriture parasite
|
|
|
|
s, err := state.Get(db, "vpc/vpc-1")
|
|
if err != nil {
|
|
t.Fatalf("Get a échoué : %v", err)
|
|
}
|
|
if s != state.Running {
|
|
t.Errorf("l'état devrait rester %q, obtenu %q", state.Running, s)
|
|
}
|
|
}
|