Merge branch 'master' into fork

Author: tstromberg

retry.go

@@ -136,38 +136,6 @@ func DoWithData[T any](retryableFunc RetryableFuncWithData[T], opts ...Option) (
 		return emptyT, err
 	}
 
-	// Setting attempts to 0 means we'll retry until we succeed
-	var lastErr error
-	if config.attempts == 0 {
-		for {
-			t, err := retryableFunc()
-			if err == nil {
-				return t, nil
-			}
-
-			if !IsRecoverable(err) {
-				return emptyT, err
-			}
-
-			if !config.retryIf(err) {
-				return emptyT, err
-			}
-
-			lastErr = err
-
-			config.onRetry(n, err)
-			n++
-			select {
-			case <-config.timer.After(delay(config, n, err)):
-			case <-config.context.Done():
-				if config.wrapContextErrorWithLastError {
-					return emptyT, Error{context.Cause(config.context), lastErr}
-				}
-				return emptyT, context.Cause(config.context)
-			}
-		}
-	}
-
 	errorLog := Error{}
 
 	attemptsForError := make(map[error]uint, len(config.attemptsForError))
@@ -184,6 +152,10 @@ shouldRetry:
 
 		errorLog = append(errorLog, unpackUnrecoverable(err))
 
+		if !IsRecoverable(err) {
+			return emptyT, err
+		}
+
 		if !config.retryIf(err) {
 			break
 		}
@@ -198,6 +170,7 @@ shouldRetry:
 			}
 		}
 
+		// Setting attempts to 0 means we'll retry until we succeed
 		// if this is last attempt - don't wait
 		if n == config.attempts-1 {
 			break shouldRetry

retry_test.go

@@ -140,6 +140,7 @@ func TestRetryIf_ZeroAttempts(t *testing.T) {
 			return err.Error() != "special"
 		}),
 		Delay(time.Nanosecond),
+		LastErrorOnly(true),
 		Attempts(0),
 	)
 	if err == nil {
@@ -286,23 +287,16 @@ func TestLastErrorOnly(t *testing.T) {
 func TestUnrecoverableError(t *testing.T) {
 	attempts := 0
 	testErr := errors.New("error")
-	expectedErr := Error{testErr}
 	err := Do(
 		func() error {
 			attempts++
 			return Unrecoverable(testErr)
 		},
 		Attempts(2),
 	)
-	if err.Error() != expectedErr.Error() {
-		t.Errorf("got %v, want %v", err, expectedErr)
-	}
-	if testErr != errors.Unwrap(err) {
-		t.Errorf("unwrapped error: got %v, want %v", errors.Unwrap(err), testErr)
-	}
-	if attempts != 1 {
-		t.Errorf("attempts with unrecoverable error: got %d, want 1", attempts)
-	}
+	assert.Error(t, err)
+	assert.Equal(t, Unrecoverable(testErr), err)
+	assert.Equal(t, 1, attempts, "unrecoverable error broke the loop")
 }
 
 func TestCombineFixedDelays(t *testing.T) {
@@ -587,6 +581,7 @@ func TestContext(t *testing.T) {
 						cancel()
 					}
 				}),
+				LastErrorOnly(true),
 				Context(ctx),
 				Attempts(0),
 			)