Main reverted G's half merge (#189, reverted by8afc3ebin #191) and then took the reader release's S1-S5, which copied G's code. G's form holds where they differ (process_bus.go, seats.go, state.go and their tests); the release's kept names stay so main's callers keep building: SeatViewPrefix beside SeatReadPrefix, and QueueInvoke's empty strings on not-ok (with its test TestQueueInvoke). The tree differs from G's headf30dee54only by those and the release's two tests (objects cap option, seat states and stream kinds). Builds: design 47 G (the milestone's sdk part, as atf30dee54) Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
95 lines
3.0 KiB
Go
95 lines
3.0 KiB
Go
package buscalls
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
)
|
|
|
|
// lineMem is a core connection in memory: what Send publishes is kept, and when ackOf says so the chunk is acknowledged as the
|
|
// caller does, with a request on the ack subject, whose reply Send must give.
|
|
type lineMem struct {
|
|
mu sync.Mutex
|
|
handler nats.MsgHandler
|
|
subject string
|
|
chunks map[string][]byte
|
|
order []string
|
|
ackOf func(n int64) (string, bool)
|
|
}
|
|
|
|
func (l *lineMem) Subscribe(subject string, cb nats.MsgHandler) (*nats.Subscription, error) {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
l.handler, l.subject = cb, subject
|
|
return nil, nil
|
|
}
|
|
|
|
func (l *lineMem) Publish(subject string, data []byte) error {
|
|
l.mu.Lock()
|
|
l.chunks[subject] = data
|
|
l.order = append(l.order, subject)
|
|
h := l.handler
|
|
l.mu.Unlock()
|
|
var c SeatChunk
|
|
_ = json.Unmarshal(data, &c)
|
|
if sub, ok := l.ackOf(c.N); ok {
|
|
go h(&nats.Msg{Subject: sub, Reply: "_INBOX.x", Sub: nil})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TestSeatChunksSend: the bytes go in chunks of at most SeatChunkBytes, each published only after the one before is
|
|
// acknowledged, and the receive of the same form reads them back; an acknowledgement missed or of another call ends the
|
|
// send (design 47 G §681, A-237, A-139).
|
|
func TestSeatChunksSend(t *testing.T) {
|
|
c := SeatChunks{Seat: "mesh-catalog", Verb: "input", Call: "0123456789abcdef"}
|
|
body := bytes.Repeat([]byte("x"), 2*SeatChunkBytes+5)
|
|
for _, tc := range []struct {
|
|
name string
|
|
ackOf func(int64) (string, bool)
|
|
err string
|
|
sent int
|
|
}{
|
|
{name: "every chunk acknowledged", ackOf: func(n int64) (string, bool) { return c.Ack(n), true }, sent: 3},
|
|
{name: "no acknowledgement", ackOf: func(int64) (string, bool) { return "", false }, err: "chunk 1 of 3", sent: 1},
|
|
{name: "another call's acknowledgement", ackOf: func(n int64) (string, bool) {
|
|
return SeatChunks{Seat: "mesh-catalog", Verb: "input", Call: "fedcba9876543210"}.Ack(n), true
|
|
}, err: "chunk 1 of 3", sent: 1},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
l := &lineMem{chunks: map[string][]byte{}, ackOf: tc.ackOf}
|
|
err := c.Send(l, body, time.Millisecond*50, func(string, ...any) {})
|
|
if tc.err == "" && err != nil || tc.err != "" && (err == nil || !strings.Contains(err.Error(), tc.err)) {
|
|
t.Fatalf("err %v, want %q", err, tc.err)
|
|
}
|
|
if len(l.order) != tc.sent {
|
|
t.Fatalf("%d chunks sent, want %d", len(l.order), tc.sent)
|
|
}
|
|
if l.subject != SeatAcks("mesh-catalog", "input") {
|
|
t.Fatalf("acknowledgements heard on %q", l.subject)
|
|
}
|
|
if tc.err != "" {
|
|
return
|
|
}
|
|
var got bytes.Buffer
|
|
i := 0
|
|
_, err = c.Receive(3, func() (string, []byte, error) {
|
|
s := l.order[i]
|
|
i++
|
|
return s, l.chunks[s], nil
|
|
}, func(string) error { return nil }, &got)
|
|
if err != nil || !bytes.Equal(got.Bytes(), body) {
|
|
t.Fatalf("received %d bytes, %v", got.Len(), err)
|
|
}
|
|
})
|
|
}
|
|
if err := c.Send(&lineMem{chunks: map[string][]byte{}}, nil, time.Second, nil); err != nil {
|
|
t.Errorf("no bytes: %v", err)
|
|
}
|
|
}
|