使用Dart嘲笑 - 如何测试作为参数传递的函数被调用？ [英] Mocking with Dart - How to test that a function passed as a parameter was called?

问题描述

诚然，这是一个奇怪的测试用例，但这是一个问题，我跑到。我有一个类，它接受一个函数作为参数在它的构造函数。我想知道传递的函数是否被调用。这里有一个例子：

  class TestClassMock extends Mock implements RealClass {
 RealClass _ 
 
 TestClassMock（）{
 _real = new RealClass（）; 
 
 when（callsTo（myNamedFunction））。alwaysCall（_real.myNamedFunction）; 
} 
} 
 
 class RealClass {
 String _name =RealClass; 
函数myNamedFunction; 
 
 RealClass（）{
 myNamedFunction = _theNamedFunction; 
} 
 
 String _theNamedFunction（）{
 return _name; 
} 
} 
 
 class ClassThatCallsRealClass {
 ClassThatCallsRealClass（function func）{
 func（）; 
} 
} 
 
 //测试
 TestClassMock testClassMock = new TestClassMock（）; 
 ClassThatCallsRealClass caller = new ClassThatCallsRealClass（testClassMock.myNamedFunction）; 
 testClassMock.getLogs（callsTo（myNamedFunction））。verify（happenedOnce）; 
  

因此，为了说明一点，ClassThatCallsRealClass接受一个函数作为参数并调用它。如果你要传入（RealClass的实例）.myNamedFunction，这将调用RealClass上的私有函数_theNamedFunction。但是，如果您尝试模拟RealClass并将所有调用从myNamedFunction重定向到RealClass myNamedFunction，这似乎失败。

有什么想法吗？

我不知道有什么办法可以让这个工作，但我认为这是可能的。 解决方案

在Dart中，所有的函数都是 Function 类的实例，因为你传递一个函数到 ClassThatCallsRealClass 构造函数。 Function 的实例有一个方法 call（），如下所示这里。

嘲笑功能此处。

所以你需要做的就是像任何其他对象一样测试嘲笑。正如引用中所述，为 ClassThatCallsRealClass 创建一个间谍，并为您的 Function 实例创建一个模拟。然后在函数的 call（）方法上使用验证（happensOnce）。

要模拟你的函数，请这样做：

  class MockFunction extends Mock {
 call int a，int b）=> a + b; 
} 
 
 var mock = new MockFunction（）; 
 mock（1,2）; //返回3 
  

当然，参数列表为 call 将匹配真正的函数。将 mock 传送给您的间谍 ClassThatCallsRealClass 。

Admittedly, this is a little bit of an odd test case, but it's a problem I've ran in to. I have a class that takes a function as a parameter in it's constructor. I'd like to know if the function that was passed was called. Here's an example:

class TestClassMock extends Mock implements RealClass {
  RealClass _real;

  TestClassMock() {
    _real = new RealClass();

    when(callsTo("myNamedFunction")).alwaysCall(_real.myNamedFunction);
  }
}

class RealClass {
  String _name = "RealClass";
  Function myNamedFunction;

  RealClass() {
    myNamedFunction = _theNamedFunction;
  }

  String _theNamedFunction() {
    return _name;
  }
}

class ClassThatCallsRealClass {
  ClassThatCallsRealClass(Function func) {
    func();
  }
}

//The test
TestClassMock testClassMock = new TestClassMock();
ClassThatCallsRealClass caller = new ClassThatCallsRealClass(testClassMock.myNamedFunction);  
testClassMock.getLogs(callsTo("myNamedFunction")).verify(happenedOnce);

So to explain a bit, ClassThatCallsRealClass takes a function as a parameter and calls it. If you were to pass in (Instance Of RealClass).myNamedFunction, this would in turn call the private function _theNamedFunction on RealClass. However, if you try to mock RealClass and redirect all calls from myNamedFunction to the RealClass myNamedFunction, this seems to fail. I don't see any clear way to get this to work, but I would think it'd be possible.

Any ideas?

解决方案

In Dart, all functions are instances of class Function as you know since you pass an instance of Function to the ClassThatCallsRealClass constructor. Instances of Function have a method call() as shown here.

Meanwhile, Dart has a very good mocking capability described here.

So all you need to do is test with mocks like with any other object. Just as described in the reference, create a spy for ClassThatCallsRealClass and a mock for your Function instance. Then use a verify(happenedOnce) on the call() method of the function.

To mock your function do this:

class MockFunction extends Mock {
  call(int a, int b) => a + b;
}

var mock = new MockFunction();
mock(1,2); //returns 3

Of course the parameter list to call will match that of the real function. Pass mock to your spy on ClassThatCallsRealClass.

这篇关于使用Dart嘲笑 - 如何测试作为参数传递的函数被调用？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！