124 lines
3.4 KiB
Go
124 lines
3.4 KiB
Go
package messaging
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
|
|
"lijiaoqiao/supply-api/internal/repository"
|
|
)
|
|
|
|
type fakeStreamClient struct {
|
|
xaddArgs []*redis.XAddArgs
|
|
xaddErr error
|
|
xgroupErr error
|
|
streamName string
|
|
groupName string
|
|
startOffset string
|
|
}
|
|
|
|
func (c *fakeStreamClient) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd {
|
|
c.xaddArgs = append(c.xaddArgs, a)
|
|
return redis.NewStringResult("1-0", c.xaddErr)
|
|
}
|
|
|
|
func (c *fakeStreamClient) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd {
|
|
c.streamName = stream
|
|
c.groupName = group
|
|
c.startOffset = start
|
|
return redis.NewStatusResult("OK", c.xgroupErr)
|
|
}
|
|
|
|
func TestOutboxMessageBrokerPublishBuildsExpectedEnvelope(t *testing.T) {
|
|
client := &fakeStreamClient{}
|
|
broker := newOutboxMessageBrokerWithClient(client, "supply-outbox", "relay")
|
|
event := &repository.OutboxEvent{
|
|
EventID: "evt-1",
|
|
AggregateType: "account",
|
|
AggregateID: "acc-1",
|
|
EventType: "created",
|
|
Payload: json.RawMessage(`{"provider":"openai"}`),
|
|
}
|
|
|
|
if err := broker.Publish(context.Background(), event); err != nil {
|
|
t.Fatalf("Publish() error = %v", err)
|
|
}
|
|
if len(client.xaddArgs) != 1 {
|
|
t.Fatalf("XAdd call count = %d, want 1", len(client.xaddArgs))
|
|
}
|
|
|
|
call := client.xaddArgs[0]
|
|
if call.Stream != "supply-outbox" {
|
|
t.Fatalf("stream = %q, want %q", call.Stream, "supply-outbox")
|
|
}
|
|
if call.ID != "*" {
|
|
t.Fatalf("id = %q, want %q", call.ID, "*")
|
|
}
|
|
|
|
values, ok := call.Values.(map[string]interface{})
|
|
if !ok {
|
|
t.Fatalf("values type = %T, want map[string]interface{}", call.Values)
|
|
}
|
|
|
|
rawData, ok := values["data"].(string)
|
|
if !ok {
|
|
t.Fatalf("data field type = %T, want string", values["data"])
|
|
}
|
|
|
|
var payload map[string]any
|
|
if err := json.Unmarshal([]byte(rawData), &payload); err != nil {
|
|
t.Fatalf("Unmarshal() error = %v", err)
|
|
}
|
|
|
|
if payload["event_id"] != event.EventID || payload["aggregate_type"] != event.AggregateType || payload["aggregate_id"] != event.AggregateID {
|
|
t.Fatalf("unexpected envelope: %#v", payload)
|
|
}
|
|
if payload["payload"] != string(event.Payload) {
|
|
t.Fatalf("payload = %#v, want %q", payload["payload"], string(event.Payload))
|
|
}
|
|
if _, err := time.Parse(time.RFC3339, payload["published_at"].(string)); err != nil {
|
|
t.Fatalf("published_at parse error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEnsureConsumerGroupHandlesBusyGroupAndOtherErrors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
err error
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "busy group is treated as success",
|
|
err: errors.New("BUSYGROUP Consumer Group name already exists"),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "other errors are wrapped",
|
|
err: errors.New("redis unavailable"),
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
client := &fakeStreamClient{xgroupErr: tt.err}
|
|
broker := newOutboxMessageBrokerWithClient(client, "supply-outbox", "relay")
|
|
|
|
err := broker.EnsureConsumerGroup(context.Background())
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("EnsureConsumerGroup() expected error, got nil")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("EnsureConsumerGroup() error = %v, want nil", err)
|
|
}
|
|
if client.streamName != "supply-outbox" || client.groupName != "relay" || client.startOffset != "0" {
|
|
t.Fatalf("unexpected group args: stream=%q group=%q start=%q", client.streamName, client.groupName, client.startOffset)
|
|
}
|
|
})
|
|
}
|
|
}
|