Add a default timeout and a test to ensure that timeout works

Author: MelbourneDeveloper

lib/async_lock.dart

@@ -15,15 +15,31 @@ class AsyncLock<T> {
   final bool retainFutureErrors;
 
   /// Executes the given [function] and returns the value, but ensures that
-  /// only one async function executes at a time.
-  Future<T> execute() async {
+  /// only one async function executes at a time. The call defaults to a
+  /// timeout of 5 minutes.
+  Future<T> execute([Duration timeout = const Duration(minutes: 5)]) async {
     try {
       if (_completer != null) {
         return _completer!.future;
       } else {
         _completer = Completer<T>();
       }
-      final result = await function();
+
+      final result = await function().timeout(
+        timeout,
+        onTimeout: () {
+          //On timeout complete with an error
+          final error = TimeoutException('Timeout of $timeout exceeded.');
+          _completer!.completeError(error);
+          if (!retainFutureErrors) {
+            //Clear the completer/error if we're not hanging on to it
+            //TODO: verify this happens in all cases
+            _completer = null;
+          }
+          throw error;
+        },
+      );
+
       _completer!.complete(result);
       return result;
       // ignore: avoid_catches_without_on_clauses

lib/ioc_container.dart

@@ -268,7 +268,9 @@ extension IocContainerExtensions on IocContainer {
   ///with [IocContainerBuilder.addAsync] or
   ///[IocContainerBuilder.addSingletonAsync]. You can only use this on factories
   ///that return a Future<>.
-  Future<T> getAsync<T>() async {
+  Future<T> getAsync<T>([
+    Duration? timeout = const Duration(minutes: 5),
+  ]) async {
     final serviceDefinition = serviceDefinitionsByType[Future<T>];
 
     if (serviceDefinition == null) {
@@ -295,7 +297,7 @@ extension IocContainerExtensions on IocContainer {
 
       try {
         //Await the locked call
-        final future = lock.execute();
+        final future = timeout != null ? lock.execute(timeout) : lock.execute();
         await future;
 
         //Store successful future

test/ioc_container_test.dart

@@ -526,37 +526,65 @@ void main() {
     );
   });
 
-  test('Test initSafe - Deadlock times out', () async {
-    var throwException = true;
+  test('Test Time Out', () async {
+    var loop = true;
 
     final builder = IocContainerBuilder()
-      ..addSingletonAsync(
-        (c) async => throwException ? throw Exception() : A('a'),
+      ..addSingletonAsync<A>(
+        (c) async {
+          while (loop) {
+            await Future<void>.delayed(const Duration(milliseconds: 10));
+          }
+          return A('a');
+        },
       );
 
     final container = builder.toContainer();
 
-    //This causes a deadlock because the future is never completed, so cleanup
-    //never occurs
-    expect(() async => container.getAsync<A>(), throwsException);
+    final future1 = container.getAsync<A>(const Duration(milliseconds: 100));
+    final future2 = container.getAsync<A>(const Duration(milliseconds: 200));
 
-    //We should not have stored the bad future
-    expect(container.singletons.containsKey(Future<A>), false);
+    final combinedFutures = Future.wait([future1, future2]);
 
-    throwException = false;
+    await expectLater(combinedFutures, throwsA(isA<Exception>()));
 
-    //We can recover
-    final a = await container.getAsync<A>();
+    loop = false;
 
-    expect(
-      identical(
-        a,
-        await container.getAsync<A>(),
-      ),
-      true,
-    );
+    final a = await container.getAsync<A>();
+    expect(a.name, 'a');
   });
 
+  // test('Test initSafe - Deadlock times out', () async {
+  //   var throwException = true;
+
+  //   final builder = IocContainerBuilder()
+  //     ..addSingletonAsync(
+  //       (c) async => throwException ? throw Exception() : A('a'),
+  //     );
+
+  //   final container = builder.toContainer();
+
+  //   //This causes a deadlock because the future is never completed, so cleanup
+  //   //never occurs
+  //   expect(() async => container.getAsync<A>(), throwsException);
+
+  //   //We should not have stored the bad future
+  //   expect(container.singletons.containsKey(Future<A>), false);
+
+  //   throwException = false;
+
+  //   //We can recover
+  //   final a = await container.getAsync<A>();
+
+  //   expect(
+  //     identical(
+  //       a,
+  //       await container.getAsync<A>(),
+  //     ),
+  //     true,
+  //   );
+  // });
+
   test('Test initSafe - Recover From Error expectLater', () async {
     var throwException = true;