fix(dispenser): wait for delivery clearance before FC7
This commit is contained in:
@@ -0,0 +1,391 @@
|
||||
package dispenser
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func apReply(st []byte) []byte {
|
||||
frame := []byte{STX, 0x30, 0x30, 0, byte(len(st) + 2), 'S', 'F'}
|
||||
frame = append(frame, st...)
|
||||
frame = append(frame, ETX)
|
||||
return append(frame, calculateBCC(frame))
|
||||
}
|
||||
|
||||
func workerRequest(c *Client, ctx context.Context, typ cmdType) cmdResp {
|
||||
ch := make(chan cmdResp, 1)
|
||||
c.handle(cmdReq{typ: typ, ctx: ctx, respCh: ch})
|
||||
return <-ch
|
||||
}
|
||||
|
||||
func TestDeliveryDispatchBoundary(t *testing.T) {
|
||||
transportAddress(t)
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
short int
|
||||
badACK bool
|
||||
cancelAfter int
|
||||
pending bool
|
||||
wantErr bool
|
||||
}{
|
||||
{name: "success", pending: true},
|
||||
{name: "command short write", short: 1, wantErr: true},
|
||||
{name: "bad ACK", badACK: true, wantErr: true},
|
||||
{name: "ENQ short write", short: 2, pending: true, wantErr: true},
|
||||
{name: "cancel before ENQ", cancelAfter: 1, wantErr: true},
|
||||
{name: "cancel after ENQ", cancelAfter: 2, pending: true, wantErr: true},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
ack := append([]byte(nil), vendorACK...)
|
||||
if tc.badACK {
|
||||
ack[0] = 0
|
||||
}
|
||||
p := &scriptedTransport{chunks: [][]byte{ack}, shortWrite: tc.short}
|
||||
p.afterWrite = func() {
|
||||
if len(p.writes) == tc.cancelAfter {
|
||||
cancel()
|
||||
}
|
||||
}
|
||||
c := &Client{port: p}
|
||||
r := workerRequest(c, ctx, cmdOutOfMouth)
|
||||
if (r.err != nil) != tc.wantErr || c.deliveryPending != tc.pending {
|
||||
t.Errorf("FC0(%s): err=%v pending=%v, want error=%v pending=%v", tc.name, r.err, c.deliveryPending, tc.wantErr, tc.pending)
|
||||
}
|
||||
if len(p.writes) > 2 {
|
||||
t.Errorf("FC0 writes=%d, want no resend", len(p.writes))
|
||||
}
|
||||
})
|
||||
}
|
||||
t.Run("definite failure preserves previous pending", func(t *testing.T) {
|
||||
c := &Client{port: &scriptedTransport{writeErr: io.ErrClosedPipe}, deliveryPending: true}
|
||||
workerRequest(c, context.Background(), cmdOutOfMouth)
|
||||
if !c.deliveryPending {
|
||||
t.Error("failed FC0 erased previous pending")
|
||||
}
|
||||
})
|
||||
t.Run("ENQ transport error remains pending", func(t *testing.T) {
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK}}
|
||||
p.afterWrite = func() {
|
||||
if len(p.writes) == 2 {
|
||||
p.writeErr = io.ErrClosedPipe
|
||||
}
|
||||
}
|
||||
c := &Client{port: p}
|
||||
r := workerRequest(c, context.Background(), cmdOutOfMouth)
|
||||
if !errors.Is(r.err, io.ErrClosedPipe) || !c.deliveryPending {
|
||||
t.Errorf("ENQ error=%v pending=%v, want closed pipe and pending", r.err, c.deliveryPending)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestWorkerClearanceValidation(t *testing.T) {
|
||||
transportAddress(t)
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
st []byte
|
||||
clear bool
|
||||
}{
|
||||
{"clear", status(0x30), true},
|
||||
{"low stock clear", []byte{0x30, 0x30, 0x31, 0x30}, true},
|
||||
{"residual encoder", status(0x33), false},
|
||||
{"all sensors", status(0x37), false},
|
||||
{"mouth", status(0x34), false},
|
||||
{"unknown diagnostic", []byte{0x30, 0x30, 0xFF, 0x30}, false},
|
||||
{"jam", []byte{0x30, 0x30, 0x32, 0x30}, false},
|
||||
{"overlap", []byte{0x30, 0x30, 0x34, 0x30}, false},
|
||||
{"rejection", []byte{0x36, 0x30, 0x30, 0x30}, false},
|
||||
{"empty", status(0x38), false},
|
||||
{"short payload", []byte{0x30, 0x30, 0x30}, false},
|
||||
{"unknown position", status(0x40), false},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(tc.st), vendorACK}}
|
||||
c := &Client{port: p, deliveryPending: true, deliveryStarted: time.Now(), lastStatus: status(0x30), lastStatusT: time.Now(), statusTTL: time.Hour}
|
||||
r := workerRequest(c, context.Background(), cmdToEncoder)
|
||||
if (r.err == nil) != tc.clear || c.deliveryPending == tc.clear {
|
||||
t.Errorf("FC7(% X): err=%v pending=%v, want clear=%v", tc.st, r.err, c.deliveryPending, tc.clear)
|
||||
}
|
||||
want := []string{"AP"}
|
||||
if tc.clear {
|
||||
want = append(want, "FC7")
|
||||
}
|
||||
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("commands=%v, want %v", got, want)
|
||||
}
|
||||
})
|
||||
}
|
||||
t.Run("bad BCC cannot clear", func(t *testing.T) {
|
||||
frame := apReply(status(0x30))
|
||||
frame[len(frame)-1] ^= 1
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK, frame}}
|
||||
c := &Client{port: p, deliveryPending: true}
|
||||
r := workerRequest(c, context.Background(), cmdToEncoder)
|
||||
if r.err == nil || !c.deliveryPending {
|
||||
t.Errorf("bad BCC: err=%v pending=%v", r.err, c.deliveryPending)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func wireCommands(p *scriptedTransport) []string {
|
||||
var commands []string
|
||||
for _, w := range p.writes {
|
||||
if len(w) > 6 && w[0] == STX {
|
||||
commands = append(commands, string(w[5:len(w)-2]))
|
||||
}
|
||||
}
|
||||
return commands
|
||||
}
|
||||
|
||||
func deliveryWorkerClient(t *testing.T, p *scriptedTransport) (*Client, *time.Time) {
|
||||
t.Helper()
|
||||
transportAddress(t)
|
||||
now := time.Unix(0, 0)
|
||||
c := &Client{port: p, reqCh: make(chan cmdReq, 16), done: make(chan struct{})}
|
||||
c.sequenceTiming = sequenceTiming{now: func() time.Time { return now }, wait: func(ctx context.Context, d time.Duration) error {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
now = now.Add(d)
|
||||
return nil
|
||||
}}
|
||||
stopped := make(chan struct{})
|
||||
go func() { defer close(stopped); c.loop() }()
|
||||
t.Cleanup(func() { c.Close(); <-stopped })
|
||||
return c, &now
|
||||
}
|
||||
|
||||
func TestDeliveryIncidentReplay(t *testing.T) {
|
||||
for _, next := range []bool{false, true} {
|
||||
t.Run(map[bool]string{false: "current", true: "next"}[next], func(t *testing.T) {
|
||||
p := &scriptedTransport{chunks: [][]byte{
|
||||
vendorACK, apReply(status(0x33)), // current card at encoder; encoding succeeds
|
||||
vendorACK, // FC0
|
||||
vendorACK, apReply(status(0x37)), // best effort must defer
|
||||
vendorACK, apReply(status(0x33)), // previous encoder sensor must not succeed
|
||||
vendorACK, apReply(status(0x34)),
|
||||
vendorACK, apReply(status(0x37)),
|
||||
vendorACK, apReply(status(0x30)), // clearance
|
||||
vendorACK, // FC7
|
||||
vendorACK, apReply(status(0x33)),
|
||||
}}
|
||||
c, now := deliveryWorkerClient(t, p)
|
||||
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := c.DeliverCurrentCard(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// A cached clear result must not authorize FC7.
|
||||
c.mu.Lock()
|
||||
c.lastStatus = status(0x30)
|
||||
c.lastStatusT = time.Now()
|
||||
c.statusTTL = time.Hour
|
||||
c.mu.Unlock()
|
||||
if err := c.BeginPrepareNextCard(context.Background()); !errors.Is(err, errDeliveryPending) {
|
||||
t.Fatalf("BeginPrepareNextCard=%v, want deferred", err)
|
||||
}
|
||||
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "FC0", "AP"}) {
|
||||
t.Fatalf("before clearance commands=%v", got)
|
||||
}
|
||||
prepare := c.PrepareCurrentCard
|
||||
if next {
|
||||
prepare = c.PrepareNextCard
|
||||
}
|
||||
if _, err := prepare(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := []string{"AP", "FC0", "AP", "AP", "AP", "AP", "AP", "FC7", "AP"}
|
||||
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("incident commands=%v, want %v", got, want)
|
||||
}
|
||||
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != 3*time.Second {
|
||||
t.Errorf("clearance waits=%s, want 3s", elapsed)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryClearImmediately(t *testing.T) {
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK, vendorACK, apReply(status(0x30)), vendorACK, vendorACK, apReply(status(0x33))}}
|
||||
c, now := deliveryWorkerClient(t, p)
|
||||
if _, err := c.DeliverCurrentCard(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"FC0", "AP", "FC7", "AP"}) {
|
||||
t.Errorf("commands=%v, want FC0 AP FC7 AP", got)
|
||||
}
|
||||
if !now.Equal(time.Unix(0, 0)) {
|
||||
t.Errorf("immediate clearance waited until %v", now)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryClearanceWaitStops(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
response cmdResp
|
||||
cancel bool
|
||||
timeout bool
|
||||
}{
|
||||
{name: "cancel", response: cmdResp{status: status(0x37), deliveryPending: true}, cancel: true},
|
||||
{name: "timeout", response: cmdResp{status: status(0x37), deliveryPending: true}, timeout: true},
|
||||
{name: "transport", response: cmdResp{err: io.ErrUnexpectedEOF}},
|
||||
{name: "jam", response: cmdResp{status: []byte{0x30, 0x30, 0x32, 0x30}, deliveryPending: true}},
|
||||
{name: "empty", response: cmdResp{status: status(0x38), deliveryPending: true}},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
responses := make([]cmdResp, 20)
|
||||
for i := range responses {
|
||||
responses[i] = tc.response
|
||||
}
|
||||
c, d := newSequenceTestClient(t, responses...)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
if tc.cancel {
|
||||
c.sequenceTiming.wait = func(context.Context, time.Duration) error { cancel(); return ctx.Err() }
|
||||
}
|
||||
started := c.sequenceTiming.now()
|
||||
_, err := c.PrepareCurrentCard(ctx)
|
||||
if err == nil {
|
||||
t.Fatal("preparation succeeded while clearance unavailable")
|
||||
}
|
||||
if tc.cancel && !errors.Is(err, context.Canceled) {
|
||||
t.Errorf("error=%v, want canceled", err)
|
||||
}
|
||||
if tc.timeout {
|
||||
if !errors.Is(err, context.DeadlineExceeded) || c.sequenceTiming.now().Sub(started) != sequenceTimeout {
|
||||
t.Errorf("timeout err=%v elapsed=%s", err, c.sequenceTiming.now().Sub(started))
|
||||
}
|
||||
}
|
||||
for _, cmd := range d.commands {
|
||||
if cmd != cmdStatus {
|
||||
t.Errorf("clearance dispatched command %v, want only AP", cmd)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryClearanceDoesNotConsumeRecoveryWindow(t *testing.T) {
|
||||
responses := []cmdResp{{status: status(0x37), deliveryPending: true}, {status: status(0x33), deliveryPending: true}, {status: status(0x30)}}
|
||||
responses = append(responses, prepareFailureResponses(0x32, 7)...)
|
||||
responses = append(responses, cmdResp{status: status(0x30)}, cmdResp{status: status(0x33)})
|
||||
c, d := newSequenceTestClient(t, responses...)
|
||||
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var initial, reset time.Time
|
||||
for i, cmd := range d.commands {
|
||||
if cmd == cmdToEncoder && initial.IsZero() {
|
||||
initial = d.commandTimes[i]
|
||||
}
|
||||
if cmd == cmdReset {
|
||||
reset = d.commandTimes[i]
|
||||
}
|
||||
}
|
||||
if reset.Sub(initial) != sequenceRetryAfter || commandCount(d.commands, cmdReset) != 1 || commandCount(d.commands, cmdToEncoder) != 2 {
|
||||
t.Errorf("recovery commands=%v reset delay=%s, want two FC7 and one RS at 6s", d.commands, reset.Sub(initial))
|
||||
}
|
||||
if got := c.sequenceTiming.now().Sub(reset); got != sequenceResetWait+sequencePollInterval {
|
||||
t.Errorf("post-reset elapsed=%s, want settle plus poll=3s", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryPendingIsNotPersisted(t *testing.T) {
|
||||
c := NewClient(nil, 1)
|
||||
defer c.Close()
|
||||
if c.deliveryPending {
|
||||
t.Error("new Client has pending delivery")
|
||||
}
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x37))}}
|
||||
fresh, _ := deliveryWorkerClient(t, p)
|
||||
if _, err := fresh.PrepareCurrentCard(context.Background()); err != nil {
|
||||
t.Errorf("fresh client encoder status: %v", err)
|
||||
}
|
||||
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP"}) {
|
||||
t.Errorf("restart commands=%v, want AP only", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryCancellationAfterACKDoesNotSetPending(t *testing.T) {
|
||||
transportAddress(t)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK}, afterRead: cancel}
|
||||
c := &Client{port: p}
|
||||
r := workerRequest(c, ctx, cmdOutOfMouth)
|
||||
if !errors.Is(r.err, context.Canceled) || c.deliveryPending || len(p.writes) != 1 {
|
||||
t.Errorf("cancel after ACK: err=%v pending=%v writes=%d, want canceled, false, 1", r.err, c.deliveryPending, len(p.writes))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryClearanceRetainsFullPreparationTimeout(t *testing.T) {
|
||||
responses := make([]cmdResp, 8)
|
||||
for i := range responses {
|
||||
responses[i] = cmdResp{status: status(0x37), deliveryPending: true}
|
||||
}
|
||||
responses = append(responses, cmdResp{status: status(0x30)})
|
||||
responses = append(responses, prepareFailureResponses(0x32, 30)...)
|
||||
c, d := newSequenceTestClient(t, responses...)
|
||||
started := c.sequenceTiming.now()
|
||||
if _, err := c.PrepareCurrentCard(context.Background()); err == nil {
|
||||
t.Fatal("persistent failure succeeded")
|
||||
}
|
||||
if got := c.sequenceTiming.now().Sub(started); got != 8*time.Second+sequenceTimeout {
|
||||
t.Errorf("total duration=%s, want clearance 8s + preparation 16s", got)
|
||||
}
|
||||
if commandCount(d.commands, cmdReset) != 1 || commandCount(d.commands, cmdToEncoder) != 2 {
|
||||
t.Errorf("commands=%v, want one RS and two FC7", d.commands)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWorkerSerializesClearanceAndFC7(t *testing.T) {
|
||||
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK, vendorACK, vendorACK, apReply(status(0x37))}}
|
||||
c, _ := deliveryWorkerClient(t, p)
|
||||
// Set initial state before any request can reach the worker.
|
||||
c.deliveryPending = true
|
||||
c.deliveryStarted = time.Now()
|
||||
reading := make(chan struct{})
|
||||
resume := make(chan struct{})
|
||||
p.afterWrite = func() {
|
||||
if len(p.writes) == 1 {
|
||||
close(reading)
|
||||
<-resume
|
||||
}
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
fc7 := make(chan error, 1)
|
||||
go func() { fc7 <- c.BeginPrepareNextCard(ctx) }()
|
||||
select {
|
||||
case <-reading:
|
||||
case <-ctx.Done():
|
||||
t.Fatal("worker did not begin AP")
|
||||
}
|
||||
fc0 := make(chan cmdResp, 1)
|
||||
// This FC0 is queued while AP is in progress. It must not slip between
|
||||
// the clearance observation and FC7 dispatch.
|
||||
c.reqCh <- cmdReq{typ: cmdOutOfMouth, ctx: ctx, respCh: fc0}
|
||||
close(resume)
|
||||
if err := <-fc7; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if r := <-fc0; r.err != nil {
|
||||
t.Fatal(r.err)
|
||||
}
|
||||
if err := c.ToEncoder(ctx); !errors.Is(err, errDeliveryPending) {
|
||||
t.Errorf("FC7 after queued FC0=%v, want deferred", err)
|
||||
}
|
||||
want := []string{"AP", "FC7", "FC0", "AP"}
|
||||
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("serialized commands=%v, want %v", got, want)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user