Files
archie/internal/infrastructure/cronevents/engine_test.go
T

81 lines
2.6 KiB
Go

package cronevents
import (
"context"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/domain/scheduling"
"github.com/samcharles93/archie-core/internal/events"
)
// chanClock is a deterministic scheduling.Clock: one tick per value sent on
// ch, so the test drives the engine instead of waiting on wall-clock time.
// After returns the same channel every time, and the engine re-arms only when
// it is called again -- so nothing fires unless the test says so.
type chanClock struct{ ch chan time.Time }
func (c chanClock) Now() time.Time { return time.Time{} }
func (c chanClock) After(time.Duration) <-chan time.Time { return c.ch }
// staticSource reports the same due jobs on every tick.
type staticSource []scheduling.Job
func (s staticSource) Due(context.Context, time.Time) ([]scheduling.Job, error) { return s, nil }
type okRunner struct{}
func (okRunner) Run(context.Context, scheduling.Job) error { return nil }
// TestEngineSinkPublishesRealRunOnTheBus is the end-to-end proof of the
// adapter: the engine's own emission, over the bus, as an event the
// dashboard's timeline can read. It runs a real engine on a driven clock --
// no sleeps, no wall-clock deadlines -- so the only thing under test is the
// wiring between Emit and Publish.
func TestEngineSinkPublishesRealRunOnTheBus(t *testing.T) {
bus := events.NewBus()
t.Cleanup(bus.Close)
sub := bus.Subscribe(4)
sink := New(bus)
clock := chanClock{ch: make(chan time.Time, 1)}
engine, err := scheduling.NewEngine(
staticSource{{ID: "daily", Pool: scheduling.PoolParallel, Detail: "daily status summary"}},
okRunner{},
scheduling.EngineConfig{Interval: time.Minute, Clock: clock, Events: sink},
)
if err != nil {
t.Fatalf("NewEngine: %v", err)
}
if err := engine.Start(t.Context()); err != nil {
t.Fatalf("Start: %v", err)
}
t.Cleanup(func() {
// WithoutCancel: t.Context() is cancelled before this cleanup runs,
// and a cancelled ctx would only make Stop give up at once.
ctx, cancel := context.WithTimeout(context.WithoutCancel(t.Context()), 10*time.Second)
defer cancel()
if err := engine.Stop(ctx); err != nil {
t.Errorf("Stop: %v", err)
}
})
clock.ch <- time.Time{} // one tick
select {
case got := <-sub.C:
if got.Kind != scheduling.KindJobRun {
t.Errorf("Kind = %q, want %q", got.Kind, scheduling.KindJobRun)
}
if got.Detail != "daily status summary" {
t.Errorf("Detail = %q, want the engine's job detail", got.Detail)
}
if got.Data["job"] != "daily" {
t.Errorf("Data[job] = %v, want %q", got.Data["job"], "daily")
}
case <-time.After(10 * time.Second):
t.Fatal("no job_run event reached the bus: the engine's run is unobservable")
}
}