retry_test.go

package goretry

import (
	"context"
	"errors"
	"testing"
	"time"
)

type testError struct {
	message   string
	transient bool
	timeout   bool
	temporary bool
}

func (e *testError) Error() string   { return e.message }
func (e *testError) Timeout() bool   { return e.timeout }
func (e *testError) Temporary() bool { return e.temporary }

func TestRetrier_Do_Success(t *testing.T) {
	retrier := NewRetrier(NewFixedDelayPolicy(10 * time.Millisecond))

	callCount := 0
	err := retrier.Do(func() error {
		callCount++
		if callCount < 3 {
			return &testError{message: "transient error", transient: true, timeout: true}
		}
		return nil
	})

	if err != nil {
		t.Errorf("Expected success, got error: %v", err)
	}

	if callCount != 3 {
		t.Errorf("Expected 3 calls, got %d", callCount)
	}
}

func TestRetrier_Do_NonTransientError(t *testing.T) {
	retrier := NewRetrier(NewFixedDelayPolicy(10 * time.Millisecond))

	callCount := 0
	nonTransientErr := errors.New("non-transient error")

	err := retrier.Do(func() error {
		callCount++
		return nonTransientErr
	})

	if err != nonTransientErr {
		t.Errorf("Expected non-transient error to be returned immediately, got: %v", err)
	}

	if callCount != 1 {
		t.Errorf("Expected 1 call for non-transient error, got %d", callCount)
	}
}

func TestRetrier_Do_OutOfRetries(t *testing.T) {
	retrier := NewRetrier(NewFixedDelayPolicy(1*time.Millisecond), WithMaxAttempts(2))

	callCount := 0
	transientErr := &testError{message: "transient error", timeout: true}

	err := retrier.Do(func() error {
		callCount++
		return transientErr
	})

	var outOfRetriesErr *OutOfRetriesError
	if !errors.As(err, &outOfRetriesErr) {
		t.Errorf("Expected OutOfRetriesError, got: %T", err)
	}

	if outOfRetriesErr.Attempts != 2 {
		t.Errorf("Expected 2 attempts, got %d", outOfRetriesErr.Attempts)
	}

	if callCount != 2 {
		t.Errorf("Expected 2 calls, got %d", callCount)
	}
}

func TestRetrier_DoWithContext_Cancellation(t *testing.T) {
	retrier := NewRetrier(NewFixedDelayPolicy(100 * time.Millisecond))

	ctx, cancel := context.WithCancel(context.Background())

	go func() {
		time.Sleep(50 * time.Millisecond)
		cancel()
	}()

	err := retrier.DoWithContext(ctx, func(ctx context.Context) error {
		return &testError{message: "transient error", timeout: true}
	})

	if !errors.Is(err, context.Canceled) {
		t.Errorf("Expected context.Canceled, got: %v", err)
	}
}

func TestDefaultTransientErrorFunc(t *testing.T) {
	tests := []struct {
		name     string
		err      error
		expected bool
	}{
		{"nil error", nil, false},
		{"timeout error", &testError{timeout: true}, true},
		{"temporary error", &testError{temporary: true}, true},
		{"context canceled", context.Canceled, false},
		{"context deadline exceeded", context.DeadlineExceeded, false},
		{"regular error", errors.New("regular error"), false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := DefaultTransientErrorFunc(tt.err)
			if result != tt.expected {
				t.Errorf("Expected %v, got %v for error: %v", tt.expected, result, tt.err)
			}
		})
	}
}

func TestCustomTransientErrorFunc(t *testing.T) {
	customTransient := func(err error) bool {
		return err.Error() == "custom transient"
	}

	retrier := NewRetrier(
		NewFixedDelayPolicy(1*time.Millisecond),
		WithTransientErrorFunc(customTransient),
		WithMaxAttempts(2),
	)

	callCount := 0
	err := retrier.Do(func() error {
		callCount++
		return errors.New("custom transient")
	})

	var outOfRetriesErr *OutOfRetriesError
	if !errors.As(err, &outOfRetriesErr) {
		t.Errorf("Expected OutOfRetriesError, got: %T", err)
	}

	if callCount != 2 {
		t.Errorf("Expected 2 calls, got %d", callCount)
	}
}

func TestOnRetryCallback(t *testing.T) {
	var retryAttempts []int
	var retryErrors []error

	retrier := NewRetrier(
		NewFixedDelayPolicy(1*time.Millisecond),
		WithMaxAttempts(3),
		WithOnRetry(func(attempt int, err error) {
			retryAttempts = append(retryAttempts, attempt)
			retryErrors = append(retryErrors, err)
		}),
	)

	callCount := 0
	transientErr := &testError{message: "transient error", timeout: true}

	_ = retrier.Do(func() error {
		callCount++
		return transientErr
	})

	expectedAttempts := []int{1, 2}
	if len(retryAttempts) != len(expectedAttempts) {
		t.Errorf("Expected %d retry callbacks, got %d", len(expectedAttempts), len(retryAttempts))
	}

	for i, attempt := range retryAttempts {
		if attempt != expectedAttempts[i] {
			t.Errorf("Expected attempt %d, got %d", expectedAttempts[i], attempt)
		}
	}
}