Eric Rakestraw
96039f6530
- add new `processors` package with canonical `Processor` interface - add `processors.Registry` with Register/Build/BuildChain factory model - switch `pipeline.Pipeline` to `[]processors.Processor` - replace `normalize.Registry` + registry adapter with direct `normalize.Processor` - remove `normalize/registry.go` - update root docs to position normalize as one optional processing stage - add tests for processors registry, normalize processor behavior, and pipeline flow BREAKING CHANGE: - `pipeline.Processor` removed; use `processors.Processor` - `normalize.Registry` and old normalize processor adapter APIs removed - downstream daemons must update processor wiring to new `processors.Registry` and `normalize.NewProcessor(...)`
101 lines
2.5 KiB
Go
101 lines
2.5 KiB
Go
package processors
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/ejr/feedkit/event"
|
|
)
|
|
|
|
type testProcessor struct {
|
|
name string
|
|
}
|
|
|
|
func (p testProcessor) Process(context.Context, event.Event) (*event.Event, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func TestRegistryRegisterValidation(t *testing.T) {
|
|
t.Run("empty driver panics", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
assertPanics(t, func() {
|
|
r.Register(" ", func() (Processor, error) { return testProcessor{name: "x"}, nil })
|
|
})
|
|
})
|
|
|
|
t.Run("nil factory panics", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
assertPanics(t, func() {
|
|
r.Register("normalize", nil)
|
|
})
|
|
})
|
|
|
|
t.Run("duplicate driver panics", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
r.Register("normalize", func() (Processor, error) { return testProcessor{name: "a"}, nil })
|
|
assertPanics(t, func() {
|
|
r.Register("normalize", func() (Processor, error) { return testProcessor{name: "b"}, nil })
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestRegistryBuildUnknownDriver(t *testing.T) {
|
|
r := NewRegistry()
|
|
_, err := r.Build("does_not_exist")
|
|
if err == nil {
|
|
t.Fatalf("expected error for unknown driver")
|
|
}
|
|
if !strings.Contains(err.Error(), "unknown processor driver") {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRegistryBuildChainPreservesOrder(t *testing.T) {
|
|
r := NewRegistry()
|
|
r.Register("first", func() (Processor, error) { return testProcessor{name: "first"}, nil })
|
|
r.Register("second", func() (Processor, error) { return testProcessor{name: "second"}, nil })
|
|
|
|
chain, err := r.BuildChain([]string{"first", "second"})
|
|
if err != nil {
|
|
t.Fatalf("BuildChain error: %v", err)
|
|
}
|
|
if len(chain) != 2 {
|
|
t.Fatalf("expected 2 processors, got %d", len(chain))
|
|
}
|
|
|
|
p0, ok := chain[0].(testProcessor)
|
|
if !ok || p0.name != "first" {
|
|
t.Fatalf("unexpected chain[0]: %#v", chain[0])
|
|
}
|
|
p1, ok := chain[1].(testProcessor)
|
|
if !ok || p1.name != "second" {
|
|
t.Fatalf("unexpected chain[1]: %#v", chain[1])
|
|
}
|
|
}
|
|
|
|
func TestRegistryBuildChainIndexedFailure(t *testing.T) {
|
|
r := NewRegistry()
|
|
r.Register("ok", func() (Processor, error) { return testProcessor{name: "ok"}, nil })
|
|
r.Register("broken", func() (Processor, error) { return nil, errors.New("boom") })
|
|
|
|
_, err := r.BuildChain([]string{"ok", "broken"})
|
|
if err == nil {
|
|
t.Fatalf("expected error")
|
|
}
|
|
if !strings.Contains(err.Error(), "chain[1]") {
|
|
t.Fatalf("expected indexed error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func assertPanics(t *testing.T, fn func()) {
|
|
t.Helper()
|
|
defer func() {
|
|
if recover() == nil {
|
|
t.Fatalf("expected panic")
|
|
}
|
|
}()
|
|
fn()
|
|
}
|