Files
archie/internal/domain/curator/runtime_test.go
T

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)
}
})
}
}