Async support for when, whenError and onRetry (#679)

Co-authored-by: Nate Bosch <[email protected]>

Author: beroso

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.13.5-dev
+
+* Allow async callbacks in RetryClient.
+
 ## 0.13.4
 
 * Throw a more useful error when a client is used after it has been closed.

lib/retry.dart

@@ -18,16 +18,16 @@ class RetryClient extends BaseClient {
   final int _retries;
 
   /// The callback that determines whether a request should be retried.
-  final bool Function(BaseResponse) _when;
+  final FutureOr<bool> Function(BaseResponse) _when;
 
   /// The callback that determines whether a request when an error is thrown.
-  final bool Function(Object, StackTrace) _whenError;
+  final FutureOr<bool> Function(Object, StackTrace) _whenError;
 
   /// The callback that determines how long to wait before retrying a request.
   final Duration Function(int) _delay;
 
   /// The callback to call to indicate that a request is being retried.
-  final void Function(BaseRequest, BaseResponse?, int)? _onRetry;
+  final FutureOr<void> Function(BaseRequest, BaseResponse?, int)? _onRetry;
 
   /// Creates a client wrapping [_inner] that retries HTTP requests.
   ///
@@ -51,10 +51,11 @@ class RetryClient extends BaseClient {
   RetryClient(
     this._inner, {
     int retries = 3,
-    bool Function(BaseResponse) when = _defaultWhen,
-    bool Function(Object, StackTrace) whenError = _defaultWhenError,
+    FutureOr<bool> Function(BaseResponse) when = _defaultWhen,
+    FutureOr<bool> Function(Object, StackTrace) whenError = _defaultWhenError,
     Duration Function(int retryCount) delay = _defaultDelay,
-    void Function(BaseRequest, BaseResponse?, int retryCount)? onRetry,
+    FutureOr<void> Function(BaseRequest, BaseResponse?, int retryCount)?
+        onRetry,
   })  : _retries = retries,
         _when = when,
         _whenError = whenError,
@@ -72,9 +73,10 @@ class RetryClient extends BaseClient {
   RetryClient.withDelays(
     Client inner,
     Iterable<Duration> delays, {
-    bool Function(BaseResponse) when = _defaultWhen,
-    bool Function(Object, StackTrace) whenError = _defaultWhenError,
-    void Function(BaseRequest, BaseResponse?, int retryCount)? onRetry,
+    FutureOr<bool> Function(BaseResponse) when = _defaultWhen,
+    FutureOr<bool> Function(Object, StackTrace) whenError = _defaultWhenError,
+    FutureOr<void> Function(BaseRequest, BaseResponse?, int retryCount)?
+        onRetry,
   }) : this._withDelays(
           inner,
           delays.toList(),
@@ -86,9 +88,9 @@ class RetryClient extends BaseClient {
   RetryClient._withDelays(
     Client inner,
     List<Duration> delays, {
-    required bool Function(BaseResponse) when,
-    required bool Function(Object, StackTrace) whenError,
-    required void Function(BaseRequest, BaseResponse?, int)? onRetry,
+    required FutureOr<bool> Function(BaseResponse) when,
+    required FutureOr<bool> Function(Object, StackTrace) whenError,
+    required FutureOr<void> Function(BaseRequest, BaseResponse?, int)? onRetry,
   }) : this(
           inner,
           retries: delays.length,
@@ -108,19 +110,19 @@ class RetryClient extends BaseClient {
       try {
         response = await _inner.send(_copyRequest(request, splitter.split()));
       } catch (error, stackTrace) {
-        if (i == _retries || !_whenError(error, stackTrace)) rethrow;
+        if (i == _retries || !await _whenError(error, stackTrace)) rethrow;
       }
 
       if (response != null) {
-        if (i == _retries || !_when(response)) return response;
+        if (i == _retries || !await _when(response)) return response;
 
         // Make sure the response stream is listened to so that we don't leave
         // dangling connections.
         _unawaited(response.stream.listen((_) {}).cancel().catchError((_) {}));
       }
 
       await Future<void>.delayed(_delay(i));
-      _onRetry?.call(request, response, i);
+      await _onRetry?.call(request, response, i);
       i++;
     }
   }

pubspec.yaml

@@ -1,5 +1,5 @@
 name: http
-version: 0.13.4
+version: 0.13.5-dev
 homepage: https://github.com/dart-lang/http
 description: A composable, multi-platform, Future-based API for HTTP requests.
 

test/http_retry_test.dart

@@ -224,4 +224,32 @@ void main() {
     final response = await client.send(request);
     expect(response.statusCode, equals(503));
   });
+
+  test('async when, whenError and onRetry', () async {
+    final client = RetryClient(
+      MockClient(expectAsync1(
+          (request) async => request.headers['Authorization'] != null
+              ? Response('', 200)
+              : Response('', 401),
+          count: 2)),
+      retries: 1,
+      delay: (_) => Duration.zero,
+      when: (response) async {
+        await Future<void>.delayed(const Duration(milliseconds: 500));
+        return response.statusCode == 401;
+      },
+      whenError: (error, stackTrace) async {
+        await Future<void>.delayed(const Duration(milliseconds: 500));
+        return false;
+      },
+      onRetry: (request, response, retryCount) async {
+        expect(response?.statusCode, equals(401));
+        await Future<void>.delayed(const Duration(milliseconds: 500));
+        request.headers['Authorization'] = 'Bearer TOKEN';
+      },
+    );
+
+    final response = await client.get(Uri.http('example.org', ''));
+    expect(response.statusCode, equals(200));
+  });
 }