Files
archie/internal/natsrpc/natsrpc_test.go
T
sam ba672965c6 test(coverage): add tests for workintake, secret, forge, natsrpc
Closes coverage gaps flagged in load-bearing packages:
- internal/domain/workintake: 14.3% -> 94.6%
- internal/secret/enginehost: 0% -> 100%
- internal/secret/secretextract: 10% -> 100%
- internal/forge: 36.1% -> 77.0%
- internal/natsrpc: 28.3% -> 91.3%
2026-08-31 21:24:25 +10:00

334 lines
9.0 KiB
Go

package natsrpc
import (
"context"
"encoding/json"
"log/slog"
"testing"
"time"
"github.com/nats-io/nats-server/v2/server"
natssrv "github.com/nats-io/nats-server/v2/test"
"github.com/nats-io/nats.go"
)
func startEmbedded(t *testing.T) *server.Server {
t.Helper()
srv := natssrv.RunRandClientPortServer()
t.Cleanup(srv.Shutdown)
return srv
}
func connect(t *testing.T, url string) *nats.Conn {
t.Helper()
nc, err := nats.Connect(url)
if err != nil {
t.Fatalf("nats connect: %v", err)
}
t.Cleanup(nc.Close)
return nc
}
func TestNewEnvelopeAndErr(t *testing.T) {
if e := NewEnvelope(nil); e.Error != "" {
t.Fatalf("NewEnvelope(nil).Error = %q, want empty", e.Error)
}
if err := (Envelope{}).Err(); err != nil {
t.Fatalf("Envelope{}.Err() = %v, want nil", err)
}
wantErr := "boom"
e := NewEnvelope(errString(wantErr))
if e.Error != wantErr {
t.Fatalf("NewEnvelope(err).Error = %q, want %q", e.Error, wantErr)
}
if got := e.Err(); got == nil || got.Error() != wantErr {
t.Fatalf("Err() = %v, want error %q", got, wantErr)
}
}
type errString string
func (e errString) Error() string { return string(e) }
func TestClientRequest(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("echo.subject", func(msg *nats.Msg) {
_ = msg.Respond(append([]byte("echo:"), msg.Data...))
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
c := &Client{Conn: nc, Timeout: 2 * time.Second}
reply, err := c.Request(context.Background(), "echo.subject", []byte("hi"))
if err != nil {
t.Fatal(err)
}
if string(reply) != "echo:hi" {
t.Fatalf("reply = %q, want %q", reply, "echo:hi")
}
}
func TestClientRequestNoResponders(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
c := &Client{Conn: nc, Timeout: 200 * time.Millisecond}
if _, err := c.Request(context.Background(), "nobody.listening", []byte("hi")); err == nil {
t.Fatal("Request() error = nil, want error when no responder is subscribed")
}
}
func TestClientRequestUsesContextDeadlineWhenSet(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
c := &Client{Conn: nc, Timeout: 10 * time.Second} // large default, ctx deadline should win
ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
defer cancel()
start := time.Now()
_, err := c.Request(ctx, "nobody.listening.either", []byte("hi"))
elapsed := time.Since(start)
if err == nil {
t.Fatal("Request() error = nil, want error (no responder)")
}
if elapsed > 2*time.Second {
t.Fatalf("Request() took %v, want it to respect the short context deadline rather than the 10s client timeout", elapsed)
}
}
type callReq struct {
Value string `json:"value"`
}
type callResp struct {
Envelope
Echo string `json:"echo"`
}
func TestCallMarshalsRequestAndUnmarshalsResponse(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("call.subject", func(msg *nats.Msg) {
var req callReq
if err := json.Unmarshal(msg.Data, &req); err != nil {
_ = msg.Respond([]byte(`{"error":"bad request"}`))
return
}
resp := callResp{Echo: req.Value}
data, _ := json.Marshal(resp)
_ = msg.Respond(data)
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
c := &Client{Conn: nc, Timeout: 2 * time.Second}
resp, err := Call[callResp](context.Background(), c, "call.subject", callReq{Value: "hello"})
if err != nil {
t.Fatal(err)
}
if resp.Echo != "hello" {
t.Fatalf("resp.Echo = %q, want %q", resp.Echo, "hello")
}
if err := resp.Err(); err != nil {
t.Fatalf("resp.Err() = %v, want nil", err)
}
}
func TestCallPropagatesEnvelopeError(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("call.error", func(msg *nats.Msg) {
_ = msg.Respond([]byte(`{"error":"handler failed"}`))
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
c := &Client{Conn: nc, Timeout: 2 * time.Second}
resp, err := Call[callResp](context.Background(), c, "call.error", callReq{Value: "x"})
if err != nil {
t.Fatalf("Call() transport error = %v, want nil (envelope errors are not transport errors)", err)
}
if envErr := resp.Err(); envErr == nil || envErr.Error() != "handler failed" {
t.Fatalf("resp.Err() = %v, want \"handler failed\"", envErr)
}
}
func TestCallUnmarshalError(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("call.badjson", func(msg *nats.Msg) {
_ = msg.Respond([]byte("not json"))
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
c := &Client{Conn: nc, Timeout: 2 * time.Second}
if _, err := Call[callResp](context.Background(), c, "call.badjson", callReq{Value: "x"}); err == nil {
t.Fatal("Call() error = nil, want decode error for invalid JSON reply")
}
}
func TestCallMarshalError(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
c := &Client{Conn: nc, Timeout: 2 * time.Second}
// A channel cannot be marshalled to JSON, so Call must fail before ever
// sending a request.
if _, err := Call[callResp](context.Background(), c, "call.never-reached", make(chan int)); err == nil {
t.Fatal("Call() error = nil, want encode error for unmarshalable request")
}
}
func TestRegisterAllSubscribesAndFlushes(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
var calledA, calledB bool
regs := []Registration{
{Subject: "reg.a", Handler: func(msg *nats.Msg) { calledA = true; _ = msg.Respond(nil) }},
{Subject: "reg.b", Handler: func(msg *nats.Msg) { calledB = true; _ = msg.Respond(nil) }},
}
unsubscribe, err := RegisterAll(nc, regs)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubscribe)
if _, err := nc.Request("reg.a", nil, time.Second); err != nil {
t.Fatal(err)
}
if _, err := nc.Request("reg.b", nil, time.Second); err != nil {
t.Fatal(err)
}
if !calledA || !calledB {
t.Fatalf("calledA=%t calledB=%t, want both true", calledA, calledB)
}
unsubscribe()
if _, err := nc.Request("reg.a", nil, 200*time.Millisecond); err == nil {
t.Fatal("Request() after unsubscribe error = nil, want no-responder error")
}
}
func TestRegisterAllRollsBackOnPartialFailure(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
regs := []Registration{
{Subject: "reg.ok", Handler: func(msg *nats.Msg) { _ = msg.Respond(nil) }},
// An empty subject is invalid and Subscribe rejects it, forcing the
// rollback path.
{Subject: "", Handler: func(msg *nats.Msg) {}},
}
if _, err := RegisterAll(nc, regs); err == nil {
t.Fatal("RegisterAll() error = nil, want error for invalid subject")
}
// The first, valid subscription must have been rolled back too.
if _, err := nc.Request("reg.ok", nil, 200*time.Millisecond); err == nil {
t.Fatal("Request(\"reg.ok\") after rollback error = nil, want no-responder error")
}
}
func TestRespondSuccess(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("respond.subject", func(msg *nats.Msg) {
Respond(msg, slog.New(slog.DiscardHandler), "test", callResp{Echo: "ok"})
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
reply, err := nc.Request("respond.subject", nil, time.Second)
if err != nil {
t.Fatal(err)
}
var resp callResp
if err := json.Unmarshal(reply.Data, &resp); err != nil {
t.Fatal(err)
}
if resp.Echo != "ok" {
t.Fatalf("resp.Echo = %q, want %q", resp.Echo, "ok")
}
}
func TestRespondEncodeFailureDoesNotPanic(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("respond.badvalue", func(msg *nats.Msg) {
// A channel cannot be marshalled to JSON; Respond must log and
// return rather than respond or panic.
Respond(msg, slog.New(slog.DiscardHandler), "test", make(chan int))
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
if _, err := nc.Request("respond.badvalue", nil, 200*time.Millisecond); err == nil {
t.Fatal("Request() error = nil, want timeout since Respond never replies on encode failure")
}
}
func TestRespondWithNilLoggerDoesNotPanic(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
sub, err := nc.Subscribe("respond.nillogger", func(msg *nats.Msg) {
Respond(msg, nil, "test", make(chan int))
})
if err != nil {
t.Fatal(err)
}
if err := nc.Flush(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
// Just confirm the subscriber survives a nil logger without panicking;
// no reply is expected on encode failure.
if _, err := nc.Request("respond.nillogger", nil, 200*time.Millisecond); err == nil {
t.Fatal("Request() error = nil, want timeout")
}
}