Add strong mode-compliant 'typed' API

Author: srawlins

README.md

@@ -126,11 +126,11 @@ verifyNoMoreInteractions(cat);
 ```dart
 //simple capture
 cat.eatFood("Fish");
-expect(verify(cat.eatFood(capture)).captured.single, "Fish");
+expect(verify(cat.eatFood(captureAny)).captured.single, "Fish");
 //capture multiple calls
 cat.eatFood("Milk");
 cat.eatFood("Fish");
-expect(verify(cat.eatFood(capture)).captured, ["Milk", "Fish"]);
+expect(verify(cat.eatFood(captureAny)).captured, ["Milk", "Fish"]);
 //conditional capture
 cat.eatFood("Milk");
 cat.eatFood("Fish");
@@ -147,6 +147,77 @@ expect(cat.sound(), "Purr");
 //using real object
 expect(cat.lives, 9);   
 ```
+
+## Strong mode compliance
+
+Unfortunately, the use of the arg matchers in mock method calls (like `cat.eatFood(any)`)
+violates the Strong mode type system. Specifically, if the method signature of a mocked
+method has a parameter with a parameterized type (like `List<int>`), then passing `any` or
+`argThat` will result in a Strong mode warning:
+
+> [warning] Unsound implicit cast from dynamic to List<int>
+
+In order to write Strong mode-compliant tests with Mockito, you might need to use `typed`,
+annotating it with a type parameter comment. Let's use a slightly different `Cat` class to
+show some examples:
+
+```dart
+class Cat {
+  bool eatFood(List<String> foods, [List<String> mixins]) => true;
+  int walk(List<String> places, {Map<String, String> gaits}) => 0;
+}
+
+class MockCat extends Mock implements Cat {}
+
+var cat = new MockCat();
+```
+
+OK, what if we try to stub using `any`:
+
+```dart
+when(cat.eatFood(any)).thenReturn(true);
+```
+
+Let's analyze this code:
+
+```
+$ dartanalyzer --strong test/cat_test.dart
+Analyzing [lib/cat_test.dart]...
+[warning] Unsound implicit cast from dynamic to List<String> (test/cat_test.dart, line 12, col 20)
+1 warning found.
+```
+
+This code is not Strong mode-compliant. Let's change it to use `typed`:
+
+```dart
+when(cat.eatFood(typed/*<List<String>>*/(any)))
+```
+
+```
+$ dartanalyzer --strong test/cat_test.dart
+Analyzing [lib/cat_test.dart]...
+No issues found
+```
+
+Great! A little ugly, but it works. Here are some more examples:
+
+```dart
+when(cat.eatFood(typed/*<List<String>>*/(any), typed/*<List<String>>*/(any)))
+    .thenReturn(true);
+when(cat.eatFood(typed/*<List<String>>*/(argThat(isEmpty)))).thenReturn(true);
+```
+
+Named args require one more component: `typed` needs to know what named argument it is
+being passed into:
+
+```dart
+when(cat.walk(
+    typed/*<List<String>>*/(any),
+    gaits: typed/*<Map<String, String>>*/(any), name: 'gaits')).thenReturn(true);
+```
+
+Note the `name` argument.
+
 ## How it works
 The basics of the `Mock` class are nothing special: It uses `noSuchMethod` to catch
 all method invocations, and returns the value that you have configured beforehand with

lib/mockito.dart

@@ -11,6 +11,8 @@ _WhenCall _whenCall = null;
 final List<_VerifyCall> _verifyCalls = <_VerifyCall>[];
 final _TimeStampProvider _timer = new _TimeStampProvider();
 final List _capturedArgs = [];
+final List<_ArgMatcher> _typedArgs = <_ArgMatcher>[];
+final Map<String, _ArgMatcher> _typedNamedArgs = <String, _ArgMatcher>{};
 
 class Mock {
   final List<RealCall> _realCalls = <RealCall>[];
@@ -25,7 +27,18 @@ class Mock {
 
   dynamic noSuchMethod(Invocation invocation) {
     if (_whenInProgress) {
-      _whenCall = new _WhenCall(this, invocation);
+      if (_typedArgs.isEmpty && _typedNamedArgs.isEmpty) {
+        _whenCall = new _WhenCall(this, invocation);
+      } else {
+        try {
+          _whenCall = new _WhenCall(this, new FakeInvocation(invocation));
+        } catch (e) {
+          print("Boo");
+        } finally {
+          _typedArgs.clear();
+          _typedNamedArgs.clear();
+        }
+      }
       return null;
     } else if (_verificationInProgress) {
       _verifyCalls.add(new _VerifyCall(this, invocation));
@@ -48,6 +61,56 @@ class Mock {
   String toString() => _givenName != null ? _givenName : runtimeType.toString();
 }
 
+class FakeInvocation extends Invocation {
+  final bool isAccessor;
+  final bool isGetter;
+  final bool isMethod;
+  final bool isSetter;
+  final Symbol memberName;
+  final Map<Symbol, dynamic> namedArguments;
+  final List<dynamic> positionalArguments;
+
+  factory FakeInvocation(Invocation invocation) {
+    if (_typedArgs.isEmpty && _typedNamedArgs.isEmpty) {
+      throw 'What?';
+    }
+    var positionalArguments = <_ArgMatcher>[];
+    var namedArguments = <Symbol, dynamic>{};
+    if (_typedArgs.length != invocation.positionalArguments.length) {
+      throw 'All positional args must be typed, but ${_typedArgs.length}, ${invocation.positionalArguments.length}';
+    }
+    _typedArgs.forEach((arg) {
+      positionalArguments.add(arg);
+    });
+
+    // TODO: this can maybe be relaxed.
+    if (_typedNamedArgs.length != invocation.namedArguments.length) {
+      throw 'All named args must be typed';
+    }
+    _typedNamedArgs.forEach((name, arg) {
+      namedArguments[new Symbol(name)] = arg;
+    });
+
+    return new FakeInvocation._(
+        invocation.isAccessor,
+        invocation.isGetter,
+        invocation.isMethod,
+        invocation.isSetter,
+        invocation.memberName,
+        namedArguments,
+        positionalArguments);
+  }
+
+  FakeInvocation._(
+      this.isAccessor,
+      this.isGetter,
+      this.isMethod,
+      this.isSetter,
+      this.memberName,
+      this.namedArguments,
+      this.positionalArguments);
+}
+
 named(var mock, {String name, int hashCode}) => mock
   .._givenName = name
   .._givenHashCode = hashCode;
@@ -291,6 +354,15 @@ get captureAny => new _ArgMatcher(anything, true);
 captureThat(Matcher matcher) => new _ArgMatcher(matcher, true);
 argThat(Matcher matcher) => new _ArgMatcher(matcher, false);
 
+/*=T*/ typed/*<T>*/(_ArgMatcher matcher, {String name}) {
+  if (name == null) {
+    _typedArgs.add(matcher);
+  } else {
+    _typedNamedArgs[name] = matcher;
+  }
+  return null;
+}
+
 class VerificationResult {
   List captured = [];
   int callCount;

test/mockito_test.dart

@@ -9,6 +9,12 @@ class RealClass {
   String methodWithNamedArgs(int x, {int y}) => "Real";
   String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
   String methodWithObjArgs(RealClass x) => "Real";
+  // "SpecialArgs" here means type-parameterized args. But that makes for a long
+  // method name.
+  String methodWithSpecialArgs(List<int> x, [List<int> y]) => "Real";
+  // "SpecialNamedArgs" here means type-parameterized, named args. But that
+  // makes for a long method name.
+  String methodWithSpecialNamedArgs(List<int> x, {List<int> y}) => "Real";
   String get getter => "Real";
   void set setter(String arg) {
     throw new StateError("I must be mocked");
@@ -204,6 +210,24 @@ void main() {
       when(mock.methodWithNormalArgs(argThat(equals(42)))).thenReturn("42");
       expect(mock.methodWithNormalArgs(43), equals("43"));
     });
+    test("should mock method with typed argument matcher", () {
+      when(mock.methodWithSpecialArgs(typed/*<List<int>>*/(any)))
+          .thenReturn("A lot!");
+      expect(mock.methodWithSpecialArgs([42]), equals("A lot!"));
+      expect(mock.methodWithSpecialArgs([43]), equals("A lot!"));
+    });
+    test("should mock method with two typed argument matcher", () {
+      when(mock.methodWithSpecialArgs(
+          typed/*<List<int>>*/(any), typed/*<List<int>>*/(any)))
+          .thenReturn("A lot!");
+      expect(mock.methodWithSpecialArgs([42], [43]), equals("A lot!"));
+    });
+    test("should mock method with named, typed argument matcher", () {
+      when(mock.methodWithSpecialNamedArgs(
+          typed/*<List<int>>*/(any), y: typed/*<List<int>>*/(any, name: 'y')))
+          .thenReturn("A lot!");
+      expect(mock.methodWithSpecialNamedArgs([42], y: [43]), equals("A lot!"));
+    });
   });
 
   group("verify()", () {
@@ -478,7 +502,9 @@ void main() {
     });
     test("should captureOut list arguments", () {
       mock.methodWithListArgs([42]);
-      expect(verify(mock.methodWithListArgs(captureAny)).captured.single, equals([42]));
+      expect(verify(
+          mock.methodWithListArgs(captureAny)).captured.single,
+          equals([42]));
     });
     test("should captureOut multiple arguments", () {
       mock.methodWithPositionalArgs(1, 2);