106 lines
3.0 KiB
Go
106 lines
3.0 KiB
Go
package curator
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestReplaceLiveDefinitions(t *testing.T) {
|
|
ctx := t.Context()
|
|
registry := NewRegistry(Registrar{})
|
|
runtime := NewRuntime(registry, RuntimeConfig{})
|
|
if err := runtime.Start(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer func() {
|
|
if err := runtime.Stop(context.Background()); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
for _, tt := range []struct {
|
|
name string
|
|
defs []Definition
|
|
present bool
|
|
wantErr bool
|
|
}{
|
|
{"add without restart", []Definition{{Name: "custom", Enabled: true, Manifest: Manifest{Interval: time.Hour}}}, true, false},
|
|
{"undeclared host refuses replacement", []Definition{{Name: "custom", Enabled: true, Manifest: Manifest{Interval: time.Hour, Tools: []string{"secret"}}}}, true, true},
|
|
{"disable removes loop", []Definition{{Name: "custom", Enabled: false, Manifest: Manifest{Interval: time.Hour}}}, false, false},
|
|
{"re-enable", []Definition{{Name: "custom", Enabled: true, Manifest: Manifest{Interval: 2 * time.Hour}}}, true, false},
|
|
{"delete", nil, false, false},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := runtime.ReplaceDefinitions(ctx, tt.defs)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Fatalf("error = %v", err)
|
|
}
|
|
if _, ok := registry.Get("custom"); ok != tt.present {
|
|
t.Fatalf("registered = %v, want %v", ok, tt.present)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// blockingEngine's Pass blocks until release closes, honouring its context
|
|
// only when obey is set.
|
|
type blockingEngine struct {
|
|
DefinitionEngine
|
|
obey bool
|
|
entered chan struct{}
|
|
release chan struct{}
|
|
}
|
|
|
|
func (e *blockingEngine) Pass(ctx context.Context, _ PassInput) (PassResult, error) {
|
|
close(e.entered)
|
|
if e.obey {
|
|
<-ctx.Done()
|
|
return PassResult{}, ctx.Err()
|
|
}
|
|
<-e.release
|
|
return PassResult{}, nil
|
|
}
|
|
|
|
func TestRemoveInFlightPass(t *testing.T) {
|
|
for _, tt := range []struct {
|
|
name string
|
|
obey bool
|
|
wantErr bool
|
|
readdErr bool
|
|
}{
|
|
{"pass honours cancellation", true, false, false},
|
|
{"pass ignores cancellation", false, true, true},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
runtime := NewRuntime(NewRegistry(Registrar{}), RuntimeConfig{})
|
|
if err := runtime.Start(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
e := &blockingEngine{
|
|
def: Definition{Name: "c", Manifest: Manifest{Interval: time.Hour}},
|
|
obey: tt.obey, entered: make(chan struct{}), release: make(chan struct{}),
|
|
}
|
|
if err := runtime.Add(t.Context(), e); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
<-e.entered
|
|
|
|
ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond)
|
|
defer cancel()
|
|
if err := runtime.Remove(ctx, "c"); (err != nil) != tt.wantErr {
|
|
t.Fatalf("Remove error = %v", err)
|
|
}
|
|
if _, ok := runtime.registry.Get("c"); ok {
|
|
t.Fatal("still registered after Remove")
|
|
}
|
|
if err := runtime.Add(t.Context(), NewDefinitionEngine(e.def)); (err != nil) != tt.readdErr {
|
|
t.Fatalf("re-add error = %v", err)
|
|
}
|
|
close(e.release)
|
|
if err := runtime.Stop(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
}
|
|
}
|