diff --git a/config.example.toml b/config.example.toml index 4e276270f..a278cc71f 100644 --- a/config.example.toml +++ b/config.example.toml @@ -333,6 +333,42 @@ gate_max_failures = 5 # rate_per_second = 1.0 # per-remote-address token bucket # rate_burst = 5 +# The cron/scheduling ticker engine: how often scheduled jobs are checked, +# how many may run at once, and how long one may run. The engine polls a job +# store for what is due and dispatches each due job to the delivery it names +# -- so nothing here schedules anything by itself, it only tunes the timing. +# Absent is valid: every field defaults independently, and a section naming +# only one of them still gets the defaults for the other two. +# +# Zero (or absent) takes the default named below. A NEGATIVE value is a +# startup error, not a clamp: running something other than what was written +# is how a misconfiguration stays invisible. Zero cannot mean "off" here for +# the same reason it cannot in [tools.tool_policy] -- it is indistinguishable +# from an unset key. +# [scheduling] +# interval = "60s" # tick cadence: how often due jobs are checked. +# # Absent/zero means 1m. The finest granularity a +# # cron-style schedule needs, and polling a local +# # job store that often costs nothing. +# max_parallel = 4 # caps simultaneous parallel-pool runs, so a store +# # reporting many jobs due at once (the first tick +# # after long downtime, typically) cannot launch an +# # unbounded fan-out. Absent/zero means 4. It does +# # not bound the sequential pool, which is one by +# # definition. +# job_timeout = "1h" # bounds one run. Absent/zero means 1h. A job that +# # has not finished in an hour is stuck, and leaving +# # it in flight would suppress every later run of the +# # same job forever. +# events_sink = "none" # "bus" publishes each run and failure on the event +# # stream, which is what the dashboard timeline reads; +# # "none" (the default, same as leaving it unset) +# # leaves the engine unobservable -- a scheduled run +# # has no task or chat turn behind it, so with no +# # sink nothing anywhere records that it fired. +# # Any other value is a startup error, so a typo +# # cannot silently turn observability off. + # Playbook-binding at-rest encryption: [bindings].encryption_key resolves a # 32-byte high-entropy key through the secret registry (engine + key) and seals # each binding's HMAC secret in the SQLite bindings.secret column with AES-256- diff --git a/internal/app/archied/scheduling.go b/internal/app/archied/scheduling.go new file mode 100644 index 000000000..52a0a04fa --- /dev/null +++ b/internal/app/archied/scheduling.go @@ -0,0 +1,38 @@ +package archied + +import ( + "fmt" + + "github.com/samcharles93/archie-core/internal/domain/scheduling" + "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/infrastructure/configuration" + "github.com/samcharles93/archie-core/internal/infrastructure/cronevents" +) + +// schedulingConfig translates external input into the domain-owned engine +// configuration and connects the selected event infrastructure. +func schedulingConfig(input configuration.SchedulingInput, bus *events.Bus) (scheduling.EngineConfig, error) { + cfg := scheduling.DefaultEngineConfig() + if input.Interval != 0 { + cfg.Interval = input.Interval.Std() + } + if input.MaxParallel != 0 { + cfg.MaxParallel = input.MaxParallel + } + if input.JobTimeout != 0 { + cfg.JobTimeout = input.JobTimeout.Std() + } + + switch input.EventsSink { + case "", configuration.EventsSinkNone: + case configuration.EventsSinkBus: + cfg.Events = cronevents.New(bus) + default: + return scheduling.EngineConfig{}, fmt.Errorf("%w: scheduling.events_sink %q (want %q or %q)", + configuration.ErrInvalidInput, input.EventsSink, configuration.EventsSinkBus, configuration.EventsSinkNone) + } + if err := cfg.Validate(); err != nil { + return scheduling.EngineConfig{}, fmt.Errorf("%w: %w", configuration.ErrInvalidInput, err) + } + return cfg, nil +} diff --git a/internal/app/archied/scheduling_test.go b/internal/app/archied/scheduling_test.go new file mode 100644 index 000000000..6c9d0c496 --- /dev/null +++ b/internal/app/archied/scheduling_test.go @@ -0,0 +1,86 @@ +package archied + +import ( + "errors" + "testing" + "time" + + "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/infrastructure/configuration" +) + +func TestSchedulingConfigTranslatesExternalInput(t *testing.T) { + tests := []struct { + name string + input configuration.SchedulingInput + wantInterval time.Duration + wantMaxParallel int + wantJobTimeout time.Duration + }{ + { + name: "defaults", + wantInterval: time.Minute, + wantMaxParallel: 4, + wantJobTimeout: time.Hour, + }, + { + name: "configured", + input: configuration.SchedulingInput{ + Interval: configuration.Duration(30 * time.Second), + MaxParallel: 2, + JobTimeout: configuration.Duration(5 * time.Minute), + }, + wantInterval: 30 * time.Second, + wantMaxParallel: 2, + wantJobTimeout: 5 * time.Minute, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := schedulingConfig(tc.input, nil) + if err != nil { + t.Fatal(err) + } + if got.Interval != tc.wantInterval || got.MaxParallel != tc.wantMaxParallel || got.JobTimeout != tc.wantJobTimeout { + t.Errorf("schedulingConfig() = %+v, want interval=%v max_parallel=%d job_timeout=%v", + got, tc.wantInterval, tc.wantMaxParallel, tc.wantJobTimeout) + } + }) + } +} + +func TestSchedulingConfigRejectsInvalidInput(t *testing.T) { + tests := []configuration.SchedulingInput{ + {Interval: configuration.Duration(-time.Second)}, + {MaxParallel: -1}, + {JobTimeout: configuration.Duration(-time.Second)}, + {EventsSink: "kafka"}, + } + for _, input := range tests { + if _, err := schedulingConfig(input, nil); !errors.Is(err, configuration.ErrInvalidInput) { + t.Errorf("schedulingConfig(%+v) error = %v, want ErrInvalidInput", input, err) + } + } +} + +func TestSchedulingConfigSelectsEventSink(t *testing.T) { + bus := events.NewBus() + t.Cleanup(bus.Close) + + for _, mode := range []string{"", configuration.EventsSinkNone} { + cfg, err := schedulingConfig(configuration.SchedulingInput{EventsSink: mode}, bus) + if err != nil { + t.Fatal(err) + } + if cfg.Events != nil { + t.Errorf("events_sink %q produced a sink", mode) + } + } + cfg, err := schedulingConfig(configuration.SchedulingInput{EventsSink: configuration.EventsSinkBus}, bus) + if err != nil { + t.Fatal(err) + } + if cfg.Events == nil { + t.Fatal("events_sink bus produced no sink") + } +} diff --git a/internal/domain/scheduling/ticker.go b/internal/domain/scheduling/ticker.go index 587f028bf..690c405eb 100644 --- a/internal/domain/scheduling/ticker.go +++ b/internal/domain/scheduling/ticker.go @@ -10,20 +10,10 @@ import ( "github.com/samcharles93/archie-core/internal/events" ) -// Defaults for the tunables an operator may leave unset. const ( - // DefaultInterval is the tick cadence when none is configured. A minute - // is the finest granularity a cron-style schedule needs, and polling a - // local job store that often costs nothing. - DefaultInterval = time.Minute - // DefaultMaxParallel caps concurrent parallel-pool runs. It exists so a - // store that reports many jobs due at once (the first tick after a long - // downtime, typically) cannot launch an unbounded fan-out. - DefaultMaxParallel = 4 - // DefaultJobTimeout bounds one run. A scheduled job that has not - // finished in an hour is stuck, and leaving it in flight would suppress - // every later run of the same job forever. - DefaultJobTimeout = time.Hour + defaultInterval = time.Minute + defaultMaxParallel = 4 + defaultJobTimeout = time.Hour ) // Event kinds emitted by the engine, re-exported so callers of this package @@ -49,14 +39,15 @@ const sequentialQueueDepth = 256 // take the documented defaults. type EngineConfig struct { // Interval is the tick cadence: how often the engine asks its source - // what is due. Zero uses DefaultInterval; negative is an error. + // what is due. Zero uses the value from DefaultEngineConfig; negative + // is an error. Interval time.Duration // MaxParallel caps simultaneous parallel-pool runs. Zero uses - // DefaultMaxParallel. It does not bound the sequential pool, which is - // one by definition. + // the value from DefaultEngineConfig. It does not bound the sequential + // pool, which is one by definition. MaxParallel int // JobTimeout bounds a single run via context deadline. Zero uses - // DefaultJobTimeout. + // the value from DefaultEngineConfig. JobTimeout time.Duration // Clock is injectable time. Nil uses the system clock. Clock Clock @@ -65,7 +56,18 @@ type EngineConfig struct { Events Sink } -func (c EngineConfig) validate() error { +// DefaultEngineConfig returns the domain-owned defaults for the engine's +// operator-selectable runtime settings. +func DefaultEngineConfig() EngineConfig { + return EngineConfig{ + Interval: defaultInterval, + MaxParallel: defaultMaxParallel, + JobTimeout: defaultJobTimeout, + } +} + +// Validate rejects unusable engine settings. +func (c EngineConfig) Validate() error { switch { case c.Interval < 0: return fmt.Errorf("scheduling: interval must not be negative, got %v", c.Interval) @@ -79,14 +81,15 @@ func (c EngineConfig) validate() error { // withDefaults returns the config with zero values replaced. func (c EngineConfig) withDefaults() EngineConfig { + d := DefaultEngineConfig() if c.Interval == 0 { - c.Interval = DefaultInterval + c.Interval = d.Interval } if c.MaxParallel == 0 { - c.MaxParallel = DefaultMaxParallel + c.MaxParallel = d.MaxParallel } if c.JobTimeout == 0 { - c.JobTimeout = DefaultJobTimeout + c.JobTimeout = d.JobTimeout } if c.Clock == nil { c.Clock = systemClock{} @@ -134,7 +137,7 @@ func NewEngine(source JobSource, runner Runner, cfg EngineConfig) (*Engine, erro if runner == nil { return nil, errors.New("scheduling: runner must not be nil") } - if err := cfg.validate(); err != nil { + if err := cfg.Validate(); err != nil { return nil, err } cfg = cfg.withDefaults() diff --git a/internal/domain/scheduling/ticker_test.go b/internal/domain/scheduling/ticker_test.go index f3c06f398..0c6d104c8 100644 --- a/internal/domain/scheduling/ticker_test.go +++ b/internal/domain/scheduling/ticker_test.go @@ -332,14 +332,14 @@ func TestNewEngineAppliesDefaults(t *testing.T) { if err != nil { t.Fatalf("NewEngine: %v", err) } - if got := e.Interval(); got != DefaultInterval { - t.Errorf("interval = %v, want %v", got, DefaultInterval) + if got := e.Interval(); got != time.Minute { + t.Errorf("interval = %v, want 1m", got) } - if got := e.MaxParallel(); got != DefaultMaxParallel { - t.Errorf("max parallel = %d, want %d", got, DefaultMaxParallel) + if got := e.MaxParallel(); got != 4 { + t.Errorf("max parallel = %d, want 4", got) } - if got := e.JobTimeout(); got != DefaultJobTimeout { - t.Errorf("job timeout = %v, want %v", got, DefaultJobTimeout) + if got := e.JobTimeout(); got != time.Hour { + t.Errorf("job timeout = %v, want 1h", got) } } diff --git a/internal/infrastructure/configuration/loader.go b/internal/infrastructure/configuration/loader.go index bac412c51..fbe6b1bfe 100644 --- a/internal/infrastructure/configuration/loader.go +++ b/internal/infrastructure/configuration/loader.go @@ -19,6 +19,9 @@ type Document struct { // It stays for now so this package can own loading without every // consumer changing at once. Delete when internal/config is dissolved. Config config.Config + // Scheduling is the decoded [scheduling] input. Application composition + // translates it into domain-owned scheduling.EngineConfig. + Scheduling SchedulingInput // Provenance lists the files that produced Config, in precedence order. Provenance Provenance @@ -138,6 +141,9 @@ func (l *Loader) ApplyOverlay(doc *Document, overrides map[string]any) (*Documen if err := ApplyOverlayValues(&next.Config, overrides); err != nil { return nil, err } + if err := applySchedulingOverlay(&next.Scheduling, overrides); err != nil { + return nil, err + } next.Provenance.record(Origin{Path: "config_overlay (runtime)", Role: RoleMain, Layer: LayerOverlay}) return l.finalize(&next) } @@ -148,12 +154,18 @@ func (l *Loader) overlayFile(basePath, overlayPath string) (*Document, error) { if err := decodeConfigFile(basePath, &doc.Config); err != nil { return nil, err } + if err := decodeSchedulingFile(basePath, &doc.Scheduling); err != nil { + return nil, err + } doc.Provenance.record(Origin{Path: basePath, Role: RoleMain, Layer: LayerBase}) if overlayPath != "" { if err := decodeConfigFile(overlayPath, &doc.Config); err != nil { return nil, err } + if err := decodeSchedulingFile(overlayPath, &doc.Scheduling); err != nil { + return nil, err + } doc.Provenance.record(Origin{Path: overlayPath, Role: RoleMain, Layer: LayerOverlay}) } @@ -202,7 +214,7 @@ func (l *Loader) loadDir(doc *Document, dir string, layer Layer) error { switch path, isYAMLFile, ok := files.main(); { case ok: - if err := l.decodeMain(&doc.Config, path, isYAMLFile); err != nil { + if err := l.decodeMain(doc, path, isYAMLFile); err != nil { return err } doc.Provenance.record(Origin{Path: path, Role: RoleMain, Layer: layer}) @@ -230,11 +242,17 @@ func (l *Loader) loadDir(doc *Document, dir string, layer Layer) error { } // decodeMain decodes the daemon-level file in whichever format it uses. -func (l *Loader) decodeMain(cfg *config.Config, path string, isYAMLFile bool) error { +func (l *Loader) decodeMain(doc *Document, path string, isYAMLFile bool) error { if isYAMLFile { - return decodeYAML(path, cfg) + if err := decodeYAML(path, &doc.Config); err != nil { + return err + } + return decodeSchedulingFile(path, &doc.Scheduling) } - return decodeTOML(path, cfg) + if err := decodeTOML(path, &doc.Config); err != nil { + return err + } + return decodeSchedulingFile(path, &doc.Scheduling) } // finalize applies defaults, then validates. The order matters: validation diff --git a/internal/infrastructure/configuration/scheduling.go b/internal/infrastructure/configuration/scheduling.go new file mode 100644 index 000000000..64a4347c8 --- /dev/null +++ b/internal/infrastructure/configuration/scheduling.go @@ -0,0 +1,66 @@ +package configuration + +import ( + "fmt" + "time" + + "gopkg.in/yaml.v3" +) + +// SchedulingInput is the external [scheduling] input document. It deliberately +// contains no runtime defaults or domain dependencies; application composition +// translates it into scheduling.EngineConfig. +type SchedulingInput struct { + Interval Duration `toml:"interval" yaml:"interval"` + MaxParallel int `toml:"max_parallel" yaml:"max_parallel"` + JobTimeout Duration `toml:"job_timeout" yaml:"job_timeout"` + EventsSink string `toml:"events_sink" yaml:"events_sink"` +} + +// Duration is a textual duration at the configuration boundary. +type Duration time.Duration + +func (d *Duration) UnmarshalText(text []byte) error { + value, err := time.ParseDuration(string(text)) + if err != nil { + return err + } + *d = Duration(value) + return nil +} + +func (d Duration) Std() time.Duration { return time.Duration(d) } + +const ( + EventsSinkBus = "bus" + EventsSinkNone = "none" +) + +type schedulingDocument struct { + Scheduling SchedulingInput `toml:"scheduling" yaml:"scheduling"` +} + +func decodeSchedulingFile(path string, target *SchedulingInput) error { + doc := schedulingDocument{Scheduling: *target} + if err := decodeConfigFile(path, &doc); err != nil { + return err + } + *target = doc.Scheduling + return nil +} + +func applySchedulingOverlay(target *SchedulingInput, overrides map[string]any) error { + if len(overrides) == 0 { + return nil + } + data, err := yaml.Marshal(overrides) + if err != nil { + return fmt.Errorf("%w: encoding scheduling overlay: %w", ErrUnreadable, err) + } + doc := schedulingDocument{Scheduling: *target} + if err := yaml.Unmarshal(data, &doc); err != nil { + return fmt.Errorf("%w: parsing scheduling overlay: %w", ErrUnreadable, err) + } + *target = doc.Scheduling + return nil +} diff --git a/internal/infrastructure/configuration/scheduling_test.go b/internal/infrastructure/configuration/scheduling_test.go new file mode 100644 index 000000000..59c4a382c --- /dev/null +++ b/internal/infrastructure/configuration/scheduling_test.go @@ -0,0 +1,77 @@ +package configuration + +import ( + "os" + "path/filepath" + "testing" + "time" +) + +func writeSchedulingConfig(t *testing.T, section string) string { + t.Helper() + path := filepath.Join(t.TempDir(), "config.toml") + if err := os.WriteFile(path, []byte("bot_user = \"widget\"\n"+section), 0o600); err != nil { + t.Fatal(err) + } + return path +} + +func TestLoaderDecodesSchedulingInputSeparatelyFromRuntimeConfig(t *testing.T) { + doc, err := New(nil).File(writeSchedulingConfig(t, ` +[scheduling] +interval = "30s" +max_parallel = 2 +job_timeout = "5m" +events_sink = "bus" +`)) + if err != nil { + t.Fatal(err) + } + if got := doc.Scheduling.Interval.Std(); got != 30*time.Second { + t.Errorf("Interval = %v, want 30s", got) + } + if got := doc.Scheduling.MaxParallel; got != 2 { + t.Errorf("MaxParallel = %d, want 2", got) + } + if got := doc.Scheduling.JobTimeout.Std(); got != 5*time.Minute { + t.Errorf("JobTimeout = %v, want 5m", got) + } + if got := doc.Scheduling.EventsSink; got != EventsSinkBus { + t.Errorf("EventsSink = %q, want %q", got, EventsSinkBus) + } +} + +func TestLoaderLeavesAbsentSchedulingInputUnset(t *testing.T) { + doc, err := New(nil).File(writeSchedulingConfig(t, "")) + if err != nil { + t.Fatal(err) + } + if doc.Scheduling != (SchedulingInput{}) { + t.Errorf("Scheduling = %+v, want zero external input", doc.Scheduling) + } +} + +func TestSchedulingFileOverlayKeepsUnspecifiedBaseFields(t *testing.T) { + base := writeSchedulingConfig(t, "[scheduling]\ninterval = \"30s\"\nmax_parallel = 2\n") + overlay := filepath.Join(t.TempDir(), "overlay.toml") + if err := os.WriteFile(overlay, []byte("[scheduling]\njob_timeout = \"5m\"\n"), 0o600); err != nil { + t.Fatal(err) + } + doc, err := New(nil).Overlay(base, overlay) + if err != nil { + t.Fatal(err) + } + if doc.Scheduling.Interval.Std() != 30*time.Second || doc.Scheduling.MaxParallel != 2 || doc.Scheduling.JobTimeout.Std() != 5*time.Minute { + t.Errorf("Scheduling = %+v, want merged input", doc.Scheduling) + } +} + +func TestExampleConfigLeavesSchedulingAtDefaults(t *testing.T) { + doc, err := New(nil).File(filepath.Join("..", "..", "..", "config.example.toml")) + if err != nil { + t.Fatal(err) + } + if doc.Scheduling != (SchedulingInput{}) { + t.Errorf("Scheduling = %+v, want commented example to remain unset", doc.Scheduling) + } +} diff --git a/internal/infrastructure/cronevents/engine_test.go b/internal/infrastructure/cronevents/engine_test.go new file mode 100644 index 000000000..ef9fc4cc0 --- /dev/null +++ b/internal/infrastructure/cronevents/engine_test.go @@ -0,0 +1,80 @@ +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") + } +} diff --git a/internal/infrastructure/cronevents/sink.go b/internal/infrastructure/cronevents/sink.go new file mode 100644 index 000000000..7fc4a05c5 --- /dev/null +++ b/internal/infrastructure/cronevents/sink.go @@ -0,0 +1,25 @@ +// Package cronevents adapts the daemon's event bus to scheduling.Sink. +package cronevents + +import ( + "github.com/samcharles93/archie-core/internal/domain/scheduling" + "github.com/samcharles93/archie-core/internal/events" +) + +// New returns a scheduling sink over bus. A nil bus yields a nil sink. +func New(bus *events.Bus) scheduling.Sink { + if bus == nil { + return nil + } + return busSink{bus: bus} +} + +type busSink struct { + bus *events.Bus +} + +func (s busSink) Emit(kind, detail string, data map[string]any) { + s.bus.Publish(events.Event{Kind: kind, Detail: detail, Data: data}) +} + +var _ scheduling.Sink = busSink{} diff --git a/internal/infrastructure/cronevents/sink_test.go b/internal/infrastructure/cronevents/sink_test.go new file mode 100644 index 000000000..ae03f7f78 --- /dev/null +++ b/internal/infrastructure/cronevents/sink_test.go @@ -0,0 +1,66 @@ +package cronevents + +import ( + "testing" + + "github.com/samcharles93/archie-core/internal/domain/scheduling" + "github.com/samcharles93/archie-core/internal/events" +) + +// TestSinkPublishesEmitAsJobEvent: the engine's emitted event is the only +// trace a scheduled run leaves (a job has no task, no chat turn and no +// workflow behind it), so the adapter has to carry Kind, Detail and Data +// across unchanged and must not borrow a task-scoped identity it does not +// have. +func TestSinkPublishesEmitAsJobEvent(t *testing.T) { + bus := events.NewBus() + t.Cleanup(bus.Close) + sub := bus.Subscribe(4) + + sink := New(bus) + if sink == nil { + t.Fatal("New(bus) = nil, want a sink over the bus") + } + + // The shape the engine builds for a completed run + // (internal/domain/scheduling/ticker.go runJob). + sink.Emit(scheduling.KindJobRun, "nightly status", map[string]any{ + "job": "nightly-status", + "pool": string(scheduling.PoolSequential), + "duration_ms": int64(12), + }) + + select { + case got := <-sub.C: + if got.Kind != scheduling.KindJobRun { + t.Errorf("Kind = %q, want %q", got.Kind, scheduling.KindJobRun) + } + if got.Detail != "nightly status" { + t.Errorf("Detail = %q, want unchanged \"nightly status\"", got.Detail) + } + if got.Data["job"] != "nightly-status" { + t.Errorf("Data[job] = %v, want unchanged \"nightly-status\"", got.Data["job"]) + } + if got.Data["duration_ms"] != int64(12) { + t.Errorf("Data[duration_ms] = %v, want unchanged 12", got.Data["duration_ms"]) + } + // The bus stamps publish time when the event carries none. + if got.At.IsZero() { + t.Error("At is zero: a timeline cannot place an event with no timestamp") + } + if got.TaskID != 0 || got.Repo != "" || got.Issue != 0 || got.Workflow != "" || got.Stage != "" { + t.Errorf("event carries task-scoped identity it has none of: %+v", got) + } + default: + t.Fatal("Emit published no event: the dashboard timeline would see nothing") + } +} + +// A missing bus cannot produce an adapter; composition decides whether that +// is acceptable for the selected event mode. +func TestSinkIsNilWithoutABus(t *testing.T) { + sink := New(nil) + if sink != nil { + t.Errorf("New(nil) = %#v, want a nil sink", sink) + } +}