推荐轻量友好的.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());

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

Expected  but was 

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

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

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

contestant.Points.ShouldBe();

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

contestant.Points should be  but was 

Shouldly的优势

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

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

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

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

(new[] { , ,  }).ShouldBe(new[] { , ,  });

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

should be
[, , ]
    but was
[, , ]
    difference
[, , **]

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

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

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

详细用法

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=};
     var kentBrockman = new Person() { Name = "Homer", Salary = };
     var homer = new Person() { Name = "Homer", Salary = };
     var millionares = new List<Person>() {mrBurns, kentBrockman, homer};

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

失败信息：

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

ShouldContain

 [Test]
 public void IEnumerable_ShouldContain()
 {
     var mrBurns = new Person() { Name = "Mr.Burns", Salary=};
     var kentBrockman = new Person() { Name = "Homer", Salary = };
     var homer = new Person() { Name = "Homer", Salary = };
     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 = };
     var moe = new Person() { Name = "Moe", Salary=};
     var barney = new Person() { Name = "Barney", Salary = };
     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 > );
 }

失败信息：

Shouldly.ChuckedAWobbly :
    millionares
        should contain an element satisfying the condition
    (m.Salary > )
        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 =  };
     var denominator = ;
     Should.CompleteIn(() =>
     {
         Thread.Sleep();
         var y = homer.Salary / denominator;
     }, TimeSpan.FromSeconds());
 }

失败信息：

System.TimeoutException : The operation has timed out.

Exceptions 异常

ShouldThrow

 [Test]
 public void ShouldThrowFuncOfTask()
 {
     var homer = new Person() { Name = "Homer", Salary = };
     var denominator = ;
     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 = };
     var denominator = ;
     Should.NotThrow(() =>
     {
         var task = Task.Factory.StartNew(() => { var y = homer.Salary/denominator; });
         return task;
     });
 }

失败信息：

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