add independent audio worker
This commit is contained in:
Dmitry Sergeev
@@ -0,0 +1,241 @@
|
||||
package playback
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type queuedAudioFactory struct {
|
||||
readers []AudioReader
|
||||
errs []error
|
||||
calls int
|
||||
}
|
||||
|
||||
func (f *queuedAudioFactory) OpenAudio(
|
||||
context.Context,
|
||||
FeedConfig,
|
||||
) (AudioReader, error) {
|
||||
index := f.calls
|
||||
f.calls++
|
||||
if index < len(f.errs) && f.errs[index] != nil {
|
||||
return nil, f.errs[index]
|
||||
}
|
||||
if index < len(f.readers) {
|
||||
return f.readers[index], nil
|
||||
}
|
||||
return nil, errors.New("unexpected audio open")
|
||||
}
|
||||
|
||||
func newAudioWorkerForTest(
|
||||
t *testing.T,
|
||||
factory AudioReaderFactory,
|
||||
sink AudioSink,
|
||||
maxAttempts int,
|
||||
shouldRetry func(error) bool,
|
||||
observer StatusObserver,
|
||||
) *AudioWorker {
|
||||
t.Helper()
|
||||
worker, err := NewAudioWorker(
|
||||
factory,
|
||||
sink,
|
||||
testRetryPolicy(maxAttempts),
|
||||
shouldRetry,
|
||||
observer,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("NewAudioWorker() error = %v", err)
|
||||
}
|
||||
worker.wait = func(context.Context, time.Duration) error { return nil }
|
||||
return worker
|
||||
}
|
||||
|
||||
func TestNewAudioWorkerValidatesDependencies(t *testing.T) {
|
||||
factory := &fakeAudioFactory{}
|
||||
sink := &fakeAudioSink{}
|
||||
retry := testRetryPolicy(3)
|
||||
decider := func(error) bool { return true }
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
factory AudioReaderFactory
|
||||
sink AudioSink
|
||||
retry RetryPolicy
|
||||
decider func(error) bool
|
||||
wantErr error
|
||||
}{
|
||||
{name: "factory", sink: sink, retry: retry, decider: decider, wantErr: ErrAudioFactoryRequired},
|
||||
{name: "sink", factory: factory, retry: retry, decider: decider, wantErr: ErrAudioSinkRequired},
|
||||
{name: "decider", factory: factory, sink: sink, retry: retry, wantErr: ErrAudioRetryDeciderRequired},
|
||||
{
|
||||
name: "retry policy",
|
||||
factory: factory,
|
||||
sink: sink,
|
||||
retry: RetryPolicy{},
|
||||
decider: decider,
|
||||
wantErr: ErrInvalidRetryDelay,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
worker, err := NewAudioWorker(
|
||||
tt.factory,
|
||||
tt.sink,
|
||||
tt.retry,
|
||||
tt.decider,
|
||||
nil,
|
||||
)
|
||||
if worker != nil {
|
||||
t.Fatalf("NewAudioWorker() worker = %#v, want nil", worker)
|
||||
}
|
||||
if !errors.Is(err, tt.wantErr) {
|
||||
t.Fatalf("NewAudioWorker() error = %v, want %v", err, tt.wantErr)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAudioWorkerRejectsInactiveFeed(t *testing.T) {
|
||||
worker := newAudioWorkerForTest(
|
||||
t,
|
||||
&fakeAudioFactory{},
|
||||
&fakeAudioSink{},
|
||||
1,
|
||||
func(error) bool { return false },
|
||||
nil,
|
||||
)
|
||||
|
||||
err := worker.Run(
|
||||
context.Background(),
|
||||
FeedConfig{Domain: "/audio", UUID: "audio", Active: false},
|
||||
)
|
||||
if !errors.Is(err, ErrAudioFeedInactive) {
|
||||
t.Fatalf("Run() error = %v, want %v", err, ErrAudioFeedInactive)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAudioWorkerPublishesPlayingThenFailed(t *testing.T) {
|
||||
readErr := errors.New("audio disappeared")
|
||||
reader := &fakeAudioReader{
|
||||
frames: []AudioFrame{{Index: 1, Samples: [][]byte{{1, 2, 3, 4}}}},
|
||||
readErr: readErr,
|
||||
}
|
||||
var statuses []Status
|
||||
worker := newAudioWorkerForTest(
|
||||
t,
|
||||
&fakeAudioFactory{reader: reader},
|
||||
&fakeAudioSink{},
|
||||
1,
|
||||
func(error) bool { return false },
|
||||
func(status Status) { statuses = append(statuses, status) },
|
||||
)
|
||||
|
||||
err := worker.Run(
|
||||
context.Background(),
|
||||
FeedConfig{Domain: "/audio", UUID: "audio", Active: true},
|
||||
)
|
||||
if !errors.Is(err, readErr) {
|
||||
t.Fatalf("Run() error = %v, want %v", err, readErr)
|
||||
}
|
||||
wantStates := []State{StateConnecting, StatePlaying, StateFailed}
|
||||
if len(statuses) != len(wantStates) {
|
||||
t.Fatalf("status count = %d, want %d: %#v", len(statuses), len(wantStates), statuses)
|
||||
}
|
||||
for i, want := range wantStates {
|
||||
if statuses[i].Unit != UnitAudio || statuses[i].State != want {
|
||||
t.Errorf("status[%d] = %#v, want audio/%v", i, statuses[i], want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAudioWorkerRetriesUpToAttemptLimit(t *testing.T) {
|
||||
openErr := errors.New("audio unavailable")
|
||||
factory := &queuedAudioFactory{errs: []error{openErr, openErr, openErr}}
|
||||
var statuses []Status
|
||||
worker := newAudioWorkerForTest(
|
||||
t,
|
||||
factory,
|
||||
&fakeAudioSink{},
|
||||
3,
|
||||
func(error) bool { return true },
|
||||
func(status Status) { statuses = append(statuses, status) },
|
||||
)
|
||||
|
||||
err := worker.Run(
|
||||
context.Background(),
|
||||
FeedConfig{Domain: "/audio", UUID: "audio", Active: true},
|
||||
)
|
||||
if !errors.Is(err, openErr) {
|
||||
t.Fatalf("Run() error = %v, want %v", err, openErr)
|
||||
}
|
||||
if factory.calls != 3 {
|
||||
t.Fatalf("open calls = %d, want 3", factory.calls)
|
||||
}
|
||||
last := statuses[len(statuses)-1]
|
||||
if last.State != StateFailed || last.Attempt != 3 || last.FailedAttempts != 3 {
|
||||
t.Fatalf("last status = %#v, want failed attempt 3", last)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAudioWorkerDoesNotRetrySinkFailure(t *testing.T) {
|
||||
sinkErr := errors.New("output failed")
|
||||
factory := &fakeAudioFactory{
|
||||
reader: &fakeAudioReader{frames: []AudioFrame{{Index: 1}}},
|
||||
}
|
||||
worker := newAudioWorkerForTest(
|
||||
t,
|
||||
factory,
|
||||
&fakeAudioSink{err: sinkErr},
|
||||
3,
|
||||
func(error) bool { return true },
|
||||
nil,
|
||||
)
|
||||
|
||||
err := worker.Run(
|
||||
context.Background(),
|
||||
FeedConfig{Domain: "/audio", UUID: "audio", Active: true},
|
||||
)
|
||||
if !errors.Is(err, sinkErr) {
|
||||
t.Fatalf("Run() error = %v, want %v", err, sinkErr)
|
||||
}
|
||||
if factory.calls != 1 {
|
||||
t.Fatalf("open calls = %d, want 1", factory.calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAudioWorkerCancellationPublishesStoppingAndIdle(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
reader := &fakeAudioReader{
|
||||
read: func(ctx context.Context) (AudioFrame, error) {
|
||||
cancel()
|
||||
<-ctx.Done()
|
||||
return AudioFrame{}, ctx.Err()
|
||||
},
|
||||
}
|
||||
var statuses []Status
|
||||
worker := newAudioWorkerForTest(
|
||||
t,
|
||||
&fakeAudioFactory{reader: reader},
|
||||
&fakeAudioSink{},
|
||||
1,
|
||||
func(error) bool { return true },
|
||||
func(status Status) { statuses = append(statuses, status) },
|
||||
)
|
||||
|
||||
err := worker.Run(
|
||||
ctx,
|
||||
FeedConfig{Domain: "/audio", UUID: "audio", Active: true},
|
||||
)
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("Run() error = %v, want %v", err, context.Canceled)
|
||||
}
|
||||
if len(statuses) < 3 {
|
||||
t.Fatalf("statuses = %#v, want connecting, stopping, idle", statuses)
|
||||
}
|
||||
last := statuses[len(statuses)-2:]
|
||||
if last[0].State != StateStopping || last[1].State != StateIdle {
|
||||
t.Fatalf("final statuses = %#v, want stopping then idle", last)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user