fix(dispenser): simplify card preparation and recovery

This commit is contained in:
2026-09-27 22:21:28 +01:00
parent 99c74f49b6
commit e26331ffa9
6 changed files with 710 additions and 952 deletions
+127 -59
View File
@@ -95,18 +95,22 @@ func TestWorkerClearanceValidation(t *testing.T) {
{"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},
{"ready", status(0x34), true},
{"unknown diagnostic", []byte{0x30, 0x30, 0xFF, 0x30}, true},
{"jam", []byte{0x30, 0x30, 0x32, 0x30}, true},
{"overlap", []byte{0x30, 0x30, 0x34, 0x30}, true},
{"rejection", []byte{0x36, 0x30, 0x30, 0x30}, true},
{"empty", status(0x38), false},
{"preparing", []byte{0x31, 0x30, 0x30, 0x30}, false},
{"dispensing", []byte{0x30, 0x38, 0x30, 0x34}, false},
{"capturing", []byte{0x30, 0x34, 0x30, 0x30}, false},
{"ready with stale errors", []byte{0x36, 0x32, 0x34, 0x34}, true},
{"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}
c := &Client{port: p, deliveryPending: true, deliveryStarted: time.Now().Add(-deliveryMinimumWait), 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)
@@ -169,8 +173,6 @@ func TestDeliveryIncidentReplay(t *testing.T) {
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)),
}}
@@ -187,11 +189,11 @@ func TestDeliveryIncidentReplay(t *testing.T) {
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 err := c.BeginPrepareNextCard(context.Background()); err != nil {
t.Fatal(err)
}
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "FC0", "AP"}) {
t.Fatalf("before clearance commands=%v", got)
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "FC0", "AP", "AP", "AP", "FC7"}) {
t.Fatalf("prestaging commands=%v, want clearance APs then one FC7", got)
}
prepare := c.PrepareCurrentCard
if next {
@@ -200,31 +202,36 @@ func TestDeliveryIncidentReplay(t *testing.T) {
if _, err := prepare(context.Background()); err != nil {
t.Fatal(err)
}
want := []string{"AP", "FC0", "AP", "AP", "AP", "AP", "AP", "FC7", "AP"}
want := []string{"AP", "FC0", "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)
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != 2*time.Second {
t.Errorf("clearance waits=%s, want 2s", 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 TestDeliveryClearWaitsTwoSeconds(t *testing.T) {
for _, position := range []byte{0x30, 0x34} {
p := &scriptedTransport{chunks: [][]byte{vendorACK,
vendorACK, apReply(status(position)), vendorACK, apReply(status(position)), vendorACK, apReply(status(position)),
vendorACK, vendorACK, apReply(status(0x37))}}
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)
}
want := []string{"FC0", "AP", "AP", "AP", "FC7", "AP"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("clearance %X commands=%v, want %v", position, got, want)
}
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != deliveryMinimumWait {
t.Errorf("clearance %X elapsed=%s, want 2s", position, elapsed)
}
}
}
@@ -238,7 +245,7 @@ func TestDeliveryClearanceWaitStops(t *testing.T) {
{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: "movement", response: cmdResp{status: []byte{0x31, 0x30, 0x32, 0x30}, deliveryPending: true}},
{name: "empty", response: cmdResp{status: status(0x38), deliveryPending: true}},
} {
t.Run(tc.name, func(t *testing.T) {
@@ -261,7 +268,7 @@ func TestDeliveryClearanceWaitStops(t *testing.T) {
t.Errorf("error=%v, want canceled", err)
}
if tc.timeout {
if !errors.Is(err, context.DeadlineExceeded) || c.sequenceTiming.now().Sub(started) != sequenceTimeout {
if !errors.Is(err, context.DeadlineExceeded) || c.sequenceTiming.now().Sub(started) != deliveryClearanceTimeout {
t.Errorf("timeout err=%v elapsed=%s", err, c.sequenceTiming.now().Sub(started))
}
}
@@ -275,27 +282,21 @@ func TestDeliveryClearanceWaitStops(t *testing.T) {
}
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)})
responses := make([]cmdResp, 15)
for i := range responses {
responses[i] = cmdResp{status: status(0x37), deliveryPending: true}
}
responses = append(responses, positionResponses(0x30, 17)...)
c, d := newSequenceTestClient(t, responses...)
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Fatal(err)
start := c.now()
if _, err := c.PrepareCurrentCard(context.Background()); !errors.Is(err, ErrPreparationExhausted) {
t.Fatalf("preparation error=%v, want exhausted", 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 elapsed := c.now().Sub(start); elapsed != 33*time.Second {
t.Errorf("elapsed=%s, want clearance 15s + shakes 18s", elapsed)
}
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)
if commandCount(d.commands, cmdReset) != 3 || commandCount(d.commands, cmdToEncoder) != 4 {
t.Errorf("commands=%v, want 3 RS and 4 FC7", d.commands)
}
}
@@ -332,18 +333,24 @@ func TestDeliveryClearanceRetainsFullPreparationTimeout(t *testing.T) {
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)...)
responses = append(responses, positionResponses(0x30, 2)...)
c, d := newSequenceTestClient(t, responses...)
started := c.sequenceTiming.now()
if _, err := c.PrepareCurrentCard(context.Background()); err == nil {
t.Fatal("persistent failure succeeded")
wait := c.sequenceTiming.wait
c.sequenceTiming.wait = func(ctx context.Context, duration time.Duration) error {
if commandCount(d.commands, cmdToEncoder) > 0 {
duration = sequenceTimeout
}
return wait(ctx, duration)
}
if got := c.sequenceTiming.now().Sub(started); got != 8*time.Second+sequenceTimeout {
t.Errorf("total duration=%s, want clearance 8s + preparation 16s", got)
start := c.now()
if _, err := c.PrepareCurrentCard(context.Background()); !errors.Is(err, ErrPreparationExhausted) {
t.Fatalf("preparation error=%v, want exhausted", err)
}
if commandCount(d.commands, cmdReset) != 1 || commandCount(d.commands, cmdToEncoder) != 2 {
t.Errorf("commands=%v, want one RS and two FC7", d.commands)
if elapsed := c.now().Sub(start); elapsed != 8*time.Second+sequenceTimeout {
t.Errorf("elapsed=%s, want clearance 8s + preparation 32s", elapsed)
}
if commandCount(d.commands, cmdReset) != 0 || commandCount(d.commands, cmdToEncoder) != 1 {
t.Errorf("commands=%v, want one FC7 and no RS after deadline", d.commands)
}
}
@@ -352,7 +359,7 @@ func TestWorkerSerializesClearanceAndFC7(t *testing.T) {
c, _ := deliveryWorkerClient(t, p)
// Set initial state before any request can reach the worker.
c.deliveryPending = true
c.deliveryStarted = time.Now()
c.deliveryStarted = c.now().Add(-deliveryMinimumWait)
reading := make(chan struct{})
resume := make(chan struct{})
p.afterWrite = func() {
@@ -389,3 +396,64 @@ func TestWorkerSerializesClearanceAndFC7(t *testing.T) {
t.Errorf("serialized commands=%v, want %v", got, want)
}
}
func TestDeliveryCancellationAfterFreshAPKeepsPending(t *testing.T) {
transportAddress(t)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x34))}}
p.afterRead = func() {
if len(p.chunks) == 0 {
cancel()
}
}
c := &Client{port: p, deliveryPending: true, deliveryStarted: time.Now().Add(-time.Minute)}
r := workerRequest(c, ctx, cmdToEncoder)
if !errors.Is(r.err, context.Canceled) || !c.deliveryPending {
t.Errorf("AP cancellation err=%v pending=%t, want canceled and pending", r.err, c.deliveryPending)
}
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP"}) {
t.Errorf("cancelled clearance commands=%v, want AP only", got)
}
}
func TestPreparationWireFailuresNeverShake(t *testing.T) {
badBCC := apReply(status(0x30))
badBCC[len(badBCC)-1] ^= 1
for _, frame := range [][]byte{nil, apReply(status(0x30))[:8], badBCC, apReply(status(0x40))} {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK, vendorACK}}
if frame != nil {
p.chunks = append(p.chunks, frame)
}
c, _ := deliveryWorkerClient(t, p)
if _, err := c.PrepareCurrentCard(context.Background()); err == nil || errors.Is(err, ErrPreparationExhausted) {
t.Errorf("frame % X: err=%v, want transport/protocol failure", frame, err)
}
want := []string{"AP", "FC7", "AP"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("frame % X commands=%v, want %v without RS or resends", frame, got, want)
}
}
}
func TestBeginPrepareNextCardWaitsForClearanceWithoutReadinessPolling(t *testing.T) {
for _, position := range []byte{0x30, 0x34} {
p := &scriptedTransport{chunks: [][]byte{vendorACK,
vendorACK, apReply(status(position)), vendorACK, apReply(status(position)), vendorACK, apReply(status(position)),
vendorACK}}
c, now := deliveryWorkerClient(t, p)
if _, err := c.DeliverCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
if err := c.BeginPrepareNextCard(context.Background()); err != nil {
t.Fatal(err)
}
want := []string{"FC0", "AP", "AP", "AP", "FC7"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("BeginPrepareNextCard(%X) commands = %v, want %v", position, got, want)
}
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != deliveryMinimumWait {
t.Errorf("BeginPrepareNextCard(%X) waited %s, want %s", position, elapsed, deliveryMinimumWait)
}
}
}