Add backoff strategy

Author: YakDriver

internal/actionwait/wait.go

@@ -11,6 +11,8 @@ import (
 	"errors"
 	"slices"
 	"time"
+
+	"github.com/hashicorp/terraform-provider-aws/internal/backoff"
 )
 
 // DefaultPollInterval is the default fixed polling interval used when no custom IntervalStrategy is provided.
@@ -41,6 +43,32 @@ type FixedInterval time.Duration
 // NextPoll returns the fixed duration.
 func (fi FixedInterval) NextPoll(uint) time.Duration { return time.Duration(fi) }
 
+// BackoffInterval implements IntervalStrategy using a backoff.Delay strategy.
+// This allows actionwait to leverage sophisticated backoff algorithms while
+// maintaining the declarative status-based polling approach.
+type BackoffInterval struct {
+	delay backoff.Delay
+}
+
+// NextPoll returns the next polling interval using the wrapped backoff delay strategy.
+func (bi BackoffInterval) NextPoll(attempt uint) time.Duration {
+	return bi.delay.Next(attempt)
+}
+
+// WithBackoffDelay creates an IntervalStrategy that uses the provided backoff.Delay.
+// This bridges actionwait's IntervalStrategy interface with the backoff package's
+// delay strategies (fixed, exponential, SDK-compatible, etc.).
+//
+// Example usage:
+//
+//	opts := actionwait.Options[MyType]{
+//	    Interval: actionwait.WithBackoffDelay(backoff.FixedDelay(time.Second)),
+//	    // ... other options
+//	}
+func WithBackoffDelay(delay backoff.Delay) IntervalStrategy {
+	return BackoffInterval{delay: delay}
+}
+
 // Options configure the WaitForStatus loop.
 type Options[T any] struct {
 	Timeout            time.Duration    // Required total timeout.

internal/actionwait/wait_test.go

@@ -10,6 +10,8 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
+
+	"github.com/hashicorp/terraform-provider-aws/internal/backoff"
 )
 
 // fastFixedInterval returns a very small fixed interval to speed tests.
@@ -322,3 +324,103 @@ func TestWaitForStatus_UnexpectedStateErrorMessage(t *testing.T) {
 		t.Errorf("error message should contain allowed state 'PENDING', got: %s", errMsg)
 	}
 }
+
+func TestBackoffInterval(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name              string
+		delay             backoff.Delay
+		attempts          []uint
+		expectedDurations []time.Duration
+	}{
+		{
+			name:              "fixed delay",
+			delay:             backoff.FixedDelay(100 * time.Millisecond),
+			attempts:          []uint{0, 1, 2, 3},
+			expectedDurations: []time.Duration{0, 100 * time.Millisecond, 100 * time.Millisecond, 100 * time.Millisecond},
+		},
+		{
+			name:              "zero delay",
+			delay:             backoff.ZeroDelay,
+			attempts:          []uint{0, 1, 2},
+			expectedDurations: []time.Duration{0, 0, 0},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			interval := BackoffInterval{delay: tt.delay}
+
+			for i, attempt := range tt.attempts {
+				got := interval.NextPoll(attempt)
+				want := tt.expectedDurations[i]
+				if got != want {
+					t.Errorf("NextPoll(%d) = %v, want %v", attempt, got, want)
+				}
+			}
+		})
+	}
+}
+
+func TestWithBackoffDelay(t *testing.T) {
+	t.Parallel()
+
+	delay := backoff.FixedDelay(50 * time.Millisecond)
+	interval := WithBackoffDelay(delay)
+
+	// Verify it implements IntervalStrategy
+	var _ IntervalStrategy = interval
+
+	// Test that it wraps the delay correctly
+	if got := interval.NextPoll(0); got != 0 {
+		t.Errorf("NextPoll(0) = %v, want 0", got)
+	}
+	if got := interval.NextPoll(1); got != 50*time.Millisecond {
+		t.Errorf("NextPoll(1) = %v, want 50ms", got)
+	}
+}
+
+func TestBackoffIntegration(t *testing.T) {
+	t.Parallel()
+
+	ctx := makeCtx(t)
+
+	var callCount atomic.Int32
+	fetch := func(context.Context) (FetchResult[string], error) {
+		count := callCount.Add(1)
+		switch count {
+		case 1:
+			return FetchResult[string]{Status: "CREATING", Value: "attempt1"}, nil
+		case 2:
+			return FetchResult[string]{Status: "AVAILABLE", Value: "success"}, nil
+		default:
+			t.Errorf("unexpected call count: %d", count)
+			return FetchResult[string]{}, errors.New("too many calls")
+		}
+	}
+
+	opts := Options[string]{
+		Timeout:            2 * time.Second,
+		Interval:           WithBackoffDelay(backoff.FixedDelay(fastFixedInterval)),
+		SuccessStates:      []Status{"AVAILABLE"},
+		TransitionalStates: []Status{"CREATING"},
+	}
+
+	result, err := WaitForStatus(ctx, fetch, opts)
+	if err != nil {
+		t.Fatalf("WaitForStatus() error = %v", err)
+	}
+
+	if result.Status != "AVAILABLE" {
+		t.Errorf("result.Status = %q, want %q", result.Status, "AVAILABLE")
+	}
+	if result.Value != "success" {
+		t.Errorf("result.Value = %q, want %q", result.Value, "success")
+	}
+	if callCount.Load() != 2 {
+		t.Errorf("expected 2 fetch calls, got %d", callCount.Load())
+	}
+}