moq 的常用使用方法(推荐)

moq，就是mock you。读音可以读成mock~you。是mock框架的一种。用于测试中的mock测试。mock是模拟的意思。mock是模拟对象的一种技术。

测试方法

// 准备 mock ifoo 接口
var mock = new mock<ifoo>(); 
// 配置准备模拟的方法，当调用接口中的 dosomething 方法，并传递参数 "bing" 的时候，返回 true
mock.setup(foo => foo.dosomething("ping")).returns(true); 
// 方法的参数中使用了 out 参数
// out arguments 
var outstring = "ack"; 
// 当调用 tryparse 方法的时候，out 参数返回 "ack", 方法返回 true, lazy evaluated 
mock.setup(foo => foo.tryparse("ping", out outstring)).returns(true); 
// ref 参数
var instance = new bar(); 
// 仅仅在使用 ref 调用的时候，才会匹配下面的测试
mock.setup(foo => foo.submit(ref instance)).returns(true); 
// 当方法返回值得时候，还可以访问返回的值
// 这里可以使用多个参数
mock.setup(x => x.dosomething(it.isany<string>()))
.returns((string s) => s.tolower()); 
// 在被调用的时候抛出异常
mock.setup(foo => foo.dosomething("reset")).throws<invalidoperationexception>(); 
mock.setup(foo => foo.dosomething("")).throws(new argumentexception("command"); 
// 延迟计算返回的结果 
mock.setup(foo => foo.getcount()).returns(() => count); 
// 在每一次调用的时候，返回不同的值 
var mock = new mock<ifoo>(); 
var calls = 0; 
mock.setup(foo => foo.getcountthing())
.returns(() => calls)
.callback(() => calls++); 
// 第一次调用返回 0， 下一次是 1， 依次类推
console.writeline(mock.object.getcountthing());

匹配参数

// 任意值 
mock.setup(foo => foo.dosomething(it.isany<string>())).returns(true); 
// 提供的值必须匹配一个函数, lazy evaluated 
mock.setup(foo => foo.add(it.is<int>(i => i % 2 == 0))).returns(true); 
// 匹配一个范围 
mock.setup(foo => foo.add(it.isinrange<int>(0, 10, range.inclusive))).returns(true); 
// 匹配正则表达式
mock.setup(x => x.dosomething(it.isregex("[a-d]+", regexoptions.ignorecase))).returns("foo");

属性

// 普通属性
mock.setup(foo => foo.name).returns("bar"); 
// 多层的属性
mock.setup(foo => foo.bar.baz.name).returns("baz"); 
// 期望设置属性的值为 "foo" 
mock.setupset(foo => foo.name = "foo"); 
// 或者直接验证赋值 
mock.verifyset(foo => foo.name = "foo");

设置属性，以便自动跟踪它的值

// 开始 "tracking" 属性的 sets/gets 
mock.setupproperty(f => f.name); 
// 提供一个默认的值
mock.setupproperty(f => f.name, "foo"); 
// 现在，你可以: 
ifoo foo = mock.object; 
// 保存的值 
assert.equal("foo", foo.name); 
// 重新设置一个值
foo.name = "bar"; 
assert.equal("bar", foo.name);

还可以准备所有的属性

mock.setupallproperties();

事件

// 抛出一个事件 
mock.raise(m => m.fooevent += null, new fooeventargs(foovalue)); 
// 多层的后代中的事件 
mock.raise(m => m.child.first.fooevent += null, new fooeventargs(foovalue)); 
// 当 submit 方法被调用的时候，抛出一个事件 
mock.setup(foo => foo.submit()).raises(f => f.sent += null, eventargs.empty); 
// 抛出异常将会触发对象底层的行为
// 你可能需要在后面进行断言处理
// 抛出一个自定义的事件
public delegate void myeventhandler(int i, bool b); 
public interface ifoo { event myeventhandler myevent; } 
var mock = new mock<ifoo>(); 
... 
// 传递自定义的事件参数
mock.raise(foo => foo.myevent += null, 25, true);

回调

var mock = new mock<ifoo>(); 
mock.setup(foo => foo.execute("ping"))
.returns(true)
.callback(() => calls++); 
// 使用调用的参数 
mock.setup(foo => foo.execute(it.isany<string>()))
.returns(true)
.callback((string s) => calls.add(s)); 
// 使用泛型语法 
mock.setup(foo => foo.execute(it.isany<string>()))
.returns(true)
.callback<string>(s => calls.add(s)); 
// 使用多个参数
mock.setup(foo => foo.execute(it.isany<int>(), it.isany<string>()))
.returns(true)
.callback<int, string>((i, s) => calls.add(s)); 
// 调用之前和之后的回调 
mock.setup(foo => foo.execute("ping"))
.callback(() => console.writeline("before returns"))
.returns(true)
.callback(() => console.writeline("after returns"));

验证

mock.verify(foo => foo.execute("ping")); 
// 在验证失败的时候，提供自定义的错误提示信息 
mock.verify(foo => foo.execute("ping"), "when doing operation x, the service should be pinged always"); 
// 从没有被调用的方法 
mock.verify(foo => foo.execute("ping"), times.never()); 
// 至少调用过一次 
mock.verify(foo => foo.execute("ping"), times.atleastonce()); 
mock.verifyget(foo => foo.name); 
// 验证对属性的赋值. 
mock.verifyset(foo => foo.name); 
// 验证对于属性设置特定的值 
mock.verifyset(foo => foo.name ="foo"); 
// 验证匹配的参数 
mock.verifyset(foo => foo.value = it.isinrange(1, 5, range.inclusive));

自定义 mock 行为

mock 的行为分为严格的 strict 和宽松的 loose， 默认为宽松的。在严格模式下，使用任何没有被指定的行为，都将会抛出异常，宽松模式下，不会抛出任何异常，方法将会返回默认值或者空的数组等等。

var mock = new mock<ifoo>(mockbehavior.strict);

如果没有重写基类的实现，默认将不会调用基类，在 mock web/html 控件的是必须的。

var mock = new mock<ifoo> { callbase = true };

创造自动递归的 mock, mock 对象对于它的任何成员将会返回一个新的 mock 对象。

var mock = new mock<ifoo> { defaultvalue = defaultvalue.mock }; 
// 默认是 defaultvalue.empty 
// 现在这个属性将会返回一个新的 mock 对象 
ibar value = mock.object.bar; 
// 可以使用返回的 mock 对象, 后即对属性的访问返回相同的对象实例
// 这就允许我们可以进行后继的设置 
// set further expectations on it if we want 
var barmock = mock.get(value); 
barmock.setup(b => b.submit()).returns(true);

中心化的 mock 实例创建和管理：你可以在一个地方使用 mockrepository 创建和验证所有的 mock 对象，设置 mockbehavior, callbse 和 defaultvalue 约束。

var factory = new mockfactory(mockbehavior.strict) { defaultvalue = defaultvalue.mock }; 
// 创建 mock 对象
var foomock = factory.create<ifoo>(); 
// 在创建的时候重写仓库的设置 
var barmock = factory.create<ibar>(mockbehavior.loose); 
// 验证通过仓库创建的对象 
factory.verify();

其它

// 用在测试用例的开始 
using moq.protected() 
// 测试中
var mock = new mock<commandbase>(); mock.protected()
.setup<int>("execute")
.returns(5); 
// 如果用到了参数匹配, 必须使用 itexpr 来代替 it 
// 以后计划改进
mock.protected()
.setup<string>("execute", itexpr.isany<string>())
.returns(true);

高级特性

// 从 mock 实例重新获得 mock 对象
ifoo foo = // get mock instance somehow 
var foomock = mock.get(foo); 
foomock.setup(f => f.submit()).returns(true); 
// 实现多个接口 
var foo = new mock<ifoo>(); 
var disposablefoo = foo.as<idisposable>(); 
// 现在 ifoo mock 已经实现了接口 idisposable :) disposablefoo.setup(df => df.dispose()); 
// 定制匹配 
mock.setup(foo => foo.submit(islarge())).throws<argumentexception>(); ... 
public string islarge() 
{
return match<string>.create(s => !string.isnullorempty(s) && s.length > 100); 
}

以上所述是小编给大家介绍的moq 的常用使用方法，希望对大家有所帮助