Discussion: returns stub instead of null for first class citizen member function about mockito

[TedSander]

Sorry but we specifically changed this because of Strong mode. When you return a Type that is not the value you are specifying at the return type you are specifically breaking the type contract. Null is fine because null is all types.

[srawlins]

@TedSander I think you're mixing up the issue. It's about noSuchMethod returning null, not any returning null.

[srawlins]

@lestathc Doesn't this work? when(mockObj.foo).thenReturn(() { /* your stub */});

import 'package:test/test.dart';
import 'package:mockito/mockito.dart';

class HasFoo {
  void foo() {
    print('hey');
  }
}

class MockHasFoo extends Mock implements HasFoo {}

willCallCallback(void callback()) {
  callback();
}

void main() {
  var mhf = new MockHasFoo();
  test('hey', () {
    var called = false;
    when(mhf.foo).thenReturn(() {
      called = true;
    });
    willCallCallback(mhf.foo);
    expect(called, isTrue);
  });
}

[TedSander]

Sorry my mistake

[lestathc]

@srawlins

Yes, that works, but it is similar like my last test in my full example. Ideally, I want to write it simply like:

  var mhf = new MockHasFoo();
  test('hey', () {
    willCallCallback(mhf.foo);
    verify(mhf.foo());
  });

I have written a simple piece of code which may achieve it. But I am not sure whether it breaks strong mode (I even don't know whether strong mode works in dartpad).

@MirrorsUsed(symbols: 'foo, call')
import 'dart:mirrors';

class HasFoo {
  void foo() {}
}

var _verificationInProgress = false;

get verify => _makeVerify();

_makeVerify() {
  _verificationInProgress = true;
  return (FunctionGetterStub stub) {
     _verificationInProgress = false;
     stub.verify();
  };
}

class FunctionGetterStub {
  bool _verified = false;
  bool _invoked = false;
  invoke(Invocation inv) {
    _invoked = true;
    return '123';
  }
  verify() {
    if (_verified) throw 'vefiied';
    if (!_invoked) throw 'not invoked';
    _verified = true;
  }
  
  noSuchMethod(Invocation inv) => invoke(inv);
}

class MockHasFoo implements HasFoo {
  Map<Symbol, FunctionGetterStub> _funcToStub = {};
  
  FunctionGetterStub _createOrGetStub(Symbol symbol) {
    var stub = _funcToStub[symbol];
    if (stub == null) {
      stub = new FunctionGetterStub();
      _funcToStub[symbol] = stub;
    }
    return stub;
  }
  
  noSuchMethod(Invocation inv) {
    var stub = _createOrGetStub(inv.memberName);
    if (inv.isGetter /* and is getter for func */ || _verificationInProgress) {
      return stub;
    } else {
      return stub.invoke(inv);
    }
  }
}

void test1() {
  print('==== test 1 ====');
  var mock = new MockHasFoo();
  print('Getter: ${mock.foo}');
  print('Function: ${mock.foo()}');
  verify(mock.foo());
  print('pass!');
}

void test2() {
  print('==== test 2 ====');
  
  willCallCallback(void callback()) {
    callback();
  }
  
  var mock = new MockHasFoo();
  willCallCallback(mock.foo);
  verify(mock.foo());
  print('pass!');
}

void main() {
  test1();
  test2();
}

But the first thing is to decide whether we need to do it.

Thanks

[srawlins]

Unfortunately, In Dart 2 tear offs with noSuchMethod don't play well to allow this. See #107 for more info.