You've already forked agentic-coding-workflow
100 lines
2.6 KiB
Go
100 lines
2.6 KiB
Go
package notify
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type fakeRepo struct {
|
|
mu sync.Mutex
|
|
inserted []Message
|
|
failNext bool
|
|
}
|
|
|
|
func (f *fakeRepo) Insert(_ context.Context, msg Message) error {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
if f.failNext {
|
|
f.failNext = false
|
|
return errors.New("db down")
|
|
}
|
|
f.inserted = append(f.inserted, msg)
|
|
return nil
|
|
}
|
|
func (f *fakeRepo) List(context.Context, uuid.UUID, bool, int) ([]Message, error) { return nil, nil }
|
|
func (f *fakeRepo) CountUnread(context.Context, uuid.UUID) (int, error) { return 0, nil }
|
|
func (f *fakeRepo) MarkRead(context.Context, uuid.UUID, uuid.UUID) error { return nil }
|
|
func (f *fakeRepo) MarkAllRead(context.Context, uuid.UUID) error { return nil }
|
|
|
|
type spyNotifier struct {
|
|
name Channel
|
|
count atomic.Int32
|
|
fail bool
|
|
}
|
|
|
|
func (s *spyNotifier) Name() Channel { return s.name }
|
|
func (s *spyNotifier) Send(context.Context, Message) error {
|
|
s.count.Add(1)
|
|
if s.fail {
|
|
return errors.New("send failed")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func newTestLogger() *slog.Logger {
|
|
return slog.New(slog.NewJSONHandler(io.Discard, nil))
|
|
}
|
|
|
|
func TestDispatch_PersistsThenFansOut(t *testing.T) {
|
|
repo := &fakeRepo{}
|
|
spy := &spyNotifier{name: ChannelDummy}
|
|
|
|
d := NewDispatcher(repo, newTestLogger())
|
|
d.Register(spy)
|
|
|
|
require.NoError(t, d.Dispatch(context.Background(), Message{
|
|
UserID: uuid.New(), Topic: "x", Severity: SeverityInfo,
|
|
Title: "t", Body: "b",
|
|
}))
|
|
|
|
require.Len(t, repo.inserted, 1)
|
|
require.NotEqual(t, uuid.Nil, repo.inserted[0].ID, "ID 应被 dispatcher 填充")
|
|
|
|
require.Eventually(t, func() bool { return spy.count.Load() == 1 }, time.Second, 10*time.Millisecond)
|
|
}
|
|
|
|
func TestDispatch_PersistFailureReturnsError_DoesNotFanout(t *testing.T) {
|
|
repo := &fakeRepo{failNext: true}
|
|
spy := &spyNotifier{name: ChannelDummy}
|
|
d := NewDispatcher(repo, newTestLogger())
|
|
d.Register(spy)
|
|
|
|
err := d.Dispatch(context.Background(), Message{UserID: uuid.New(), Topic: "x"})
|
|
require.Error(t, err)
|
|
time.Sleep(50 * time.Millisecond)
|
|
require.Equal(t, int32(0), spy.count.Load())
|
|
}
|
|
|
|
func TestDispatch_NotifierFailureDoesNotBlockOthers(t *testing.T) {
|
|
repo := &fakeRepo{}
|
|
bad := &spyNotifier{name: "bad", fail: true}
|
|
good := &spyNotifier{name: "good"}
|
|
d := NewDispatcher(repo, newTestLogger())
|
|
d.Register(bad)
|
|
d.Register(good)
|
|
|
|
require.NoError(t, d.Dispatch(context.Background(), Message{UserID: uuid.New()}))
|
|
require.Eventually(t, func() bool {
|
|
return bad.count.Load() == 1 && good.count.Load() == 1
|
|
}, time.Second, 10*time.Millisecond)
|
|
}
|