比较 NUnit 中两个对象之间的相等性

Question

我试图断言一个 object 与另一个 object“相等”。

这些对象只是具有一堆公共属性的 class 的实例。 有没有一种简单的方法可以让 NUnit 根据属性断言相等性？

这是我目前的解决方案，但我认为可能有更好的方法：

Assert.AreEqual(LeftObject.Property1, RightObject.Property1)
Assert.AreEqual(LeftObject.Property2, RightObject.Property2)
Assert.AreEqual(LeftObject.Property3, RightObject.Property3)
...
Assert.AreEqual(LeftObject.PropertyN, RightObject.PropertyN)

我要实现的目标与 CollectionEquivalentConstraint 的精神相同，其中 NUnit 验证两个 collections 的内容是否相同。

Answer 1

不要仅出于测试目的而覆盖 Equals。 它很乏味并且会影响域逻辑。 反而，

使用 JSON 比较对象的数据

您的对象没有额外的逻辑。 没有额外的测试任务。

只需使用这个简单的方法：

public static void AreEqualByJson(object expected, object actual)
{
    var serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
    var expectedJson = serializer.Serialize(expected);
    var actualJson = serializer.Serialize(actual);
    Assert.AreEqual(expectedJson, actualJson);
}

看起来效果很好。 测试运行器结果信息将显示包含的 JSON 字符串比较（对象图），以便您直接查看问题所在。

还要注意！ 如果您有更大的复杂对象并且只想比较它们的一部分，您可以（对序列数据使用 LINQ ）创建匿名对象以与上述方法一起使用。

public void SomeTest()
{
    var expect = new { PropA = 12, PropB = 14 };
    var sut = loc.Resolve<SomeSvc>();
    var bigObjectResult = sut.Execute(); // This will return a big object with loads of properties 
    AssExt.AreEqualByJson(expect, new { bigObjectResult.PropA, bigObjectResult.PropB });
}

Answer 2

如果由于任何原因无法覆盖 Equals，则可以构建一个辅助方法，该方法通过反射遍历公共属性并断言每个属性。 像这样的东西：

public static class AssertEx
{
    public static void PropertyValuesAreEquals(object actual, object expected)
    {
        PropertyInfo[] properties = expected.GetType().GetProperties();
        foreach (PropertyInfo property in properties)
        {
            object expectedValue = property.GetValue(expected, null);
            object actualValue = property.GetValue(actual, null);

            if (actualValue is IList)
                AssertListsAreEquals(property, (IList)actualValue, (IList)expectedValue);
            else if (!Equals(expectedValue, actualValue))
                Assert.Fail("Property {0}.{1} does not match. Expected: {2} but was: {3}", property.DeclaringType.Name, property.Name, expectedValue, actualValue);
        }
    }

    private static void AssertListsAreEquals(PropertyInfo property, IList actualList, IList expectedList)
    {
        if (actualList.Count != expectedList.Count)
            Assert.Fail("Property {0}.{1} does not match. Expected IList containing {2} elements but was IList containing {3} elements", property.PropertyType.Name, property.Name, expectedList.Count, actualList.Count);

        for (int i = 0; i < actualList.Count; i++)
            if (!Equals(actualList[i], expectedList[i]))
                Assert.Fail("Property {0}.{1} does not match. Expected IList with element {1} equals to {2} but was IList with element {1} equals to {3}", property.PropertyType.Name, property.Name, expectedList[i], actualList[i]);
    }
}

Answer 3

试试FluentAssertions库：

dto.Should().BeEquivalentTo(customer) 

它也可以使用 NuGet 安装。

Answer 4

覆盖 .Equals 为您的对象，然后在单元测试中，您可以简单地执行以下操作：

Assert.AreEqual(LeftObject, RightObject);

当然，这可能意味着您只需将所有单独的比较移动到 .Equals 方法，但它允许您对该实现重复使用多个测试，并且如果对象无论如何都应该能够将自己与同级进行比较可能是有意义的。

Answer 5

我不想为了启用测试而覆盖 Equals。 不要忘记，如果您确实覆盖了 Equals，则您确实也应该覆盖 GetHashCode，否则如果您在字典中使用对象，则可能会得到意想不到的结果。

我确实喜欢上面的反射方法，因为它可以满足将来添加属性的需求。

然而，对于快速简单的解决方案，通常最简单的方法是创建一个辅助方法来测试对象是否相等，或者在您对测试保密的类上实现 IEqualityComparer。 使用 IEqualityComparer 解决方案时，您无需担心 GetHashCode 的实现。 例如：

// Sample class.  This would be in your main assembly.
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Unit tests
[TestFixture]
public class PersonTests
{
    private class PersonComparer : IEqualityComparer<Person>
    {
        public bool Equals(Person x, Person y)
        {
            if (x == null && y == null)
            {
                return true;
            }

            if (x == null || y == null)
            {
                return false;
            }

            return (x.Name == y.Name) && (x.Age == y.Age);
        }

        public int GetHashCode(Person obj)
        {
            throw new NotImplementedException();
        }
    }

    [Test]
    public void Test_PersonComparer()
    {
        Person p1 = new Person { Name = "Tom", Age = 20 }; // Control data

        Person p2 = new Person { Name = "Tom", Age = 20 }; // Same as control
        Person p3 = new Person { Name = "Tom", Age = 30 }; // Different age
        Person p4 = new Person { Name = "Bob", Age = 20 }; // Different name.

        Assert.IsTrue(new PersonComparer().Equals(p1, p2), "People have same values");
        Assert.IsFalse(new PersonComparer().Equals(p1, p3), "People have different ages.");
        Assert.IsFalse(new PersonComparer().Equals(p1, p4), "People have different names.");
    }
}

Answer 6

我已经尝试了这里提到的几种方法。 大多数涉及序列化您的对象并进行字符串比较。 虽然超级简单且通常非常有效，但我发现当您遇到失败并报告类似以下内容时，它会有点短：

Expected string length 2326 but was 2342. Strings differ at index 1729.

至少可以说，弄清楚差异在哪里是一件痛苦的事情。

使用 FluentAssertions 的对象图比较（即a.ShouldBeEquivalentTo(b) ），你会得到这个：

Expected property Name to be "Foo" but found "Bar"

那好多了。 立即获取 FluentAssertions ，稍后您会很高兴（如果您对此表示赞同，也请对首次建议 FluentAssertions 的 dkl的回答点赞）。

Answer 7

我同意 ChrisYoxall —— 在你的主代码中实现 Equals 纯粹用于测试目的并不好。

如果您正在实施 Equals 因为某些应用程序逻辑需要它，那么这很好，但要保持纯测试代码不要乱七八糟（检查相同内容以进行测试的语义可能与您的应用程序要求的不同）。

简而言之，将仅用于测试的代码排除在类之外。

对于大多数类，使用反射对属性进行简单的浅层比较应该就足够了，尽管如果您的对象具有复杂的属性，您可能需要递归。 如果遵循引用，请注意循环引用或类似引用。

狡猾

Answer 8

在 NUnit 2.4.2 中添加的属性约束允许一种比 OP 的原始解决方案更具可读性的解决方案，并且它产生更好的失败消息。 它在任何方面都不是通用的，但是如果您不需要为太多类这样做，这是一个非常合适的解决方案。

Assert.That(ActualObject, Has.Property("Prop1").EqualTo(ExpectedObject.Prop1)
                          & Has.Property("Prop2").EqualTo(ExpectedObject.Prop2)
                          & Has.Property("Prop3").EqualTo(ExpectedObject.Prop3)
                          // ...

不像实现Equals那样通用，但它确实提供了比实现Equals更好的失败信息

Assert.AreEqual(ExpectedObject, ActualObject);

Answer 9

Max Wikstrom 的 JSON 解决方案（上图）对我来说最有意义，它简短、干净，最重要的是它有效。 虽然我个人更喜欢将 JSON 转换实现为单独的方法，并将断言放回单元测试中，如下所示......

辅助方法：

public string GetObjectAsJson(object obj)
    {
        System.Web.Script.Serialization.JavaScriptSerializer oSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
        return oSerializer.Serialize(obj);
    }

单元测试 ：

public void GetDimensionsFromImageTest()
        {
            Image Image = new Bitmap(10, 10);
            ImageHelpers_Accessor.ImageDimensions expected = new ImageHelpers_Accessor.ImageDimensions(10,10);

            ImageHelpers_Accessor.ImageDimensions actual;
            actual = ImageHelpers_Accessor.GetDimensionsFromImage(Image);

            /*USING IT HERE >>>*/
            Assert.AreEqual(GetObjectAsJson(expected), GetObjectAsJson(actual));
        }

仅供参考 - 您可能需要在解决方案中添加对 System.Web.Extensions 的引用。

Answer 10

这是一个非常古老的线程，但我想知道是否有理由没有提出NUnit.Framework.Is.EqualTo和NUnit.Framework.Is.NotEqualTo答案？

如：

Assert.That(LeftObject, Is.EqualTo(RightObject)); 

和

Assert.That(LeftObject, Is.Not.EqualTo(RightObject)); 

Answer 11

另一种选择是通过实现 NUnit 抽象Constraint类来编写自定义约束。 使用辅助类提供一点语法糖，生成的测试代码简洁易读，例如

Assert.That( LeftObject, PortfolioState.Matches( RightObject ) ); 

举一个极端的例子，考虑具有“只读”成员的类，它不是IEquatable ，并且即使您想要，也无法更改被测类：

public class Portfolio // Somewhat daft class for pedagogic purposes...
{
    // Cannot be instanitated externally, instead has two 'factory' methods
    private Portfolio(){ }

    // Immutable properties
    public string Property1 { get; private set; }
    public string Property2 { get; private set; }  // Cannot be accessed externally
    public string Property3 { get; private set; }  // Cannot be accessed externally

    // 'Factory' method 1
    public static Portfolio GetPortfolio(string p1, string p2, string p3)
    {
        return new Portfolio() 
        { 
            Property1 = p1, 
            Property2 = p2, 
            Property3 = p3 
        };
    }

    // 'Factory' method 2
    public static Portfolio GetDefault()
    {
        return new Portfolio() 
        { 
            Property1 = "{{NONE}}", 
            Property2 = "{{NONE}}", 
            Property3 = "{{NONE}}" 
        };
    }
}

Constraint类的契约要求覆盖Matches和WriteDescriptionTo （在不匹配的情况下，预期值的叙述），但也覆盖WriteActualValueTo （实际值的叙述）是有道理的：

public class PortfolioEqualityConstraint : Constraint
{
    Portfolio expected;
    string expectedMessage = "";
    string actualMessage = "";

    public PortfolioEqualityConstraint(Portfolio expected)
    {
        this.expected = expected;
    }

    public override bool Matches(object actual)
    {
        if ( actual == null && expected == null ) return true;
        if ( !(actual is Portfolio) )
        { 
            expectedMessage = "<Portfolio>";
            actualMessage = "null";
            return false;
        }
        return Matches((Portfolio)actual);
    }

    private bool Matches(Portfolio actual)
    {
        if ( expected == null && actual != null )
        {
            expectedMessage = "null";
            expectedMessage = "non-null";
            return false;
        }
        if ( ReferenceEquals(expected, actual) ) return true;

        if ( !( expected.Property1.Equals(actual.Property1)
                 && expected.Property2.Equals(actual.Property2) 
                 && expected.Property3.Equals(actual.Property3) ) )
        {
            expectedMessage = expected.ToStringForTest();
            actualMessage = actual.ToStringForTest();
            return false;
        }
        return true;
    }

    public override void WriteDescriptionTo(MessageWriter writer)
    {
        writer.WriteExpectedValue(expectedMessage);
    }
    public override void WriteActualValueTo(MessageWriter writer)
    {
        writer.WriteExpectedValue(actualMessage);
    }
}

加上助手类：

public static class PortfolioState
{
    public static PortfolioEqualityConstraint Matches(Portfolio expected)
    {
        return new PortfolioEqualityConstraint(expected);
    }

    public static string ToStringForTest(this Portfolio source)
    {
        return String.Format("Property1 = {0}, Property2 = {1}, Property3 = {2}.", 
            source.Property1, source.Property2, source.Property3 );
    }
}

用法示例：

[TestFixture]
class PortfolioTests
{
    [Test]
    public void TestPortfolioEquality()
    {
        Portfolio LeftObject 
            = Portfolio.GetDefault();
        Portfolio RightObject 
            = Portfolio.GetPortfolio("{{GNOME}}", "{{NONE}}", "{{NONE}}");

        Assert.That( LeftObject, PortfolioState.Matches( RightObject ) );
    }
}

Answer 12

只需从 Nuget 安装 ExpectedObjects，您就可以轻松地比较两个对象的属性值、集合的每个对象值、两个组合对象的值和匿名类型的部分比较属性值。

我在 github 上有一些例子： https : //github.com/hatelove/CompareObjectEquals

以下是一些包含比较对象场景的示例：

    [TestMethod]
    public void Test_Person_Equals_with_ExpectedObjects()
    {
        //use extension method ToExpectedObject() from using ExpectedObjects namespace to project Person to ExpectedObject
        var expected = new Person
        {
            Id = 1,
            Name = "A",
            Age = 10,
        }.ToExpectedObject();

        var actual = new Person
        {
            Id = 1,
            Name = "A",
            Age = 10,
        };

        //use ShouldEqual to compare expected and actual instance, if they are not equal, it will throw a System.Exception and its message includes what properties were not match our expectation.
        expected.ShouldEqual(actual);
    }

    [TestMethod]
    public void Test_PersonCollection_Equals_with_ExpectedObjects()
    {
        //collection just invoke extension method: ToExpectedObject() to project Collection<Person> to ExpectedObject too
        var expected = new List<Person>
        {
            new Person { Id=1, Name="A",Age=10},
            new Person { Id=2, Name="B",Age=20},
            new Person { Id=3, Name="C",Age=30},
        }.ToExpectedObject();

        var actual = new List<Person>
        {
            new Person { Id=1, Name="A",Age=10},
            new Person { Id=2, Name="B",Age=20},
            new Person { Id=3, Name="C",Age=30},
        };

        expected.ShouldEqual(actual);
    }

    [TestMethod]
    public void Test_ComposedPerson_Equals_with_ExpectedObjects()
    {
        //ExpectedObject will compare each value of property recursively, so composed type also simply compare equals.
        var expected = new Person
        {
            Id = 1,
            Name = "A",
            Age = 10,
            Order = new Order { Id = 91, Price = 910 },
        }.ToExpectedObject();

        var actual = new Person
        {
            Id = 1,
            Name = "A",
            Age = 10,
            Order = new Order { Id = 91, Price = 910 },
        };

        expected.ShouldEqual(actual);
    }

    [TestMethod]
    public void Test_PartialCompare_Person_Equals_with_ExpectedObjects()
    {
        //when partial comparing, you need to use anonymous type too. Because only anonymous type can dynamic define only a few properties should be assign.
        var expected = new
        {
            Id = 1,
            Age = 10,
            Order = new { Id = 91 }, // composed type should be used anonymous type too, only compare properties. If you trace ExpectedObjects's source code, you will find it invoke config.IgnoreType() first.
        }.ToExpectedObject();

        var actual = new Person
        {
            Id = 1,
            Name = "B",
            Age = 10,
            Order = new Order { Id = 91, Price = 910 },
        };

        // partial comparing use ShouldMatch(), rather than ShouldEqual()
        expected.ShouldMatch(actual);
    }

参考：

1. 预期对象 github
2. 预期对象介绍

Answer 13

我会以@Juanma 的答案为基础。 但是，我认为这不应该用单元测试断言来实现。 这是一个在某些情况下可以由非测试代码很好地使用的实用程序。

我写了一篇关于此事的文章http://timoch.com/blog/2013/06/unit-test-equality-is-not-domain-equality/

我的建议如下：

/// <summary>
/// Returns the names of the properties that are not equal on a and b.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>An array of names of properties with distinct 
///          values or null if a and b are null or not of the same type
/// </returns>
public static string[] GetDistinctProperties(object a, object b) {
    if (object.ReferenceEquals(a, b))
        return null;
    if (a == null)
        return null;
    if (b == null)
        return null;

    var aType = a.GetType();
    var bType = b.GetType();

    if (aType != bType)
        return null;

    var props = aType.GetProperties();

    if (props.Any(prop => prop.GetIndexParameters().Length != 0))
        throw new ArgumentException("Types with index properties not supported");

    return props
        .Where(prop => !Equals(prop.GetValue(a, null), prop.GetValue(b, null)))
        .Select(prop => prop.Name).ToArray();
} 

将此与 NUnit 一起使用

Expect(ReflectionUtils.GetDistinctProperties(tile, got), Empty);

在不匹配时产生以下消息。

Expected: <empty>
But was:  < "MagmaLevel" >
at NUnit.Framework.Assert.That(Object actual, IResolveConstraint expression, String message, Object[] args)
at Undermine.Engine.Tests.TileMaps.BasicTileMapTests.BasicOperations() in BasicTileMapTests.cs: line 29

Answer 14

https://github.com/kbilsted/StatePrinter专门用于将对象图转储为字符串表示形式，目的是编写简单的单元测试。

• 它带有 Assert 方法，可以输出正确转义的字符串，轻松复制粘贴到测试中以进行更正。
• 它允许自动重写单元测试
• 它与所有单元测试框架集成
• 与 JSON 序列化不同，支持循环引用
• 您可以轻松过滤，因此只会转储部分类型

给定的

class A
{
  public DateTime X;
  public DateTime Y { get; set; }
  public string Name;
}

您可以以类型安全的方式，并使用 Visual Studio 的自动完成功能来包含或排除字段。

  var printer = new Stateprinter();
  printer.Configuration.Projectionharvester().Exclude<A>(x => x.X, x => x.Y);

  var sut = new A { X = DateTime.Now, Name = "Charly" };

  var expected = @"new A(){ Name = ""Charly""}";
  printer.Assert.PrintIsSame(expected, sut);

Answer 15

请看以下链接。 它是代码项目的解决方案，我也使用过它。 它可以很好地比较对象。

http://www.codeproject.com/Articles/22709/Testing-Equality-of-Two-Objects?msg=5189539#xx5189539xx

Answer 16

我已经写了一个简单的表达式工厂：

public static class AllFieldsEqualityComprision<T>
{
    public static Comparison<T> Instance { get; } = GetInstance();

    private static Comparison<T> GetInstance()
    {
        var type = typeof(T);
        ParameterExpression[] parameters =
        {
            Expression.Parameter(type, "x"),
            Expression.Parameter(type, "y")
        };
        var result = type.GetProperties().Aggregate<PropertyInfo, Expression>(
            Expression.Constant(true),
            (acc, prop) =>
                Expression.And(acc,
                    Expression.Equal(
                        Expression.Property(parameters[0], prop.Name),
                        Expression.Property(parameters[1], prop.Name))));
        var areEqualExpression = Expression.Condition(result, Expression.Constant(0), Expression.Constant(1));
        return Expression.Lambda<Comparison<T>>(areEqualExpression, parameters).Compile();
    }
}

只需使用它：

Assert.That(
    expectedCollection, 
    Is.EqualTo(actualCollection)
      .Using(AllFieldsEqualityComprision<BusinessCategoryResponse>.Instance));

这非常有用，因为我必须比较这些对象的集合。 你可以在其他地方使用这个 comparere :)

这是示例的要点：https ://gist.github.com/Pzixel/b63fea074864892f9aba8ffde312094f

Answer 17

反序列化两个类，并进行字符串比较。

编辑：完美运行，这是我从 NUnit 获得的输出；

Test 'Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.TranslateNew_GivenEaiCustomer_ShouldTranslateToDomainCustomer_Test("ApprovedRatingInDb")' failed:
  Expected string length 2841 but was 5034. Strings differ at index 443.
  Expected: "...taClasses" />\r\n  <ContactMedia />\r\n  <Party i:nil="true" /..."
  But was:  "...taClasses" />\r\n  <ContactMedia>\r\n    <ContactMedium z:Id="..."
  ----------------------------------------------^
 TranslateEaiCustomerToDomain_Tests.cs(201,0): at Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.Assert_CustomersAreEqual(Customer expectedCustomer, Customer actualCustomer)
 TranslateEaiCustomerToDomain_Tests.cs(114,0): at Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.TranslateNew_GivenEaiCustomer_ShouldTranslateToDomainCustomer_Test(String custRatingScenario)

编辑二：这两个对象可以相同，但属性序列化的顺序不同。 因此 XML 是不同的。 哦！

编辑三：这确实有效。 我在我的测试中使用它。 但是您必须按照被测代码添加项目的顺序将项目添加到集合属性。

Answer 18

我知道这是一个非常古老的问题，但 NUnit 仍然没有对此的原生支持。 但是，如果您喜欢 BDD 风格的测试（ala Jasmine），那么您会对 NExpect（ https://github.com/fluffynuts/NExpect ，从 NuGet 获取）感到惊喜，它在那里进行了深入的平等测试.

（免责声明：我是 NExpect 的作者）

Answer 19

如何在nunit中匹配多个字符串值列表，其中输入是单个字符串值而输出是字符串列表，如何检查多个测试用例

Answer 20

这只是可以与 Moq 一起使用的上述答案之一的修改版本：

public static class Helpers {

    public static bool DeepCompare(this object actual, object expected) {
        var properties = expected.GetType().GetProperties();
        foreach (var property in properties) {
            var expectedValue = property.GetValue(expected, null);
            var actualValue = property.GetValue(actual, null);

            if (actualValue == null && expectedValue == null) {
                return true;
            }

            if (actualValue == null || expectedValue == null) {
                return false;
            }

            if (actualValue is IList actualList) {
                if (!AreListsEqual(actualList, (IList)expectedValue)) {
                    return false;
                }
            }
            else if (IsValueType(expectedValue)) {
                if(!Equals(expectedValue, actualValue)) {
                    return false;
                }
            }
            else if (expectedValue is string) {
                return actualValue is string && Equals(expectedValue, actualValue);
            }
            else if (!DeepCompare(expectedValue, actualValue)) {
                return false;
            }
                
        }
        return true;
    }

    private static bool AreListsEqual(IList actualList, IList expectedList) {
        if (actualList == null && expectedList == null) {
            return true;
        }

        if (actualList == null  || expectedList == null) {
            return false;
        }

        if (actualList.Count != expectedList.Count) {
            return false;
        }

        if (actualList.Count == 0) {
            return true;
        }

        var isValueTypeOrString = IsValueType(actualList[0]) || actualList[0] is string;

        if (isValueTypeOrString) {
            for (var i = 0; i < actualList.Count; i++) {
                if (!Equals(actualList[i], expectedList[i])) {
                    return false;
                }
            }
        }
        else {
            for (var i = 0; i < actualList.Count; i++) {
                if (!DeepCompare(actualList[i], expectedList[i])) {
                    return false;
                }
            }
        }

        return true;
    }

    private static bool IsValueType(object obj) {
        return obj != null && obj.GetType().IsValueType;
    }

当您需要的不仅仅是It.IsAny<>并且想要匹配所有属性时，它可以用于在模拟类型上指定设置时匹配 object，如下所示：

_clientsMock.Setup(m => m.SearchClients(
            It.Is<SearchClientsPayload>(x => x.DeepCompare(expectedRequest)))).Returns(expectedResponse);

当然可以改进它以处理可枚举和其他复杂场景。

Answer 21

Compare-Net-Objects项目内置了测试扩展以支持比较 NUnit 中的嵌套对象。

using KellermanSoftware.CompareNetObjects;

[Test]
public void ShouldCompare_When_Equal_Should__Not_Throw_An_Exception()
{
    //Arrange
    string errorMessage = "Groups should be equal";
    var people1 = new List<Person>() { new Person() { Name = "Joe" } };
    var people2 = new List<Person>() { new Person() { Name = "Joe" } };
    var group1 = new KeyValuePair<string, List<Person>>("People", people1);
    var group2 = new KeyValuePair<string, List<Person>>("People", people2);

    //Assert
    group1.ShouldCompare(group2, errorMessage);
}

Answer 22

字符串化并比较两个字符串

Assert.AreEqual(JSON.stringify(LeftObject), JSON.stringify(RightObject))