backup: preserve HT-FIFO queue attributes (PR #714, round 6)

Codex P1 round 12 (commit 5c6a68b):

`decodeSQSQueueMetaValue` only projected legacy SQS fields into
_queue.json. The HT-FIFO immutable attributes (PartitionCount,
FifoThroughputLimit, DeduplicationScope) were captured by the live
catalog at CreateQueue but silently dropped by the backup decoder.
The adapter rejects mutating these via SetQueueAttributes (they
are immutable per AWS contract), so a backup→restore roundtrip
would silently recreate single-partition / default-routing /
queue-scoped-dedup queues — non-fidelity preserving for any
partitioned FIFO workload.

Add the three fields to sqsQueueMetaPublic and the live decode
struct so they round-trip through the dump.

Test: TestSQS_QueueMetaPreservesHTFIFOAttributes drives a
4-partition perMessageGroupId / messageGroup-dedup queue and
asserts each field is read back from _queue.json.

Author: bootjp

internal/backup/sqs.go

@@ -137,6 +137,14 @@ type sqsInternalRecord struct {
 // sqsQueueMetaPublic is the dump-format projection of the live
 // adapter/sqs_catalog.go sqsQueueMeta. Field names match the AWS-style
 // vocabulary an external restore tool would use.
+//
+// PartitionCount, FifoThroughputLimit, and DeduplicationScope mirror
+// the HT-FIFO attributes captured at CreateQueue time. The adapter
+// rejects mutating these via SetQueueAttributes (they are immutable
+// per AWS contract), so dropping them at backup would silently
+// recreate single-partition / default-routing / queue-scoped-dedup
+// queues on restore — non-fidelity-preserving for any partitioned
+// FIFO workload. Codex P1 round 12.
 type sqsQueueMetaPublic struct {
 	FormatVersion             uint32 `json:"format_version"`
 	Name                      string `json:"name"`
@@ -148,6 +156,9 @@ type sqsQueueMetaPublic struct {
 	ReceiveMessageWaitSeconds int64  `json:"receive_message_wait_seconds,omitempty"`
 	MaximumMessageSize        int64  `json:"maximum_message_size,omitempty"`
 	RedrivePolicy             string `json:"redrive_policy,omitempty"`
+	PartitionCount            uint32 `json:"partition_count,omitempty"`
+	FifoThroughputLimit       string `json:"fifo_throughput_limit,omitempty"`
+	DeduplicationScope        string `json:"deduplication_scope,omitempty"`
 }
 
 // sqsMessageBody is the dump-format projection's body field. It marshals
@@ -643,6 +654,10 @@ func decodeSQSQueueMetaValue(value []byte) (*sqsQueueMetaPublic, error) {
 		ReceiveMessageWaitSeconds int64  `json:"receive_message_wait_seconds"`
 		MaximumMessageSize        int64  `json:"maximum_message_size"`
 		RedrivePolicy             string `json:"redrive_policy"`
+		// HT-FIFO immutable attributes — see adapter/sqs_catalog.go.
+		PartitionCount      uint32 `json:"partition_count"`
+		FifoThroughputLimit string `json:"fifo_throughput_limit"`
+		DeduplicationScope  string `json:"deduplication_scope"`
 	}
 	if err := json.Unmarshal(body, &live); err != nil {
 		return nil, errors.Wrap(ErrSQSInvalidQueueMeta, err.Error())
@@ -658,6 +673,9 @@ func decodeSQSQueueMetaValue(value []byte) (*sqsQueueMetaPublic, error) {
 		ReceiveMessageWaitSeconds: live.ReceiveMessageWaitSeconds,
 		MaximumMessageSize:        live.MaximumMessageSize,
 		RedrivePolicy:             live.RedrivePolicy,
+		PartitionCount:            live.PartitionCount,
+		FifoThroughputLimit:       live.FifoThroughputLimit,
+		DeduplicationScope:        live.DeduplicationScope,
 	}, nil
 }
 

internal/backup/sqs_test.go

@@ -377,6 +377,45 @@ func TestSQS_ParseMessageDataKey_RejectsEmptyMsgIDSegment(t *testing.T) {
 	}
 }
 
+// TestSQS_QueueMetaPreservesHTFIFOAttributes is the regression for
+// Codex P1 round 12: PartitionCount, FifoThroughputLimit, and
+// DeduplicationScope are immutable HT-FIFO attributes captured at
+// CreateQueue and rejected by SetQueueAttributes. Dropping them at
+// backup time would silently recreate single-partition / default-
+// routing / queue-scoped-dedup queues on restore — non-fidelity
+// preserving for any partitioned FIFO workload.
+func TestSQS_QueueMetaPreservesHTFIFOAttributes(t *testing.T) {
+	t.Parallel()
+	enc, root := newSQSEncoder(t)
+	queue := "ht-fifo.fifo"
+	val := encodeQueueMetaValue(t, map[string]any{
+		"name":                       queue,
+		"is_fifo":                    true,
+		"content_based_dedup":        true,
+		"visibility_timeout_seconds": 30,
+		"message_retention_seconds":  345600,
+		"partition_count":            4,
+		"fifo_throughput_limit":      "perMessageGroupId",
+		"deduplication_scope":        "messageGroup",
+	})
+	if err := enc.HandleQueueMeta(EncodeQueueMetaKey(queue), val); err != nil {
+		t.Fatal(err)
+	}
+	if err := enc.Finalize(); err != nil {
+		t.Fatal(err)
+	}
+	got := readQueueJSON(t, filepath.Join(root, "sqs", queue, "_queue.json"))
+	if floatField(t, got, "partition_count") != 4 {
+		t.Fatalf("partition_count = %v want 4", got["partition_count"])
+	}
+	if got["fifo_throughput_limit"] != "perMessageGroupId" {
+		t.Fatalf("fifo_throughput_limit = %v want perMessageGroupId", got["fifo_throughput_limit"])
+	}
+	if got["deduplication_scope"] != "messageGroup" {
+		t.Fatalf("deduplication_scope = %v want messageGroup", got["deduplication_scope"])
+	}
+}
+
 // TestSQS_StaleGenerationMessagesDropped is the regression for Codex
 // P1 round 10: PurgeQueue and DeleteQueue bump the queue's generation
 // but the affected !sqs|msg|data|<oldGen>|... rows are removed