@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/resilience/retry_test.go

@@ -0,0 +1,735 @@
+package resilience
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+// newTestLogger 构建静默 zap logger，避免测试输出噪音
+func newTestLogger() *zap.Logger {
+	return zap.NewNop()
+}
+
+// newFastConfig 构建零延迟重试配置，避免测试等待真实退避时长
+func newFastConfig() RetryConfig {
+	return RetryConfig{
+		MaxAttempts:       3,
+		InitialDelay:      time.Millisecond,
+		MaxDelay:          10 * time.Millisecond,
+		BackoffMultiplier: 2,
+		Jitter:            false,
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 1. NewRetryService — 构造验证
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_NewService_DefaultConfig(t *testing.T) {
+	svc := NewRetryService(newTestLogger())
+	require.NotNil(t, svc)
+	assert.Equal(t, DefaultRetryConfig.MaxAttempts, svc.globalConfig.MaxAttempts)
+	assert.Equal(t, DefaultRetryConfig.InitialDelay, svc.globalConfig.InitialDelay)
+	assert.Equal(t, DefaultRetryConfig.MaxDelay, svc.globalConfig.MaxDelay)
+	assert.Equal(t, DefaultRetryConfig.BackoffMultiplier, svc.globalConfig.BackoffMultiplier)
+	assert.True(t, svc.globalConfig.Jitter)
+	assert.NotNil(t, svc.retries)
+}
+
+func TestRetryService_NewService_CustomConfig(t *testing.T) {
+	cfg := RetryConfig{
+		MaxAttempts:       5,
+		InitialDelay:      500 * time.Millisecond,
+		MaxDelay:          5 * time.Second,
+		BackoffMultiplier: 1.5,
+		Jitter:            false,
+	}
+	svc := NewRetryService(newTestLogger(), cfg)
+	require.NotNil(t, svc)
+	assert.Equal(t, 5, svc.globalConfig.MaxAttempts)
+	assert.Equal(t, 500*time.Millisecond, svc.globalConfig.InitialDelay)
+	assert.InDelta(t, 1.5, svc.globalConfig.BackoffMultiplier, 0.001)
+	assert.False(t, svc.globalConfig.Jitter)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. 首次尝试成功 — 无重试
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_SuccessOnFirstAttempt(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	callCount := 0
+	err := svc.Execute("op-success", func() error {
+		callCount++
+		return nil
+	})
+
+	require.NoError(t, err)
+	assert.Equal(t, 1, callCount, "首次成功应仅调用一次")
+
+	stats := svc.GetStats("op-success")
+	require.NotNil(t, stats)
+	assert.Equal(t, int64(1), stats.TotalExecutions)
+	assert.Equal(t, int64(0), stats.TotalRetries)
+	assert.Equal(t, int64(0), stats.RetriedSuccessCount)
+	assert.Equal(t, int64(0), stats.ExhaustedCount)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. 瞬时失败后成功 — 正确重试次数
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_TransientFailureThenSuccess(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	callCount := 0
+	sentinelErr := errors.New("transient error")
+
+	// 前两次失败，第三次成功
+	err := svc.Execute("op-transient", func() error {
+		callCount++
+		if callCount < 3 {
+			return sentinelErr
+		}
+		return nil
+	})
+
+	require.NoError(t, err)
+	assert.Equal(t, 3, callCount, "应尝试三次")
+
+	stats := svc.GetStats("op-transient")
+	require.NotNil(t, stats)
+	assert.Equal(t, int64(1), stats.TotalExecutions)
+	assert.Equal(t, int64(2), stats.TotalRetries, "应记录两次重试")
+	assert.Equal(t, int64(1), stats.RetriedSuccessCount, "重试后成功计数应为 1")
+	assert.Equal(t, int64(0), stats.ExhaustedCount)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. 重试耗尽 — 返回 RetryExhaustedError 包装最后一个错误
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_AllRetriesExhausted(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	callCount := 0
+	lastErr := errors.New("persistent failure")
+
+	err := svc.Execute("op-exhausted", func() error {
+		callCount++
+		return lastErr
+	})
+
+	require.Error(t, err)
+	assert.Equal(t, 3, callCount, "MaxAttempts=3 时应尝试三次")
+
+	var exhausted *RetryExhaustedError
+	require.True(t, errors.As(err, &exhausted), "错误类型应为 RetryExhaustedError")
+	assert.Equal(t, "op-exhausted", exhausted.Key)
+	assert.Equal(t, 3, exhausted.Attempts)
+	assert.Equal(t, lastErr, exhausted.LastError)
+	// Unwrap 应返回原始错误
+	assert.True(t, errors.Is(err, lastErr), "errors.Is 应能穿透 RetryExhaustedError")
+
+	stats := svc.GetStats("op-exhausted")
+	require.NotNil(t, stats)
+	assert.Equal(t, int64(1), stats.TotalExecutions)
+	assert.Equal(t, int64(1), stats.ExhaustedCount)
+}
+
+func TestRetryService_RetryExhaustedError_Message(t *testing.T) {
+	inner := errors.New("inner err")
+	e := &RetryExhaustedError{Key: "mykey", Attempts: 5, LastError: inner}
+	msg := e.Error()
+	assert.Contains(t, msg, "mykey")
+	assert.Contains(t, msg, "5")
+	assert.Contains(t, msg, "inner err")
+	assert.Equal(t, inner, e.Unwrap())
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 5. RetryableCheck — 仅当谓词返回 true 时重试
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_RetryableCheck_OnlyRetriesWhenTrue(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	retryableErr := errors.New("retryable")
+	nonRetryableErr := errors.New("not retryable")
+
+	callCount := 0
+	// 第一次返回 nonRetryableErr，check 返回 false，应立即停止
+	err := svc.Execute("op-check", func() error {
+		callCount++
+		return nonRetryableErr
+	}, RetryOptions{
+		RetryableCheck: func(e error) bool {
+			return errors.Is(e, retryableErr)
+		},
+	})
+
+	require.Error(t, err)
+	assert.Equal(t, 1, callCount, "不可重试错误应立即终止")
+	assert.Equal(t, nonRetryableErr, err, "应直接返回原始错误，而非 RetryExhaustedError")
+
+	var exhausted *RetryExhaustedError
+	assert.False(t, errors.As(err, &exhausted), "不应包装为 RetryExhaustedError")
+}
+
+func TestRetryService_RetryableCheck_RetriesWhenTrue(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	retryableErr := errors.New("retryable")
+	callCount := 0
+
+	err := svc.Execute("op-check-retryable", func() error {
+		callCount++
+		return retryableErr
+	}, RetryOptions{
+		RetryableCheck: func(e error) bool {
+			return errors.Is(e, retryableErr)
+		},
+	})
+
+	require.Error(t, err)
+	assert.Equal(t, 3, callCount, "可重试错误应耗尽全部 MaxAttempts")
+
+	var exhausted *RetryExhaustedError
+	assert.True(t, errors.As(err, &exhausted))
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 6. 不可重试错误 — 立即失败，无重试
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_NonRetryableError_StopsImmediately(t *testing.T) {
+	cfg := newFastConfig()
+	// 在配置层设置 RetryableCheck，只有特定错误可重试
+	retryable := errors.New("ok to retry")
+	cfg.RetryableCheck = func(e error) bool {
+		return errors.Is(e, retryable)
+	}
+	svc := NewRetryService(newTestLogger(), cfg)
+	svc.ConfigureRetry("op-non-retryable", cfg)
+
+	callCount := 0
+	fatal := errors.New("fatal error")
+
+	err := svc.Execute("op-non-retryable", func() error {
+		callCount++
+		return fatal
+	})
+
+	require.Error(t, err)
+	assert.Equal(t, 1, callCount, "不可重试错误只应执行一次")
+	assert.Equal(t, fatal, err)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 7. 指数退避 — 延迟随尝试次数增长
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_ExponentialBackoff_DelayIncreases(t *testing.T) {
+	cfg := RetryConfig{
+		MaxAttempts:       4,
+		InitialDelay:      20 * time.Millisecond,
+		MaxDelay:          1 * time.Second,
+		BackoffMultiplier: 2,
+		Jitter:            false, // 禁用 jitter 以精确验证
+	}
+	svc := NewRetryService(newTestLogger(), cfg)
+
+	var delays []time.Duration
+	var mu sync.Mutex
+	var lastStart time.Time
+
+	callCount := 0
+	_ = svc.Execute("op-backoff", func() error {
+		callCount++
+		now := time.Now()
+		if callCount > 1 {
+			mu.Lock()
+			delays = append(delays, now.Sub(lastStart))
+			mu.Unlock()
+		}
+		lastStart = now
+		return errors.New("fail")
+	})
+
+	require.Equal(t, 4, callCount)
+	require.Len(t, delays, 3, "MaxAttempts=4 应有 3 次间隔")
+
+	// 验证每个间隔递增（允许 20ms 系统调度误差）
+	// attempt1→2: ~20ms, attempt2→3: ~40ms, attempt3→4: ~80ms
+	for i := 1; i < len(delays); i++ {
+		assert.Greater(t, delays[i], delays[i-1],
+			"第 %d 次间隔 (%v) 应大于第 %d 次间隔 (%v)", i+1, delays[i], i, delays[i-1])
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 8. 抖动 — 延迟有随机性（在 ±25% 范围内）
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_Jitter_DelayWithinBounds(t *testing.T) {
+	// 直接测试 calculateDelay 方法，避免 time.Sleep 引起测试缓慢
+	svc := NewRetryService(newTestLogger())
+
+	cfg := RetryConfig{
+		InitialDelay:      100 * time.Millisecond,
+		MaxDelay:          10 * time.Second,
+		BackoffMultiplier: 2,
+		Jitter:            true,
+	}
+
+	// attempt=1 时 base delay = InitialDelay * multiplier^0 = 100ms
+	// ±25% 范围：[75ms, 125ms]
+	const baseDelay = 100 * time.Millisecond
+	const tolerance = 0.25
+	lower := time.Duration(float64(baseDelay) * (1 - tolerance))
+	upper := time.Duration(float64(baseDelay) * (1 + tolerance))
+
+	// 多次采样确认始终在边界内
+	seen := make(map[time.Duration]bool)
+	for i := 0; i < 100; i++ {
+		d := svc.calculateDelay(1, cfg)
+		assert.GreaterOrEqual(t, d, lower, "抖动下界违反")
+		assert.LessOrEqual(t, d, upper, "抖动上界违反")
+		seen[d] = true
+	}
+
+	// 100 次采样应产生多于 1 种延迟值（验证存在随机性）
+	assert.Greater(t, len(seen), 1, "抖动应产生不同的延迟值")
+}
+
+func TestRetryService_NoJitter_DelayIsDeterministic(t *testing.T) {
+	svc := NewRetryService(newTestLogger())
+
+	cfg := RetryConfig{
+		InitialDelay:      50 * time.Millisecond,
+		MaxDelay:          10 * time.Second,
+		BackoffMultiplier: 2,
+		Jitter:            false,
+	}
+
+	// attempt=1 → 50ms, attempt=2 → 100ms, attempt=3 → 200ms
+	d1 := svc.calculateDelay(1, cfg)
+	d2 := svc.calculateDelay(2, cfg)
+	d3 := svc.calculateDelay(3, cfg)
+
+	assert.Equal(t, 50*time.Millisecond, d1)
+	assert.Equal(t, 100*time.Millisecond, d2)
+	assert.Equal(t, 200*time.Millisecond, d3)
+
+	// 同一 attempt 多次调用应相同
+	for i := 0; i < 10; i++ {
+		assert.Equal(t, d1, svc.calculateDelay(1, cfg))
+	}
+}
+
+func TestRetryService_MaxDelay_IsCapped(t *testing.T) {
+	svc := NewRetryService(newTestLogger())
+
+	cfg := RetryConfig{
+		InitialDelay:      100 * time.Millisecond,
+		MaxDelay:          150 * time.Millisecond,
+		BackoffMultiplier: 10, // 快速超过上限
+		Jitter:            false,
+	}
+
+	// attempt=2 → 100ms * 10^1 = 1000ms，但 MaxDelay=150ms
+	d := svc.calculateDelay(2, cfg)
+	assert.LessOrEqual(t, d, 150*time.Millisecond, "延迟不应超过 MaxDelay")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 9. MaxAttempts 配置 — 每次执行可覆盖
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_MaxRetries_Respected(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig()) // 全局 MaxAttempts=3
+
+	// 通过 RetryOptions 覆盖为 5 次
+	maxAttempts := 5
+	callCount := 0
+	err := svc.Execute("op-max", func() error {
+		callCount++
+		return errors.New("fail")
+	}, RetryOptions{MaxAttempts: &maxAttempts})
+
+	require.Error(t, err)
+	assert.Equal(t, 5, callCount, "MaxAttempts 覆盖为 5 后应尝试 5 次")
+
+	var exhausted *RetryExhaustedError
+	require.True(t, errors.As(err, &exhausted))
+	assert.Equal(t, 5, exhausted.Attempts)
+}
+
+func TestRetryService_MaxRetries_One_NoRetry(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	maxAttempts := 1
+	callCount := 0
+	err := svc.Execute("op-one", func() error {
+		callCount++
+		return errors.New("fail")
+	}, RetryOptions{MaxAttempts: &maxAttempts})
+
+	require.Error(t, err)
+	assert.Equal(t, 1, callCount, "MaxAttempts=1 时只执行一次")
+
+	var exhausted *RetryExhaustedError
+	require.True(t, errors.As(err, &exhausted))
+	assert.Equal(t, 1, exhausted.Attempts)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10. 不同 key 独立统计
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_DifferentKeys_IndependentStats(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	// key-a：首次成功
+	_ = svc.Execute("key-a", func() error { return nil })
+
+	// key-b：全部失败（耗尽）
+	_ = svc.Execute("key-b", func() error { return errors.New("fail") })
+
+	statsA := svc.GetStats("key-a")
+	statsB := svc.GetStats("key-b")
+
+	require.NotNil(t, statsA)
+	require.NotNil(t, statsB)
+
+	assert.Equal(t, int64(1), statsA.TotalExecutions)
+	assert.Equal(t, int64(0), statsA.TotalRetries)
+	assert.Equal(t, int64(0), statsA.ExhaustedCount)
+
+	assert.Equal(t, int64(1), statsB.TotalExecutions)
+	assert.Equal(t, int64(2), statsB.TotalRetries)
+	assert.Equal(t, int64(1), statsB.ExhaustedCount)
+}
+
+func TestRetryService_ConfigureRetry_PerKeyConfig(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig()) // 全局 MaxAttempts=3
+
+	// key-custom 单独配置为 2 次
+	svc.ConfigureRetry("key-custom", RetryConfig{
+		MaxAttempts:       2,
+		InitialDelay:      time.Millisecond,
+		MaxDelay:          10 * time.Millisecond,
+		BackoffMultiplier: 2,
+		Jitter:            false,
+	})
+
+	callCount := 0
+	err := svc.Execute("key-custom", func() error {
+		callCount++
+		return errors.New("fail")
+	})
+
+	require.Error(t, err)
+	assert.Equal(t, 2, callCount, "per-key MaxAttempts=2 应只尝试 2 次")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 11. GetStats / GetAllStats / ResetStats
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_GetStats_UnknownKey_ReturnsNil(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+	stats := svc.GetStats("nonexistent")
+	assert.Nil(t, stats, "未知 key 应返回 nil")
+}
+
+func TestRetryService_GetAllStats_ReturnsAllKeys(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	_ = svc.Execute("k1", func() error { return nil })
+	_ = svc.Execute("k2", func() error { return errors.New("fail") })
+	_ = svc.Execute("k3", func() error { return nil })
+
+	all := svc.GetAllStats()
+	assert.Len(t, all, 3, "应包含所有三个 key 的统计")
+
+	_, ok1 := all["k1"]
+	_, ok2 := all["k2"]
+	_, ok3 := all["k3"]
+	assert.True(t, ok1)
+	assert.True(t, ok2)
+	assert.True(t, ok3)
+}
+
+func TestRetryService_ResetStats_ClearsCounters(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	// 制造一些统计数据
+	_ = svc.Execute("op-reset", func() error { return errors.New("fail") })
+
+	before := svc.GetStats("op-reset")
+	require.NotNil(t, before)
+	assert.Equal(t, int64(1), before.TotalExecutions)
+	assert.Greater(t, before.TotalRetries, int64(0))
+
+	// 重置
+	svc.ResetStats("op-reset")
+
+	after := svc.GetStats("op-reset")
+	require.NotNil(t, after)
+	assert.Equal(t, int64(0), after.TotalExecutions)
+	assert.Equal(t, int64(0), after.TotalRetries)
+	assert.Equal(t, int64(0), after.RetriedSuccessCount)
+	assert.Equal(t, int64(0), after.ExhaustedCount)
+}
+
+func TestRetryService_ResetStats_UnknownKey_NoOp(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+	// 对不存在的 key 调用 ResetStats 不应 panic
+	assert.NotPanics(t, func() {
+		svc.ResetStats("ghost-key")
+	})
+}
+
+func TestRetryService_Stats_MultipleExecutions_Accumulate(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	// 执行 3 次：2 次成功，1 次耗尽
+	_ = svc.Execute("acc", func() error { return nil })
+	_ = svc.Execute("acc", func() error { return nil })
+	_ = svc.Execute("acc", func() error { return errors.New("fail") })
+
+	stats := svc.GetStats("acc")
+	require.NotNil(t, stats)
+	assert.Equal(t, int64(3), stats.TotalExecutions)
+	assert.Equal(t, int64(1), stats.ExhaustedCount)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 12. Context 取消 — 停止重试
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_ContextCancellation_StopsRetrying(t *testing.T) {
+	cfg := RetryConfig{
+		MaxAttempts:       10,
+		InitialDelay:      5 * time.Millisecond,
+		MaxDelay:          50 * time.Millisecond,
+		BackoffMultiplier: 1, // 固定延迟便于控制
+		Jitter:            false,
+	}
+	svc := NewRetryService(newTestLogger(), cfg)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	callCount := 0
+
+	go func() {
+		// 第一次执行后立即取消
+		time.Sleep(2 * time.Millisecond)
+		cancel()
+	}()
+
+	err := svc.ExecuteWithContext(ctx, "op-ctx", func(context.Context) error {
+		callCount++
+		return errors.New("transient")
+	})
+
+	require.Error(t, err)
+	assert.ErrorIs(t, err, context.Canceled)
+	// context 取消后不应继续消耗重试预算
+	assert.Less(t, callCount, 10, "context 取消后不应耗尽全部 10 次重试")
+}
+
+func TestRetryService_ContextAlreadyCancelled_StopsImmediately(t *testing.T) {
+	cfg := RetryConfig{
+		MaxAttempts:       5,
+		InitialDelay:      time.Millisecond,
+		MaxDelay:          10 * time.Millisecond,
+		BackoffMultiplier: 2,
+		Jitter:            false,
+	}
+	svc := NewRetryService(newTestLogger(), cfg)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // 预先取消
+
+	callCount := 0
+	err := svc.ExecuteWithContext(ctx, "op-ctx-pre", func(context.Context) error {
+		callCount++
+		return errors.New("fail")
+	})
+
+	require.Error(t, err)
+	assert.ErrorIs(t, err, context.Canceled)
+	assert.Equal(t, 0, callCount, "context 已取消时不应执行被保护操作")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 13. 并发使用 — 多 goroutine 同时重试
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_Concurrent_MultipleGoroutines(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	const goroutines = 20
+	var wg sync.WaitGroup
+	var successCount atomic.Int64
+	var errCount atomic.Int64
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			key := fmt.Sprintf("goroutine-%d", id)
+			attempts := 0
+			err := svc.Execute(key, func() error {
+				attempts++
+				if attempts < 2 {
+					return errors.New("first fail")
+				}
+				return nil
+			})
+			if err == nil {
+				successCount.Add(1)
+			} else {
+				errCount.Add(1)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	// 全部 goroutine 都应在第二次尝试时成功
+	assert.Equal(t, int64(goroutines), successCount.Load())
+	assert.Equal(t, int64(0), errCount.Load())
+
+	// 每个 key 应有独立统计
+	all := svc.GetAllStats()
+	assert.Len(t, all, goroutines)
+
+	for i := 0; i < goroutines; i++ {
+		key := fmt.Sprintf("goroutine-%d", i)
+		st, ok := all[key]
+		assert.True(t, ok, "key %s 应存在", key)
+		assert.Equal(t, int64(1), st.TotalExecutions)
+		assert.Equal(t, int64(1), st.TotalRetries)
+		assert.Equal(t, int64(1), st.RetriedSuccessCount)
+	}
+}
+
+func TestRetryService_Concurrent_SameKey(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	const goroutines = 50
+	var wg sync.WaitGroup
+	var totalSuccess atomic.Int64
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			err := svc.Execute("shared-key", func() error { return nil })
+			if err == nil {
+				totalSuccess.Add(1)
+			}
+		}()
+	}
+
+	wg.Wait()
+
+	assert.Equal(t, int64(goroutines), totalSuccess.Load())
+
+	stats := svc.GetStats("shared-key")
+	require.NotNil(t, stats)
+	assert.Equal(t, int64(goroutines), stats.TotalExecutions)
+	// 首次即成功，不产生重试
+	assert.Equal(t, int64(0), stats.TotalRetries)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// SetGlobalConfig — 对后续新 key 生效
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_SetGlobalConfig_AffectsNewKeys(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig()) // MaxAttempts=3
+
+	// 修改全局配置为 MaxAttempts=2
+	svc.SetGlobalConfig(RetryConfig{
+		MaxAttempts:       2,
+		InitialDelay:      time.Millisecond,
+		MaxDelay:          5 * time.Millisecond,
+		BackoffMultiplier: 2,
+		Jitter:            false,
+	})
+
+	callCount := 0
+	err := svc.Execute("new-key-after-global-change", func() error {
+		callCount++
+		return errors.New("fail")
+	})
+
+	require.Error(t, err)
+	assert.Equal(t, 2, callCount, "全局配置更新后新 key 应使用新的 MaxAttempts=2")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// RetryableCheck 与 RetryOptions 组合 — opt 覆盖 config 层
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_RetryOptions_OverridesConfig(t *testing.T) {
+	// 全局 RetryableCheck 允许所有错误
+	cfg := newFastConfig()
+	cfg.RetryableCheck = func(e error) bool { return true }
+	svc := NewRetryService(newTestLogger(), cfg)
+
+	specificErr := errors.New("specific")
+	callCount := 0
+
+	// 通过 RetryOptions 覆盖，只有 specificErr 才重试
+	err := svc.Execute("op-override", func() error {
+		callCount++
+		return errors.New("other error")
+	}, RetryOptions{
+		RetryableCheck: func(e error) bool {
+			return errors.Is(e, specificErr)
+		},
+	})
+
+	require.Error(t, err)
+	// "other error" 不匹配 specificErr → 立即停止
+	assert.Equal(t, 1, callCount, "opt.RetryableCheck 应覆盖 config 层")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// RetriedSuccessCount 精确验证
+// ═══════════════════════════════════════════════════════════════
+
+func TestRetryService_RetriedSuccessCount_OnlyCountsRetried(t *testing.T) {
+	svc := NewRetryService(newTestLogger(), newFastConfig())
+
+	// 第一次执行：首次成功（不计入 RetriedSuccessCount）
+	_ = svc.Execute("rc", func() error { return nil })
+	// 第二次执行：第二次才成功
+	count := 0
+	_ = svc.Execute("rc", func() error {
+		count++
+		if count < 2 {
+			return errors.New("x")
+		}
+		return nil
+	})
+
+	stats := svc.GetStats("rc")
+	require.NotNil(t, stats)
+	assert.Equal(t, int64(2), stats.TotalExecutions)
+	assert.Equal(t, int64(1), stats.RetriedSuccessCount, "只有重试后成功的执行才计入")
+}