推荐轻量友好的.NET测试断言工具Shouldly

Shouldly是一个轻量的断言（Assertion）框架，用于补充.NET框架下的测试工具。Shouldly将焦点放在当断言失败时如何简单精准的给出很好的错误信息。

Shouldly在GitHub的开源地址：https://github.com/shouldly/shouldly

Shouldly的官方文档：http://docs.shouldly-lib.net/

为什么要Shouldly？

我们知道通常测试代码中一个断言是这样写的：

Assert.That(contestant.Points, Is.EqualTo(1337));

当断言失败的时候，我们会得到这样的信息：

Expected 1337 but was 0

这样的信息让人烦恼的是，它够简练，但显然信息不够充分，可读性不高。

Shouldly充分利用了.NET框架的扩展方法，提供了更友好的处理方式。

用Shouldly编写的断言是这样的：

contestant.Points.ShouldBe(1337);

其中ShouldBe是一个扩展方法，也可以认为是一个易于理解的语法词汇。当断言失败的时候，我们会得到这样的信息：

contestant.Points should be 1337 but was 0

Shouldly的优势

下面的一个例子将两种断言方式放在一起，通过对比更容易发现Shouldly的好处：

Assert.That(map.IndexOfValue("boo"), Is.EqualTo(2));   // -> Expected 2 but was 1
map.IndexOfValue("boo").ShouldBe(2);                   // -> map.IndexOfValue("boo") should be 2 but was 1

Shouldly使用ShouldBe语句中的变量来报告错误，这使得更容易诊断。

另一个例子，如果你需要比较两个集合，采用Shouldly写法如下：

(new[] { 1, 2, 3 }).ShouldBe(new[] { 1, 2, 4 });

显然断言会失败，因为这两个集合并不相同。但Shouldly不仅如此，它会告诉你两个集合的差异所在：

should be
[1, 2, 4]
    but was
[1, 2, 3]
    difference
[1, 2, *3*]

如果你想检查一个特殊的方法调用，它会或者不会抛出异常，它可以简单地这样写：

Should.Throw<ArgumentOutOfRangeException>(() => widget.Twist(-1));

这样就可以接触到异常，借此帮助你调试出潜在的异常来源。

详细用法

Shouldly断言框架提供了相等、迭代、动态变量、字符串、字典、任务/异步，以及异常等多方面的支持。要详细的了解这些可以访问Shouldly的官方文档：http://docs.shouldly-lib.net/

后续的断言例子基于下面的范例类：

namespace Simpsons
{
    public abstract class Pet
    {
        public abstract string Name { get; set; }

        public override string ToString()
        {
            return Name;
        }
    }
}

namespace Simpsons
{
    public class Cat : Pet
    {
        public override string Name { get; set; }
    }
}

namespace Simpsons
{
    public class Dog : Pet
    {
        public override string Name { get; set; }
    }
}

namespace Simpsons
{
    public class Person
    {
        public string Name { get; set; }
        public int Salary { get; set; }


        public override string ToString()
        {
            return Name;
        }
    }
}

Equality 相等

ShouldBe

[Test]
public void ShouldBe()
{
    var theSimpsonsCat = new Cat() { Name = "Santas little helper" };
    theSimpsonsCat.Name.ShouldBe("Snowball 2");
}

失败信息：

Shouldly.ChuckedAWobbly : 
    theSimpsonsCat.Name
        should be
    "Snowball 2"
        but was
    "Santas little helper"

ShouldNotBe

[Test]
public void ShouldNotBe()
{
    var theSimpsonsCat = new Cat() { Name = "Santas little helper" };
    theSimpsonsCat.Name.ShouldNotBe("Santas little helper");
}

失败信息：

Shouldly.ChuckedAWobbly : 
    theSimpsonsCat.Name
        should not be
    "Santas little helper"
        but was
    "Santas little helper"

ShouldBeOfType

[Test]
public void ShouldBeOfType()
{
    var theSimpsonsDog = new Cat() { Name = "Santas little helper" };
    theSimpsonsDog.ShouldBeOfType<Dog>();
}

失败信息：

Shouldly.ChuckedAWobbly : 
    theSimpsonsDog
        should be of type
    Simpsons.Dog
        but was
    Simpsons.Cat

Enumberable 迭代

用于对列表集合进行断言

ShouldAllBe

[Test]
public void IEnumerable_ShouldAllBe_Predicate()
{
    var mrBurns = new Person() { Name = "Mr.Burns", Salary=3000000};
    var kentBrockman = new Person() { Name = "Homer", Salary = 3000000};
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var millionares = new List<Person>() {mrBurns, kentBrockman, homer};

    millionares.ShouldAllBe(m => m.Salary > 1000000);
}

 失败信息：

Shouldly.ChuckedAWobbly : 
    millionares
        should all be an element satisfying the condition
    (m.Salary > 1000000)
        but does not

ShouldContain

[Test]
public void IEnumerable_ShouldContain()
{
    var mrBurns = new Person() { Name = "Mr.Burns", Salary=3000000};
    var kentBrockman = new Person() { Name = "Homer", Salary = 3000000};
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var millionares = new List<Person>() {kentBrockman, homer};

    millionares.ShouldContain(mrBurns);
}

失败信息：

Shouldly.ShouldAssertException : 
    millionares
        should contain
    Mr.Burns
        but does not

ShouldContain(Predicate)

[Test]
public void IEnumerable_ShouldContain_Predicate()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var moe = new Person() { Name = "Moe", Salary=20000};
    var barney = new Person() { Name = "Barney", Salary = 0};
    var millionares = new List<Person>() {homer, moe, barney};

    // Check if at least one element in the IEnumerable satisfies the predicate
    millionares.ShouldContain(m => m.Salary > 1000000);
}

失败信息：

Shouldly.ChuckedAWobbly : 
    millionares
        should contain an element satisfying the condition
    (m.Salary > 1000000)
        but does not

Dynamic 动态对象

ShouldHaveProperty

[Test]
public void DynamicShouldHavePropertyTest()
{
    var homerThinkingLikeFlanders = new ExpandoObject();
    DynamicShould.HaveProperty(homerThinkingLikeFlanders, "IAmABigFourEyedLameO");
}

失败信息：

Shouldly.ChuckedAWobbly : 
    Dynamic Object
        "homerThinkingLikeFlanders"
    should contain property
                 "IAmABigFourEyedLameO"
        but does not.

String 字符串

ShouldMatch

[Test]
public void ShouldMatch()
{
    var simpsonDog = new Dog() { Name = "Santas little helper" };
    simpsonDog.Name.ShouldMatch("Santas [lL]ittle Helper");
}

失败信息：

Shouldly.ChuckedAWobbly : 
    simpsonDog.Name
        should match
    "Santas [lL]ittle Helper"
        but was
    "Santas little helper"

ShouldBeNullOrEmpty

[Test]
public void ShouldBeNullOrEmpty()
{
    var anonymousClanOfSlackJawedTroglodytes = new Person() {Name = "The Simpsons"};
    anonymousClanOfSlackJawedTroglodytes.Name.ShouldBeNullOrEmpty();
}

失败信息：

Shouldly.ChuckedAWobbly : 
    anonymousClanOfSlackJawedTroglodytes.Name
            should be null or empty

Dictionary 字典

ShouldNotContainKey

[Test]
public void ShouldNotContainKey()
{
    var websters = new Dictionary<string, string>();
    websters.Add("Chazzwazzers", "What Australians would have called a bull frog.");

    websters.ShouldNotContainKey("Chazzwazzers");
}

失败信息：

Shouldly.ChuckedAWobbly : 
Dictionary
    "websters"
should not contain key
            "Chazzwazzers"
but does

ShouldContainKeyAndValue

[Test]
public void ShouldNotContainKey()
{
    var websters = new Dictionary<string, string>();
    websters.Add("Chazzwazzers", "What Australians would have called a bull frog.");

    websters.ShouldNotContainKey("Chazzwazzers");
}

失败信息：

Shouldly.ChuckedAWobbly : 
Dictionary
    "websters"
should not contain key
            "Chazzwazzers"
but does

Task/Async 任务/异步

CompleteIn

[Test]
public void CompleteIn()
{
    var homer = new Person() { Name = "Homer", Salary = 30000 };
    var denominator = 1;
    Should.CompleteIn(() =>
    {
        Thread.Sleep(2000);
        var y = homer.Salary / denominator;
    }, TimeSpan.FromSeconds(1));
}

失败信息：

System.TimeoutException : The operation has timed out.

Exceptions 异常

ShouldThrow

[Test]
public void ShouldThrowFuncOfTask()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var denominator = 1;
    Should.Throw<DivideByZeroException>(() =>
    {
        var task = Task.Factory.StartNew(() => { var y = homer.Salary/denominator; });
        return task;
    });
}

失败信息：

Shouldly.ChuckedAWobbly : 
    Should
        throw 
    System.DivideByZeroException
        but does not

ShouldNotThrow(Func<Task>)

这个方法支持异步方法，并且会等待操作执行直到完成。

[Test]
public void ShouldNotThrowFuncOfTask()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var denominator = 0;
    Should.NotThrow(() =>
    {
        var task = Task.Factory.StartNew(() => { var y = homer.Salary/denominator; });
        return task;
    });
}

失败信息：

Shouldly.ChuckedAWobbly : 
    Should
        not throw 
    System.DivideByZeroException
        but does