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) } }