Add ability to wait for an invocation

Author: jdicker

pkgs/mockito/README.md

@@ -150,6 +150,16 @@ cat.eatFood("Fish");
 expect(verify(cat.eatFood(captureThat(startsWith("F")).captured, ["Fish"]);
 ```
 
+## Waiting for an interaction
+```dart
+//waiting for a call
+cat.eatFood("Fish");
+await untilCalled(cat.chew()); //completes when cat.chew() is called
+//waiting for a call that has already happened
+cat.eatFood("Fish");
+await untilCalled(cat.eatFood(any)); //will complete immediately
+```
+
 ## Resetting mocks
 ```dart
 //clearing collected interactions

pkgs/mockito/lib/mockito.dart

@@ -42,4 +42,5 @@ export 'src/mock.dart'
         clearInteractions,
         reset,
         resetMockitoState,
-        logInvocations;
+        logInvocations,
+        untilCalled;

pkgs/mockito/lib/src/mock.dart

@@ -15,14 +15,18 @@
 // Warning: Do not import dart:mirrors in this library, as it's exported via
 // lib/mockito.dart, which is used for Dart AOT projects such as Flutter.
 
+import 'dart:async';
+
 import 'package:meta/meta.dart';
 import 'package:mockito/src/call_pair.dart';
 import 'package:mockito/src/invocation_matcher.dart';
 import 'package:test/test.dart';
 
 bool _whenInProgress = false;
+bool _untilCalledInProgress = false;
 bool _verificationInProgress = false;
 _WhenCall _whenCall;
+_UntilCall _untilCall;
 final List<_VerifyCall> _verifyCalls = <_VerifyCall>[];
 final _TimeStampProvider _timer = new _TimeStampProvider();
 final List _capturedArgs = [];
@@ -78,6 +82,8 @@ class Mock {
 
   static const _nullResponse = const CallPair.allInvocations(_answerNull);
 
+  final StreamController<Invocation> _invocationStreamController =
+      new StreamController.broadcast();
   final _realCalls = <RealCall>[];
   final _responses = <CallPair>[];
 
@@ -103,8 +109,12 @@ class Mock {
     } else if (_verificationInProgress) {
       _verifyCalls.add(new _VerifyCall(this, invocation));
       return null;
+    } else if (_untilCalledInProgress) {
+      _untilCall = new _UntilCall(this, invocation);
+      return null;
     } else {
       _realCalls.add(new RealCall(this, invocation));
+      _invocationStreamController.add(invocation);
       var cannedResponse = _responses.lastWhere(
           (cr) => cr.call.matches(invocation, {}),
           orElse: _defaultResponse);
@@ -470,6 +480,29 @@ class _WhenCall {
   }
 }
 
+class _UntilCall {
+  final InvocationMatcher _invocationMatcher;
+  final Mock _mock;
+
+  _UntilCall(this._mock, Invocation invocation)
+      : _invocationMatcher = new InvocationMatcher(invocation);
+
+  bool _matchesInvocation(RealCall realCall) =>
+      _invocationMatcher.matches(realCall.invocation);
+
+  List<RealCall> get _realCalls => _mock._realCalls;
+
+  Future<Invocation> get invocationFuture {
+    if (_realCalls.any(_matchesInvocation)) {
+      return new Future.value(
+          _realCalls.firstWhere(_matchesInvocation).invocation);
+    }
+
+    return _mock._invocationStreamController.stream
+        .firstWhere(_invocationMatcher.matches);
+  }
+}
+
 class _VerifyCall {
   final Mock mock;
   final Invocation verifyInvocation;
@@ -707,6 +740,29 @@ Expectation get when {
   };
 }
 
+typedef Future<Invocation> InvocationLoader(_);
+
+/// Returns a future [Invocation] that will complete upon the first occurrence
+/// of the given invocation.
+///
+/// Usage of this is as follows:
+///
+/// ```dart
+/// cat.eatFood("fish");
+/// await untilCalled(cat.chew());
+/// ```
+///
+/// In the above example, the untilCalled(cat.chew()) will complete only when
+/// that method is called. If the given invocation has already been called, the
+/// future will return immediately.
+InvocationLoader get untilCalled {
+  _untilCalledInProgress = true;
+  return (_) {
+    _untilCalledInProgress = false;
+    return _untilCall.invocationFuture;
+  };
+}
+
 /// Print all collected invocations of any mock methods of [mocks].
 void logInvocations(List<Mock> mocks) {
   List<RealCall> allInvocations =
@@ -728,8 +784,10 @@ void logInvocations(List<Mock> mocks) {
 /// or in `tearDown`.
 void resetMockitoState() {
   _whenInProgress = false;
+  _untilCalledInProgress = false;
   _verificationInProgress = false;
   _whenCall = null;
+  _untilCall = null;
   _verifyCalls.clear();
   _capturedArgs.clear();
   _typedArgs.clear();

pkgs/mockito/test/mockito_test.dart

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import 'dart:async';
+
 import 'package:mockito/mockito.dart';
 import 'package:mockito/src/mock.dart'
     show resetMockitoState, throwOnMissingStub;
@@ -42,6 +44,33 @@ class RealClass {
   }
 }
 
+class CallMethodsEvent {}
+
+/// Listens on a stream and upon any event calls all methods in [RealClass].
+class RealClassController {
+  final RealClass _realClass;
+
+  RealClassController(
+      this._realClass, StreamController<CallMethodsEvent> streamController) {
+    streamController.stream.listen(_callAllMethods);
+  }
+
+  Future<Null> _callAllMethods(_) async {
+    _realClass
+      ..methodWithoutArgs()
+      ..methodWithNormalArgs(1)
+      ..methodWithListArgs([1, 2])
+      ..methodWithPositionalArgs(1, 2)
+      ..methodWithNamedArgs(1, y: 2)
+      ..methodWithTwoNamedArgs(1, y: 2, z: 3)
+      ..methodWithObjArgs(new RealClass())
+      ..typeParameterizedFn([1, 2], [3, 4], [5, 6], [7, 8])
+      ..typeParameterizedNamedFn([1, 2], [3, 4], y: [5, 6], z: [7, 8])
+      ..getter
+      ..setter = "A";
+  }
+}
+
 abstract class Foo {
   String bar();
 }
@@ -352,6 +381,210 @@ void main() {
     });
   });
 
+  group("untilCalled", () {
+    StreamController<CallMethodsEvent> streamController =
+        new StreamController.broadcast();
+
+    group("on methods already called", () {
+      test("waits for method without args", () async {
+        mock.methodWithoutArgs();
+
+        await untilCalled(mock.methodWithoutArgs());
+
+        verify(mock.methodWithoutArgs()).called(1);
+      });
+
+      test("waits for method with normal args", () async {
+        mock.methodWithNormalArgs(1);
+
+        await untilCalled(mock.methodWithNormalArgs(any));
+
+        verify(mock.methodWithNormalArgs(any)).called(1);
+      });
+
+      test("waits for method with list args", () async {
+        mock.methodWithListArgs([1]);
+
+        await untilCalled(mock.methodWithListArgs(any));
+
+        verify(mock.methodWithListArgs(any)).called(1);
+      });
+
+      test("waits for method with positional args", () async {
+        mock.methodWithPositionalArgs(1, 2);
+
+        await untilCalled(mock.methodWithPositionalArgs(any, any));
+
+        verify(mock.methodWithPositionalArgs(any, any)).called(1);
+      });
+
+      test("waits for method with named args", () async {
+        mock.methodWithNamedArgs(1, y: 2);
+
+        await untilCalled(mock.methodWithNamedArgs(any, y: any));
+
+        verify(mock.methodWithNamedArgs(any, y: any)).called(1);
+      });
+
+      test("waits for method with two named args", () async {
+        mock.methodWithTwoNamedArgs(1, y: 2, z: 3);
+
+        await untilCalled(mock.methodWithTwoNamedArgs(any, y: any, z: any));
+
+        verify(mock.methodWithTwoNamedArgs(any, y: any, z: any)).called(1);
+      });
+
+      test("waits for method with obj args", () async {
+        mock.methodWithObjArgs(new RealClass());
+
+        await untilCalled(mock.methodWithObjArgs(any));
+
+        verify(mock.methodWithObjArgs(any)).called(1);
+      });
+
+      test("waits for function with positional parameters", () async {
+        mock.typeParameterizedFn([1, 2], [3, 4], [5, 6], [7, 8]);
+
+        await untilCalled(mock.typeParameterizedFn(any, any, any, any));
+
+        verify(mock.typeParameterizedFn(any, any, any, any)).called(1);
+      });
+
+      test("waits for function with named parameters", () async {
+        mock.typeParameterizedNamedFn([1, 2], [3, 4], y: [5, 6], z: [7, 8]);
+
+        await untilCalled(
+            mock.typeParameterizedNamedFn(any, any, y: any, z: any));
+
+        verify(mock.typeParameterizedNamedFn(any, any, y: any, z: any))
+            .called(1);
+      });
+
+      test("waits for getter", () async {
+        mock.getter;
+
+        await untilCalled(mock.getter);
+
+        verify(mock.getter).called(1);
+      });
+
+      test("waits for setter", () async {
+        mock.setter = "A";
+
+        await untilCalled(mock.setter = "A");
+
+        verify(mock.setter = "A").called(1);
+      });
+    });
+
+    group("on methods not yet called", () {
+      setUp(() {
+        new RealClassController(mock, streamController);
+      });
+
+      test("waits for method without args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithoutArgs());
+
+        await untilCalled(mock.methodWithoutArgs());
+
+        verify(mock.methodWithoutArgs()).called(1);
+      });
+
+      test("waits for method with normal args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithNormalArgs(any));
+
+        await untilCalled(mock.methodWithNormalArgs(any));
+
+        verify(mock.methodWithNormalArgs(any)).called(1);
+      });
+
+      test("waits for method with list args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithListArgs(any));
+
+        await untilCalled(mock.methodWithListArgs(any));
+
+        verify(mock.methodWithListArgs(any)).called(1);
+      });
+
+      test("waits for method with positional args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithPositionalArgs(any, any));
+
+        await untilCalled(mock.methodWithPositionalArgs(any, any));
+
+        verify(mock.methodWithPositionalArgs(any, any)).called(1);
+      });
+
+      test("waits for method with named args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithNamedArgs(any, y: any));
+
+        await untilCalled(mock.methodWithNamedArgs(any, y: any));
+
+        verify(mock.methodWithNamedArgs(any, y: any)).called(1);
+      });
+
+      test("waits for method with two named args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithTwoNamedArgs(any, y: any, z: any));
+
+        await untilCalled(mock.methodWithTwoNamedArgs(any, y: any, z: any));
+
+        verify(mock.methodWithTwoNamedArgs(any, y: any, z: any)).called(1);
+      });
+
+      test("waits for method with obj args", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithObjArgs(any));
+
+        await untilCalled(mock.methodWithObjArgs(any));
+
+        verify(mock.methodWithObjArgs(any)).called(1);
+      });
+
+      test("waits for function with positional parameters", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.typeParameterizedFn(any, any, any, any));
+
+        await untilCalled(mock.typeParameterizedFn(any, any, any, any));
+
+        verify(mock.typeParameterizedFn(any, any, any, any)).called(1);
+      });
+
+      test("waits for function with named parameters", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.typeParameterizedNamedFn(any, any, y: any, z: any));
+
+        await untilCalled(
+            mock.typeParameterizedNamedFn(any, any, y: any, z: any));
+
+        verify(mock.typeParameterizedNamedFn(any, any, y: any, z: any))
+            .called(1);
+      });
+
+      test("waits for getter", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.getter);
+
+        await untilCalled(mock.getter);
+
+        verify(mock.getter).called(1);
+      });
+
+      test("waits for setter", () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.setter = "A");
+
+        await untilCalled(mock.setter = "A");
+
+        verify(mock.setter = "A").called(1);
+      });
+    });
+  });
+
   group("verify()", () {
     test("should verify method without args", () {
       mock.methodWithoutArgs();