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