Fluent Assertions Dicctionary

您也可以将 Fluent Assertions 应用于通用dictionary。 当然，您可以断言任何字典为空或不为空，为空或不为空。 像这样：

using FluentAssertions;
using System.Collections.Generic;
using Xunit;
namespace MyFirstUnitTests
{
    public class MyTestClass
    {
        [Fact]
        public void Test_Example1()
        {
            Dictionary<int, string> dictionary = null;
            dictionary.Should().BeNull();

            dictionary = new Dictionary<int, string>();
            dictionary.Should().NotBeNull(); //不为null
            dictionary.Should().BeEmpty(); //是空集合
            dictionary.Add(1, "first element");
            dictionary.Should().NotBeEmpty(); //不为空
        }
    }
}

同样也可以用Equal来断言

 [Fact]
public void Test_Example2()
{
    var dictionary1 = new Dictionary<int, string>
    {
        { 1, "One" },
        { 2, "Two" }
    };

    var dictionary2 = new Dictionary<int, string>
    {
        { 1, "One" },
        { 2, "Two" }
    };

    var dictionary3 = new Dictionary<int, string>
    {
        { 3, "Three" },
    };

    dictionary1.Should().Equal(dictionary2); // 两个字典是不是相等， 因为字典的元素一样 断言成功
    dictionary1.Should().NotEqual(dictionary3);// 两个字典不一样，断言成功
}

如果上面的value是一个引用类型的对象，用Equal是不行的，代码如下

 public class MyTestClass
    {
        [Fact]
        public void Test_Example3()
        {
            var dictionary1 = new Dictionary<int, Student>
            {
                { 1, "One" },
                { 2, "Two" }
            };

            var dictionary2 = new Dictionary<int, Student>
            {
                { 1, "One" },
                { 2, "Two" }
            };

            dictionary1.Should().Equal(dictionary2);//会出错 因为 Student不相等，我们没有云重写 Equals方法
        }

    }

    public class Student
    { 
        public string Name { get; set; }
        // 这边进行了隐式转换符的重载
        public static implicit operator Student(string value)
        {
            return new Student()
            {
                Name = value
            };
        }
    }

//如果我们在这边有重写了 Equals方法。则上面的单元测试就会成功了
    //   public override bool Equals(object obj)
    //     {
    //         var theOther = (Student)obj;
    //         return theOther.Name.Equals(this.Name);
    //     }

同样我们也可断言这个dictionary是不是含有某些key或者某些value

[Fact]
public void Test_Example4()
{
    var dictionary = new Dictionary<int, string>
    {
        { 1, "One" },
        { 2, "Two" }
    };

    dictionary.Should().ContainKey(1); //含有 key 1
    dictionary.Should().ContainKeys(1, 2); // 含有 key 1,2
    dictionary.Should().NotContainKey(9); //不含有 key 9
    dictionary.Should().NotContainKeys(9, 10);
    dictionary.Should().ContainValue("One"); //含有 值 one
    dictionary.Should().ContainValues("One", "Two");
    dictionary.Should().NotContainValue("Nine");
    dictionary.Should().NotContainValues("Nine", "Ten"); //含有 值 Nine Ten
}

我们也可以直接断言键值对

[Fact]
public void Test_Example5()
{
    var item1 = new KeyValuePair<int, string>(1, "One");
    var item2 = new KeyValuePair<int, string>(2, "Two");
    var dictionary = new Dictionary<int, string>
    {
        { 1, "One" },
        { 2, "Two" }
    };

    dictionary.Should().Contain(item1);
    dictionary.Should().Contain(item1, item2);
    dictionary.Should().Contain(2, "Two");
    //dictionary.Should().NotContain(item1);//出错
    //dictionary.Should().NotContain(item1, item2);//出错
    dictionary.Should().NotContain(9, "Nine");
}

还支持链接其他断言。

 public class MyTestClass
    {
        [Fact]
        public void Test_Example1()
        {
            var dictionary = new Dictionary<int, Student>
            {
                { 1, "One" },
                { 2, "Two" }
            };

            dictionary.Should().ContainValue(dictionary[1])
                .Which.Name.Should().Be("One");
        }

    }

    public class Student
    { 
        public string Name { get; set; }
        public static implicit operator Student(string value)
        {
            return new Student()
            {
                Name = value
            };
        }
    }