115 lines
2.9 KiB
Go
115 lines
2.9 KiB
Go
package eventbus
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"lingniu-vehicle-ingest/go/vehicle-gateway/internal/envelope"
|
|
)
|
|
|
|
func TestAsyncSinkPublishRawReturnsAfterQueueing(t *testing.T) {
|
|
delegate := newBlockingSink()
|
|
sink := NewAsyncSink(delegate, AsyncConfig{QueueSize: 1, Workers: 1, OperationTimeout: time.Second})
|
|
|
|
start := time.Now()
|
|
if err := sink.PublishRaw(context.Background(), envelope.FrameEnvelope{Protocol: envelope.ProtocolGB32960, VIN: "LNBSCB3D4R1234567"}); err != nil {
|
|
t.Fatalf("PublishRaw() error = %v", err)
|
|
}
|
|
if elapsed := time.Since(start); elapsed > 100*time.Millisecond {
|
|
t.Fatalf("PublishRaw() blocked for %s, want quick queueing", elapsed)
|
|
}
|
|
|
|
select {
|
|
case <-delegate.rawStarted:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("delegate raw publish was not started")
|
|
}
|
|
delegate.release()
|
|
if err := sink.Close(); err != nil {
|
|
t.Fatalf("Close() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAsyncSinkPublishesInFIFOOrderWithSingleWorker(t *testing.T) {
|
|
delegate := &orderedSink{}
|
|
sink := NewAsyncSink(delegate, AsyncConfig{QueueSize: 4, Workers: 1, OperationTimeout: time.Second})
|
|
|
|
env := envelope.FrameEnvelope{Protocol: envelope.ProtocolJT808, Phone: "13307795425"}
|
|
if err := sink.PublishRaw(context.Background(), env); err != nil {
|
|
t.Fatalf("PublishRaw() error = %v", err)
|
|
}
|
|
if err := sink.PublishUnified(context.Background(), env); err != nil {
|
|
t.Fatalf("PublishUnified() error = %v", err)
|
|
}
|
|
if err := sink.Close(); err != nil {
|
|
t.Fatalf("Close() error = %v", err)
|
|
}
|
|
|
|
if got, want := delegate.calls, []string{"raw", "unified"}; len(got) != len(want) || got[0] != want[0] || got[1] != want[1] {
|
|
t.Fatalf("calls = %#v, want %#v", got, want)
|
|
}
|
|
}
|
|
|
|
type blockingSink struct {
|
|
rawStarted chan struct{}
|
|
releaseRaw chan struct{}
|
|
}
|
|
|
|
func newBlockingSink() *blockingSink {
|
|
return &blockingSink{
|
|
rawStarted: make(chan struct{}),
|
|
releaseRaw: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (s *blockingSink) PublishRaw(context.Context, envelope.FrameEnvelope) error {
|
|
close(s.rawStarted)
|
|
<-s.releaseRaw
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingSink) PublishUnified(context.Context, envelope.FrameEnvelope) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingSink) PublishFields(context.Context, envelope.FrameEnvelope) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingSink) Close() error {
|
|
s.release()
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingSink) release() {
|
|
select {
|
|
case <-s.releaseRaw:
|
|
default:
|
|
close(s.releaseRaw)
|
|
}
|
|
}
|
|
|
|
type orderedSink struct {
|
|
calls []string
|
|
}
|
|
|
|
func (s *orderedSink) PublishRaw(context.Context, envelope.FrameEnvelope) error {
|
|
s.calls = append(s.calls, "raw")
|
|
return nil
|
|
}
|
|
|
|
func (s *orderedSink) PublishUnified(context.Context, envelope.FrameEnvelope) error {
|
|
s.calls = append(s.calls, "unified")
|
|
return nil
|
|
}
|
|
|
|
func (s *orderedSink) PublishFields(context.Context, envelope.FrameEnvelope) error {
|
|
s.calls = append(s.calls, "fields")
|
|
return nil
|
|
}
|
|
|
|
func (s *orderedSink) Close() error {
|
|
return nil
|
|
}
|