@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/core/outbox/relay_test.go

@@ -0,0 +1,690 @@
+package outbox
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+
+	"{{module}}/internal/core/eventbus"
+	"{{module}}/internal/core/eventstream"
+	"{{module}}/internal/core/queue"
+)
+
+// ═══════════════════════════════════════════════════════════════
+// 1. matchEventPattern — 事件类型通配符匹配（纯函数）
+// ═══════════════════════════════════════════════════════════════
+
+func TestMatchEventPattern(t *testing.T) {
+	cases := []struct {
+		pattern   string
+		eventType string
+		expect    bool
+		desc      string
+	}{
+		// 精确匹配
+		{"identity.created", "identity.created", true, "精确匹配"},
+		{"identity.created", "identity.deleted", false, "精确匹配不同事件"},
+		{"identity.created", "user.created", false, "精确匹配不同域"},
+
+		// 全局通配符
+		{"*", "identity.created", true, "单独 * 匹配所有"},
+		{"**", "identity.created", true, "** 匹配单段事件"},
+		{"**", "user.profile.updated", true, "** 匹配多段事件"},
+
+		// 单段通配符 *
+		{"identity.*", "identity.created", true, "identity.* 匹配 identity.created"},
+		{"identity.*", "identity.deleted", true, "identity.* 匹配 identity.deleted"},
+		{"identity.*", "identity.profile.updated", false, "identity.* 不匹配多段"},
+		{"identity.*", "user.created", false, "identity.* 不匹配其他域"},
+
+		// 双星通配符 **
+		{"identity.**", "identity.created.extra", true, "identity.** 匹配三段"},
+		{"identity.**", "identity.a.b.c", true, "identity.** 匹配任意深度"},
+		{"identity.**", "user.created", false, "identity.** 不匹配其他域"},
+
+		// 中间通配符
+		{"order.*.completed", "order.payment.completed", true, "中间 * 匹配单段"},
+		{"order.*.completed", "order.completed", false, "中间 * 段数不足"},
+		{"order.*.completed", "order.a.b.completed", false, "中间 * 不匹配多段"},
+
+		// 空和边界
+		{"", "", true, "空模式匹配空事件"},
+		{"a", "b", false, "不同单段"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.desc, func(t *testing.T) {
+			got := matchEventPattern(tc.pattern, tc.eventType)
+			assert.Equal(t, tc.expect, got, "pattern=%q, eventType=%q", tc.pattern, tc.eventType)
+		})
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. DefaultRelayConfig — 默认配置验证
+// ═══════════════════════════════════════════════════════════════
+
+func TestDefaultRelayConfig(t *testing.T) {
+	cfg := DefaultRelayConfig()
+
+	assert.Equal(t, 2*time.Second, cfg.PollInterval, "默认轮询间隔 2s")
+	assert.Equal(t, 100, cfg.BatchSize, "默认批量大小 100")
+	assert.Equal(t, 5*time.Minute, cfg.LockTimeout, "默认锁超时 5m")
+	assert.Equal(t, 10, cfg.MaxRetries, "默认最大重试 10")
+	assert.Equal(t, time.Hour, cfg.CleanupInterval, "默认清理间隔 1h")
+	assert.Equal(t, 72*time.Hour, cfg.RetentionDuration, "默认保留时长 72h")
+	assert.NotEmpty(t, cfg.RelayID, "RelayID 应自动生成")
+	assert.Nil(t, cfg.AsynqEventPatterns, "默认无 Asynq 目标事件模式")
+	assert.Nil(t, cfg.RedisStreamEventPatterns, "默认无 Redis Stream 目标事件模式")
+	assert.Nil(t, cfg.PersistentRetryEvents, "默认无持续重试事件模式")
+	assert.Nil(t, cfg.PayloadDeserializer, "默认无反序列化函数")
+}
+
+func TestDefaultRelayConfig_RelayIDUnique(t *testing.T) {
+	ids := make(map[string]struct{}, 10)
+	for i := 0; i < 10; i++ {
+		cfg := DefaultRelayConfig()
+		_, duplicate := ids[cfg.RelayID]
+		assert.False(t, duplicate, "RelayID 应唯一，发现重复: %s", cfg.RelayID)
+		ids[cfg.RelayID] = struct{}{}
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. requiredDeliveryTargets — 按目标独立路由
+// ═══════════════════════════════════════════════════════════════
+
+func TestRequiredDeliveryTargetsUsesExplicitTargetPatterns(t *testing.T) {
+	cases := []struct {
+		name            string
+		asynqPatterns   []string
+		streamPatterns  []string
+		queueClient     *queue.Client
+		streamPublisher eventstream.EventStreamPublisher
+		eventType       string
+		expectedTargets []string
+	}{
+		{
+			name:            "no target patterns",
+			eventType:       "identity.created",
+			expectedTargets: []string{TargetLocalEventBus},
+		},
+		{
+			name:            "asynq target only",
+			asynqPatterns:   []string{"identity.*"},
+			queueClient:     &queue.Client{},
+			eventType:       "identity.created",
+			expectedTargets: []string{TargetLocalEventBus, TargetAsynq},
+		},
+		{
+			name:            "redis stream target only",
+			streamPatterns:  []string{"identity.*"},
+			streamPublisher: &failOnceStreamPublisher{},
+			queueClient:     &queue.Client{},
+			eventType:       "identity.created",
+			expectedTargets: []string{TargetLocalEventBus, TargetRedisStream},
+		},
+		{
+			name:            "both explicit targets",
+			asynqPatterns:   []string{"identity.*"},
+			streamPatterns:  []string{"identity.*"},
+			queueClient:     &queue.Client{},
+			streamPublisher: &failOnceStreamPublisher{},
+			eventType:       "identity.created",
+			expectedTargets: []string{TargetLocalEventBus, TargetAsynq, TargetRedisStream},
+		},
+		{
+			name:            "non matching target patterns",
+			asynqPatterns:   []string{"identity.*"},
+			streamPatterns:  []string{"identity.*"},
+			queueClient:     &queue.Client{},
+			streamPublisher: &failOnceStreamPublisher{},
+			eventType:       "user.created",
+			expectedTargets: []string{TargetLocalEventBus},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			relay := &Relay{
+				queueClient:     tc.queueClient,
+				streamPublisher: tc.streamPublisher,
+				config: RelayConfig{
+					AsynqEventPatterns:       tc.asynqPatterns,
+					RedisStreamEventPatterns: tc.streamPatterns,
+				},
+			}
+			got := relay.requiredDeliveryTargets(tc.eventType)
+			assert.Equal(t, tc.expectedTargets, got)
+		})
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. toDomainEvent — 有 PayloadDeserializer 时还原具体类型
+// ═══════════════════════════════════════════════════════════════
+
+// testPayload 测试用事件载荷
+type testPayload struct {
+	UserID int64  `json:"user_id"`
+	Email  string `json:"email"`
+}
+
+func TestToDomainEvent_WithPayloadDeserializer(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{
+			PayloadDeserializer: func(eventType string, data []byte) (any, error) {
+				if eventType == "identity.created" {
+					var p testPayload
+					if err := json.Unmarshal(data, &p); err != nil {
+						return nil, err
+					}
+					return &p, nil
+				}
+				return nil, fmt.Errorf("no factory for %q", eventType)
+			},
+		},
+		logger: zap.NewNop(),
+	}
+
+	payloadJSON, _ := json.Marshal(testPayload{UserID: 42, Email: "test@example.com"})
+	now := time.Now()
+
+	event := &OutboxEvent{
+		ID:            "evt-001",
+		AggregateType: "identity",
+		AggregateID:   "42",
+		EventType:     "identity.created",
+		Payload:       payloadJSON,
+		OccurredAt:    now,
+	}
+
+	domainEvent, err := relay.toDomainEvent(event)
+	require.NoError(t, err)
+
+	assert.Equal(t, "identity.created", domainEvent.EventName)
+	assert.Equal(t, "evt-001", domainEvent.EventID)
+	assert.Equal(t, "42", domainEvent.AggregateID)
+	assert.Equal(t, now, domainEvent.OccurredAt)
+	assert.Equal(t, 0, domainEvent.Version)
+
+	// 载荷应为具体 struct，不是 json.RawMessage
+	payload, ok := domainEvent.Payload.(*testPayload)
+	require.True(t, ok, "Payload 应为 *testPayload，实际为 %T", domainEvent.Payload)
+	assert.Equal(t, int64(42), payload.UserID)
+	assert.Equal(t, "test@example.com", payload.Email)
+}
+
+func TestToDomainEvent_WithoutPayloadDeserializer(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{},
+		logger: zap.NewNop(),
+	}
+
+	payloadJSON := []byte(`{"user_id":42}`)
+	event := &OutboxEvent{
+		ID:            "evt-002",
+		AggregateType: "identity",
+		AggregateID:   "42",
+		EventType:     "identity.created",
+		Payload:       payloadJSON,
+		OccurredAt:    time.Now(),
+	}
+
+	domainEvent, err := relay.toDomainEvent(event)
+	require.NoError(t, err)
+
+	// 无 PayloadDeserializer 时应为 json.RawMessage
+	raw, ok := domainEvent.Payload.(json.RawMessage)
+	require.True(t, ok, "Payload 应为 json.RawMessage，实际为 %T", domainEvent.Payload)
+	assert.JSONEq(t, `{"user_id":42}`, string(raw))
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 5. toDomainEvent — 元数据还原
+// ═══════════════════════════════════════════════════════════════
+
+func TestToDomainEvent_RestoresMetadata(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{},
+		logger: zap.NewNop(),
+	}
+
+	meta := eventbus.EventMetadata{
+		UserID:  100,
+		TraceID: "trace-abc",
+	}
+	metaJSON, _ := json.Marshal(meta)
+
+	event := &OutboxEvent{
+		ID:            "evt-003",
+		AggregateType: "identity",
+		AggregateID:   "100",
+		EventType:     "identity.created",
+		Payload:       []byte(`{}`),
+		Metadata:      metaJSON,
+		OccurredAt:    time.Now(),
+	}
+
+	domainEvent, err := relay.toDomainEvent(event)
+	require.NoError(t, err)
+
+	require.NotNil(t, domainEvent.Metadata, "Metadata 应被还原")
+	assert.Equal(t, int64(100), domainEvent.Metadata.UserID)
+	assert.Equal(t, "trace-abc", domainEvent.Metadata.TraceID)
+}
+
+func TestToDomainEvent_RestoresEnvelopeProductCode(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{},
+		logger: zap.NewNop(),
+	}
+	productCode := "product_alpha"
+	event := &OutboxEvent{
+		ID:                "evt-product-context",
+		AggregateType:     "identity",
+		AggregateID:       "100",
+		SourceProductCode: &productCode,
+		EventType:         "auth.password.changed",
+		Payload:           []byte(`{}`),
+		OccurredAt:        time.Now(),
+	}
+
+	domainEvent, err := relay.toDomainEvent(event)
+	require.NoError(t, err)
+	require.NotNil(t, domainEvent.Metadata)
+	require.NotNil(t, domainEvent.Metadata.Extra)
+	assert.Equal(t, productCode, domainEvent.Metadata.Extra[eventbus.ExtraKeyProductCode])
+}
+
+func TestToDomainEvent_NilMetadata(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{},
+		logger: zap.NewNop(),
+	}
+
+	event := &OutboxEvent{
+		ID:            "evt-004",
+		AggregateType: "identity",
+		AggregateID:   "1",
+		EventType:     "identity.created",
+		Payload:       []byte(`{}`),
+		Metadata:      nil,
+		OccurredAt:    time.Now(),
+	}
+
+	domainEvent, err := relay.toDomainEvent(event)
+	require.NoError(t, err)
+	assert.Nil(t, domainEvent.Metadata, "空 Metadata 不应被设置")
+}
+
+func TestToDomainEvent_InvalidMetadata(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{},
+		logger: zap.NewNop(),
+	}
+
+	event := &OutboxEvent{
+		ID:            "evt-005",
+		AggregateType: "identity",
+		AggregateID:   "1",
+		EventType:     "identity.created",
+		Payload:       []byte(`{}`),
+		Metadata:      []byte(`{invalid json`),
+		OccurredAt:    time.Now(),
+	}
+
+	// 不应 panic，无效 metadata 被安全忽略
+	domainEvent, err := relay.toDomainEvent(event)
+	require.NoError(t, err)
+	assert.Nil(t, domainEvent.Metadata, "无效 Metadata 应被忽略")
+}
+
+func TestToDomainEvent_DeserializerErrorFailsRelay(t *testing.T) {
+	relay := &Relay{
+		config: RelayConfig{
+			PayloadDeserializer: func(eventType string, data []byte) (any, error) {
+				return nil, fmt.Errorf("no factory for %q", eventType)
+			},
+		},
+		logger: zap.NewNop(),
+	}
+
+	event := &OutboxEvent{
+		ID:            "evt-006",
+		AggregateType: "identity",
+		AggregateID:   "1",
+		EventType:     "identity.unknown",
+		Payload:       []byte(`{"user_id":42}`),
+		OccurredAt:    time.Now(),
+	}
+
+	_, err := relay.toDomainEvent(event)
+	require.Error(t, err)
+	assert.ErrorContains(t, err, "deserialize outbox event payload evt-006 (identity.unknown)")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 6. CrossProcessEventPayload — JSON 序列化往返
+// ═══════════════════════════════════════════════════════════════
+
+func TestCrossProcessEventPayload_JSONRoundTrip(t *testing.T) {
+	now := time.Now().Truncate(time.Millisecond)
+	aggregateVersion := int64(7)
+	original := CrossProcessEventPayload{
+		EventType:        "identity.created",
+		AggregateType:    "identity",
+		AggregateID:      "42",
+		AggregateVersion: &aggregateVersion,
+		Payload:          json.RawMessage(`{"user_id":42,"email":"a@b.com"}`),
+		Metadata:         json.RawMessage(`{"user_id":100}`),
+		AuditChanges:     json.RawMessage(`{"before":{"status":"old"},"after":{"status":"new"}}`),
+		AuditMeta:        json.RawMessage(`{"reason":"operator update"}`),
+		OccurredAt:       now,
+		EventID:          "evt-round-trip",
+	}
+
+	data, err := json.Marshal(original)
+	require.NoError(t, err)
+
+	var restored CrossProcessEventPayload
+	err = json.Unmarshal(data, &restored)
+	require.NoError(t, err)
+
+	assert.Equal(t, original.EventType, restored.EventType)
+	assert.Equal(t, original.AggregateType, restored.AggregateType)
+	assert.Equal(t, original.AggregateID, restored.AggregateID)
+	assert.Equal(t, original.AggregateVersion, restored.AggregateVersion)
+	assert.Equal(t, original.EventID, restored.EventID)
+	assert.JSONEq(t, string(original.Payload), string(restored.Payload))
+	assert.JSONEq(t, string(original.Metadata), string(restored.Metadata))
+	assert.JSONEq(t, string(original.AuditChanges), string(restored.AuditChanges))
+	assert.JSONEq(t, string(original.AuditMeta), string(restored.AuditMeta))
+	assert.True(t, original.OccurredAt.Equal(restored.OccurredAt),
+		"OccurredAt 序列化往返应一致: want %v, got %v", original.OccurredAt, restored.OccurredAt)
+}
+
+func TestAggregateVersionValue(t *testing.T) {
+	versionOne := int64(1)
+	versionSeven := int64(7)
+
+	assert.Equal(t, 0, AggregateVersionValue(nil))
+	assert.Equal(t, 1, AggregateVersionValue(&versionOne))
+	assert.Equal(t, 7, AggregateVersionValue(&versionSeven))
+}
+
+func TestDispatchEvent_DoesNotRepublishLocalEventBusWhenStreamRetrySucceeds(t *testing.T) {
+	db := openOutboxReschedulerTestDB(t)
+	bus := eventbus.New(zap.NewNop())
+	streamPublisher := &failOnceStreamPublisher{}
+	relay := NewRelay(db, zap.NewNop(), bus, nil, streamPublisher, RelayConfig{
+		RedisStreamEventPatterns: []string{"identity.*"},
+		RelayID:                  "relay-test",
+	})
+
+	localPublishCount := 0
+	bus.Subscribe("identity.created", func(_ context.Context, _ eventbus.DomainEvent) error {
+		localPublishCount++
+		return nil
+	})
+
+	now := time.Now()
+	lockedBy := relay.config.RelayID
+	event := OutboxEvent{
+		ID:            "00000000-0000-0000-0000-000000000111",
+		AggregateType: "identity",
+		AggregateID:   "identity_111",
+		EventType:     "identity.created",
+		Payload:       []byte(`{"identity_id":111}`),
+		OccurredAt:    now,
+		CreatedAt:     now,
+		Status:        StatusLocked,
+		MaxRetries:    10,
+		LockedAt:      &now,
+		LockedBy:      &lockedBy,
+	}
+	require.NoError(t, db.Create(&event).Error)
+
+	err := relay.dispatchEvent(context.Background(), &event)
+	require.Error(t, err)
+	require.ErrorContains(t, err, "redis_stream delivery failed")
+	require.Equal(t, 1, localPublishCount)
+	require.Equal(t, 1, streamPublisher.publishCount)
+
+	var localDelivery OutboxEventDelivery
+	require.NoError(t, db.First(&localDelivery, "event_id = ? AND target = ?", event.ID, TargetLocalEventBus).Error)
+	require.Equal(t, StatusDispatched, localDelivery.Status)
+
+	var streamDelivery OutboxEventDelivery
+	require.NoError(t, db.First(&streamDelivery, "event_id = ? AND target = ?", event.ID, TargetRedisStream).Error)
+	require.Equal(t, StatusRetryPending, streamDelivery.Status)
+	require.Equal(t, 1, streamDelivery.RetryCount)
+
+	var parentAfterFailure OutboxEvent
+	require.NoError(t, db.First(&parentAfterFailure, "id = ?", event.ID).Error)
+	require.Equal(t, StatusRetryPending, parentAfterFailure.Status)
+
+	dueAt := time.Now().Add(-time.Second)
+	require.NoError(t, db.Model(&OutboxEventDelivery{}).
+		Where("event_id = ? AND target = ?", event.ID, TargetRedisStream).
+		Update("next_retry_at", dueAt).Error)
+	retryLockedAt := time.Now()
+	require.NoError(t, db.Model(&OutboxEvent{}).
+		Where("id = ?", event.ID).
+		Updates(map[string]any{
+			"status": StatusLocked, "locked_at": retryLockedAt, "locked_by": lockedBy,
+		}).Error)
+	event.Status = StatusLocked
+	event.LockedAt = &retryLockedAt
+	event.LockedBy = &lockedBy
+
+	err = relay.dispatchEvent(context.Background(), &event)
+	require.NoError(t, err)
+	require.Equal(t, 1, localPublishCount)
+	require.Equal(t, 2, streamPublisher.publishCount)
+
+	var parentAfterRetry OutboxEvent
+	require.NoError(t, db.First(&parentAfterRetry, "id = ?", event.ID).Error)
+	require.Equal(t, StatusDispatched, parentAfterRetry.Status)
+}
+
+func TestDispatchEvent_MovesPermanentDeliveryFailureDirectlyToDeadLetter(t *testing.T) {
+	db := openOutboxReschedulerTestDB(t)
+	bus := eventbus.New(zap.NewNop())
+	relay := NewRelay(db, zap.NewNop(), bus, nil, nil, RelayConfig{RelayID: "relay-test"})
+	catchErrors := false
+	bus.Subscribe("test.outbox.permanent_delivery_requested", func(_ context.Context, _ eventbus.DomainEvent) error {
+		return MarkPermanentDelivery(errors.New("unsupported test delivery"))
+	}, eventbus.SubscribeOptions{CatchErrors: &catchErrors})
+
+	now := time.Now()
+	lockedBy := relay.config.RelayID
+	event := OutboxEvent{
+		ID:            "00000000-0000-0000-0000-000000000112",
+		AggregateType: "test_outbox",
+		AggregateID:   "test_permanent_delivery",
+		EventType:     "test.outbox.permanent_delivery_requested",
+		Payload:       []byte(`{}`),
+		OccurredAt:    now,
+		CreatedAt:     now,
+		Status:        StatusLocked,
+		MaxRetries:    10,
+		LockedAt:      &now,
+		LockedBy:      &lockedBy,
+	}
+	require.NoError(t, db.Create(&event).Error)
+
+	err := relay.dispatchEvent(context.Background(), &event)
+	require.Error(t, err)
+	require.True(t, IsPermanentDeliveryError(err))
+
+	var delivery OutboxEventDelivery
+	require.NoError(t, db.First(&delivery, "event_id = ? AND target = ?", event.ID, TargetLocalEventBus).Error)
+	require.Equal(t, StatusDeadLetter, delivery.Status)
+	require.Equal(t, 1, delivery.RetryCount)
+	require.Nil(t, delivery.NextRetryAt)
+	require.NotNil(t, delivery.LastError)
+	require.Equal(t, "publish to local eventbus: unsupported test delivery", *delivery.LastError)
+
+	var parent OutboxEvent
+	require.NoError(t, db.First(&parent, "id = ?", event.ID).Error)
+	require.Equal(t, StatusDeadLetter, parent.Status)
+}
+
+func TestDispatchEvent_PersistentDeliveryRemainsRetryableAfterBudget(t *testing.T) {
+	db := openOutboxReschedulerTestDB(t)
+	bus := eventbus.New(zap.NewNop())
+	relay := NewRelay(db, zap.NewNop(), bus, nil, nil, RelayConfig{
+		RelayID:               "relay-test",
+		PersistentRetryEvents: []string{"payment.webhook.*"},
+	})
+	catchErrors := false
+	bus.Subscribe("payment.webhook.exhausted", func(_ context.Context, _ eventbus.DomainEvent) error {
+		return MarkPermanentDelivery(errors.New("consumer unavailable"))
+	}, eventbus.SubscribeOptions{CatchErrors: &catchErrors})
+
+	now := time.Now()
+	lockedBy := relay.config.RelayID
+	event := OutboxEvent{
+		ID:            "00000000-0000-0000-0000-000000000113",
+		AggregateType: "payment_webhook_event",
+		AggregateID:   "webhook_113",
+		EventType:     "payment.webhook.exhausted",
+		Payload:       []byte(`{}`),
+		OccurredAt:    now,
+		CreatedAt:     now,
+		Status:        StatusLocked,
+		MaxRetries:    1,
+		LockedAt:      &now,
+		LockedBy:      &lockedBy,
+	}
+	require.NoError(t, db.Create(&event).Error)
+
+	err := relay.dispatchEvent(context.Background(), &event)
+	require.Error(t, err)
+
+	var delivery OutboxEventDelivery
+	require.NoError(t, db.First(&delivery, "event_id = ? AND target = ?", event.ID, TargetLocalEventBus).Error)
+	require.Equal(t, StatusRetryPending, delivery.Status)
+	require.Equal(t, 1, delivery.RetryCount)
+	require.NotNil(t, delivery.NextRetryAt)
+
+	var parent OutboxEvent
+	require.NoError(t, db.First(&parent, "id = ?", event.ID).Error)
+	require.Equal(t, StatusRetryPending, parent.Status)
+}
+
+func TestPermanentDeliveryErrorClassificationPreservesCause(t *testing.T) {
+	cause := errors.New("invalid event contract")
+	marked := MarkPermanentDelivery(cause)
+	require.True(t, IsPermanentDeliveryError(marked))
+	require.ErrorIs(t, marked, cause)
+	require.Same(t, marked, MarkPermanentDelivery(marked))
+	require.Nil(t, MarkPermanentDelivery(nil))
+	require.False(t, IsPermanentDeliveryError(fmt.Errorf("transient gateway failure: %w", cause)))
+	require.True(t, IsPermanentDeliveryError(fmt.Errorf("listener failed: %w", marked)))
+}
+
+type failOnceStreamPublisher struct {
+	publishCount int
+}
+
+func (p *failOnceStreamPublisher) Publish(_ context.Context, _ eventstream.StreamEvent) error {
+	p.publishCount++
+	if p.publishCount == 1 {
+		return errors.New("redis unavailable")
+	}
+	return nil
+}
+
+func (p *failOnceStreamPublisher) Close() error {
+	return nil
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 7. generateRelayID — 格式验证
+// ═══════════════════════════════════════════════════════════════
+
+func TestGenerateRelayID_Format(t *testing.T) {
+	id := generateRelayID()
+
+	assert.NotEmpty(t, id)
+	// 格式: hostname-xxxxxxxx（8 位短 UUID）
+	assert.Contains(t, id, "-", "RelayID 应包含分隔符")
+	// 至少包含 hostname 部分和 UUID 部分
+	assert.Greater(t, len(id), 9, "RelayID 应包含 hostname + UUID 后缀")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 8. 指数退避计算验证（目标投递重试逻辑）
+// ═══════════════════════════════════════════════════════════════
+
+func TestExponentialBackoff_Formula(t *testing.T) {
+	// 退避在第十次起封顶，避免持续重试事件把恢复窗口拉得不可控。
+	cases := []struct {
+		retryCount int
+		expected   time.Duration
+	}{
+		{1, 2 * time.Second},
+		{2, 4 * time.Second},
+		{3, 8 * time.Second},
+		{4, 16 * time.Second},
+		{5, 32 * time.Second},
+		{10, 15 * time.Minute},
+	}
+
+	for _, tc := range cases {
+		t.Run(fmt.Sprintf("retry_%d", tc.retryCount), func(t *testing.T) {
+			backoff := retryBackoff(tc.retryCount)
+			assert.Equal(t, tc.expected, backoff,
+				"retryCount=%d 时退避应为 %v", tc.retryCount, tc.expected)
+		})
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 9. OutboxEvent.TableName — GORM 表名映射
+// ═══════════════════════════════════════════════════════════════
+
+func TestOutboxEvent_TableName(t *testing.T) {
+	event := OutboxEvent{}
+	assert.Equal(t, "sys_outbox_events", event.TableName())
+}
+
+func TestOutboxEventDelivery_TableName(t *testing.T) {
+	delivery := OutboxEventDelivery{}
+	assert.Equal(t, "sys_outbox_event_deliveries", delivery.TableName())
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10. 状态常量完整性
+// ═══════════════════════════════════════════════════════════════
+
+func TestStatusConstants(t *testing.T) {
+	statuses := []string{StatusPending, StatusLocked, StatusDispatched, StatusRetryPending, StatusDeadLetter}
+
+	// 所有状态应唯一且非空
+	seen := make(map[string]struct{})
+	for _, s := range statuses {
+		assert.NotEmpty(t, s, "状态常量不应为空")
+		_, duplicate := seen[s]
+		assert.False(t, duplicate, "状态常量不应重复: %s", s)
+		seen[s] = struct{}{}
+	}
+
+	assert.Equal(t, "pending", StatusPending)
+	assert.Equal(t, "locked", StatusLocked)
+	assert.Equal(t, "dispatched", StatusDispatched)
+	assert.Equal(t, "retry_pending", StatusRetryPending)
+	assert.Equal(t, "dead_letter", StatusDeadLetter)
+	assert.Equal(t, "local_eventbus", TargetLocalEventBus)
+	assert.Equal(t, "asynq", TargetAsynq)
+	assert.Equal(t, "redis_stream", TargetRedisStream)
+}