237 lines
7.6 KiB
Go
237 lines
7.6 KiB
Go
package sqs
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"testing"
|
|
"time"
|
|
|
|
awsv2 "github.com/aws/aws-sdk-go-v2/aws"
|
|
"github.com/aws/aws-sdk-go-v2/service/sqs"
|
|
sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
|
|
"github.com/aws/smithy-go"
|
|
|
|
"wucher/internal/config"
|
|
"wucher/internal/queue"
|
|
"wucher/internal/resilience"
|
|
)
|
|
|
|
type mockAPI struct {
|
|
sendInput *sqs.SendMessageInput
|
|
receiveInput *sqs.ReceiveMessageInput
|
|
deleteBatchInput *sqs.DeleteMessageBatchInput
|
|
changeVisibilityInput *sqs.ChangeMessageVisibilityInput
|
|
getAttributesInput *sqs.GetQueueAttributesInput
|
|
sendErr error
|
|
receiveErr error
|
|
deleteBatchErr error
|
|
changeVisibilityErr error
|
|
getAttributesErr error
|
|
sendCalls int
|
|
receiveCalls int
|
|
}
|
|
|
|
func (m *mockAPI) SendMessage(_ context.Context, params *sqs.SendMessageInput, _ ...func(*sqs.Options)) (*sqs.SendMessageOutput, error) {
|
|
m.sendCalls++
|
|
m.sendInput = params
|
|
if m.sendErr != nil {
|
|
return nil, m.sendErr
|
|
}
|
|
return &sqs.SendMessageOutput{}, nil
|
|
}
|
|
|
|
func (m *mockAPI) ReceiveMessage(_ context.Context, params *sqs.ReceiveMessageInput, _ ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) {
|
|
m.receiveCalls++
|
|
m.receiveInput = params
|
|
if m.receiveErr != nil {
|
|
return nil, m.receiveErr
|
|
}
|
|
return &sqs.ReceiveMessageOutput{
|
|
Messages: []sqstypes.Message{{
|
|
MessageId: awsv2.String("msg-1"),
|
|
ReceiptHandle: awsv2.String("receipt-1"),
|
|
Body: awsv2.String(`{"version":"v1","message_id":"msg-1","kind":"email.dispatch","occurred_at":"2026-03-19T00:00:00Z","payload":{"to":"user@example.com","subject":"Hello","body":"World"}}`),
|
|
MessageAttributes: map[string]sqstypes.MessageAttributeValue{
|
|
"correlation_id": {DataType: awsv2.String("String"), StringValue: awsv2.String("req-1")},
|
|
},
|
|
Attributes: map[string]string{
|
|
string(sqstypes.MessageSystemAttributeNameApproximateReceiveCount): "3",
|
|
string(sqstypes.MessageSystemAttributeNameSentTimestamp): "1710806400000",
|
|
},
|
|
}},
|
|
}, nil
|
|
}
|
|
|
|
func (m *mockAPI) DeleteMessageBatch(_ context.Context, params *sqs.DeleteMessageBatchInput, _ ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error) {
|
|
m.deleteBatchInput = params
|
|
if m.deleteBatchErr != nil {
|
|
return nil, m.deleteBatchErr
|
|
}
|
|
return &sqs.DeleteMessageBatchOutput{}, nil
|
|
}
|
|
|
|
func (m *mockAPI) ChangeMessageVisibility(_ context.Context, params *sqs.ChangeMessageVisibilityInput, _ ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error) {
|
|
m.changeVisibilityInput = params
|
|
if m.changeVisibilityErr != nil {
|
|
return nil, m.changeVisibilityErr
|
|
}
|
|
return &sqs.ChangeMessageVisibilityOutput{}, nil
|
|
}
|
|
|
|
func (m *mockAPI) GetQueueAttributes(_ context.Context, params *sqs.GetQueueAttributesInput, _ ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) {
|
|
m.getAttributesInput = params
|
|
if m.getAttributesErr != nil {
|
|
return nil, m.getAttributesErr
|
|
}
|
|
return &sqs.GetQueueAttributesOutput{
|
|
Attributes: map[string]string{
|
|
string(sqstypes.QueueAttributeNameApproximateNumberOfMessages): "5",
|
|
string(sqstypes.QueueAttributeNameApproximateNumberOfMessagesNotVisible): "2",
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func TestEmailQueuePublishReceiveAckRetryDeadLetter(t *testing.T) {
|
|
api := &mockAPI{}
|
|
cfg := config.SQSConfig{
|
|
Region: "ap-southeast-1",
|
|
QueueURL: "https://sqs.ap-southeast-1.amazonaws.com/123/test",
|
|
QueueType: queue.QueueTypeFIFO,
|
|
MessageGroupID: "email",
|
|
VisibilityTimeout: 30 * time.Second,
|
|
WaitTimeSeconds: 20,
|
|
}
|
|
q, err := NewEmailQueue(api, cfg)
|
|
if err != nil {
|
|
t.Fatalf("new queue: %v", err)
|
|
}
|
|
|
|
err = q.Publish(context.Background(), queue.OutboundMessage{
|
|
ID: "msg-1",
|
|
Body: []byte(`{"hello":"world"}`),
|
|
Attributes: map[string]string{"correlation_id": "req-1"},
|
|
MessageGroupID: "email",
|
|
DeduplicationID: "dedup-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("publish: %v", err)
|
|
}
|
|
if api.sendInput == nil || awsv2.ToString(api.sendInput.MessageGroupId) != "email" {
|
|
t.Fatalf("expected fifo publish settings")
|
|
}
|
|
|
|
deliveries, err := q.Receive(context.Background(), 5)
|
|
if err != nil {
|
|
t.Fatalf("receive: %v", err)
|
|
}
|
|
if len(deliveries) != 1 || deliveries[0].ReceiveCount != 3 {
|
|
t.Fatalf("unexpected deliveries: %+v", deliveries)
|
|
}
|
|
|
|
if err := q.Ack(context.Background(), deliveries); err != nil {
|
|
t.Fatalf("ack: %v", err)
|
|
}
|
|
if api.deleteBatchInput == nil || len(api.deleteBatchInput.Entries) != 1 {
|
|
t.Fatalf("expected batch delete")
|
|
}
|
|
|
|
if err := q.Retry(context.Background(), deliveries[0], 45*time.Second); err != nil {
|
|
t.Fatalf("retry: %v", err)
|
|
}
|
|
if api.changeVisibilityInput == nil || api.changeVisibilityInput.VisibilityTimeout != 45 {
|
|
t.Fatalf("expected retry visibility timeout 45")
|
|
}
|
|
|
|
if err := q.DeadLetter(context.Background(), deliveries[0], "permanent failure", nil); err != nil {
|
|
t.Fatalf("dead-letter: %v", err)
|
|
}
|
|
if got := awsv2.ToString(api.sendInput.MessageBody); got != `{"hello":"world"}` {
|
|
t.Fatalf("expected dead-letter path to leave message managed by SQS redrive, got send body %q", got)
|
|
}
|
|
|
|
depth, err := q.ApproximateDepth(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("depth: %v", err)
|
|
}
|
|
if depth != 7 {
|
|
t.Fatalf("expected depth 7, got %d", depth)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfigRejectsInsecureEndpoint(t *testing.T) {
|
|
err := validateConfig(config.SQSConfig{
|
|
Region: "ap-southeast-1",
|
|
QueueURL: "https://sqs.ap-southeast-1.amazonaws.com/123/test",
|
|
Endpoint: "http://localhost:4566",
|
|
})
|
|
if err == nil {
|
|
t.Fatalf("expected insecure endpoint validation error")
|
|
}
|
|
}
|
|
|
|
func TestResilientAPI_CircuitBreaker(t *testing.T) {
|
|
newExecutor := func() *resilience.Executor {
|
|
return resilience.NewExecutor("sqs", config.CircuitBreakerPolicy{
|
|
Enabled: true,
|
|
Timeout: time.Second,
|
|
MinRequests: 2,
|
|
FailureRatio: 0.5,
|
|
ConsecutiveFailures: 2,
|
|
}, slog.New(slog.NewJSONHandler(io.Discard, nil)), resilience.ClassifySQSError)
|
|
}
|
|
|
|
t.Run("client faults are excluded", func(t *testing.T) {
|
|
api := &mockAPI{
|
|
sendErr: sqsAPIError{code: "AccessDenied", fault: smithy.FaultClient},
|
|
}
|
|
wrapped := NewResilientAPI(api, newExecutor())
|
|
|
|
for range 3 {
|
|
_, err := wrapped.SendMessage(context.Background(), &sqs.SendMessageInput{})
|
|
if err == nil {
|
|
t.Fatalf("expected access denied error")
|
|
}
|
|
var openErr *resilience.OpenError
|
|
if errors.As(err, &openErr) {
|
|
t.Fatalf("expected excluded error to keep breaker closed, got %v", err)
|
|
}
|
|
}
|
|
if api.sendCalls != 3 {
|
|
t.Fatalf("expected all excluded calls to reach API, got %d", api.sendCalls)
|
|
}
|
|
})
|
|
|
|
t.Run("server faults open the breaker", func(t *testing.T) {
|
|
api := &mockAPI{
|
|
receiveErr: sqsAPIError{code: "InternalError", fault: smithy.FaultServer},
|
|
}
|
|
wrapped := NewResilientAPI(api, newExecutor())
|
|
|
|
for range 2 {
|
|
if _, err := wrapped.ReceiveMessage(context.Background(), &sqs.ReceiveMessageInput{}); err == nil {
|
|
t.Fatalf("expected receive error")
|
|
}
|
|
}
|
|
_, err := wrapped.ReceiveMessage(context.Background(), &sqs.ReceiveMessageInput{})
|
|
var openErr *resilience.OpenError
|
|
if !errors.As(err, &openErr) {
|
|
t.Fatalf("expected circuit open error, got %v", err)
|
|
}
|
|
if api.receiveCalls != 2 {
|
|
t.Fatalf("expected breaker to fail fast after opening, got %d receive calls", api.receiveCalls)
|
|
}
|
|
})
|
|
}
|
|
|
|
type sqsAPIError struct {
|
|
code string
|
|
fault smithy.ErrorFault
|
|
}
|
|
|
|
func (e sqsAPIError) Error() string { return e.code }
|
|
func (e sqsAPIError) ErrorCode() string { return e.code }
|
|
func (e sqsAPIError) ErrorMessage() string { return e.code }
|
|
func (e sqsAPIError) ErrorFault() smithy.ErrorFault { return e.fault }
|