我试图断言一个对象与另一个对象“相等”。
对象只是具有一堆公共属性的类的实例。有没有一种简单的方法可以让 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 验证两个集合的内容是否相同。
不要仅仅为了测试目的而覆盖 Equals。这很乏味并且影响域逻辑。反而，
您的对象没有额外的逻辑。没有额外的测试任务。
只需使用这个简单的方法：
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 });
}
如果由于任何原因无法覆盖 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]);
}
}
为您的对象覆盖 .Equals ，然后在单元测试中您可以简单地执行以下操作：
Assert.AreEqual(LeftObject, RightObject);
当然，这可能意味着您只需将所有单独的比较移至 .Equals 方法，但它允许您在多个测试中重用该实现，并且如果对象应该能够与兄弟姐妹进行比较可能是有意义的。
我不想仅仅为了启用测试而覆盖 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.");
}
}
我尝试了这里提到的几种方法。大多数涉及序列化您的对象并进行字符串比较。虽然超级简单且通常非常有效，但我发现当您遇到故障并报告类似这样的事情时它会有点短：
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的回答）。
我同意 ChrisYoxall 的观点——纯粹出于测试目的在您的主代码中实现 Equals 并不好。
如果您因为某些应用程序逻辑需要而实现 Equals，那很好，但请保持纯测试代码以免造成混乱（同样检查相同以进行测试的语义可能与您的应用程序所需的不同）。
简而言之，将仅用于测试的代码排除在您的课程之外。
对于大多数类来说，使用反射对属性进行简单的浅层比较就足够了，尽管如果您的对象具有复杂的属性，您可能需要递归。如果遵循引用，请注意循环引用或类似内容。
狡猾
在 NUnit 2.4.2 中添加的Property constraints允许一个比 OP 的原始解决方案更具可读性的解决方案，并且它会产生更好的失败消息。它绝不是通用的，但如果你不需要为太多的类做它，它是一个非常合适的解决方案。
Assert.That(ActualObject, Has.Property("Prop1").EqualTo(ExpectedObject.Prop1)
& Has.Property("Prop2").EqualTo(ExpectedObject.Prop2)
& Has.Property("Prop3").EqualTo(ExpectedObject.Prop3)
// ...
不像实现那样通用，Equals但它确实提供了比
Assert.AreEqual(ExpectedObject, ActualObject);
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 的引用。
这是一个非常古老的线程，但我想知道是否有理由为什么没有提出答案NUnit.Framework.Is.EqualTo和NUnit.Framework.Is.NotEqualTo？
如：
Assert.That(LeftObject, Is.EqualTo(RightObject));
和
Assert.That(LeftObject, Is.Not.EqualTo(RightObject));
另一种选择是通过实现 NUnit 抽象Constraint类来编写自定义约束。使用帮助类提供一点语法糖，生成的测试代码非常简洁易读，例如
Assert.That( LeftObject, PortfolioState.Matches( RightObject ) );
举一个极端的例子，考虑具有“只读”成员的类 is not 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 ) );
}
}
只需从 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);
}
参考：
我会以@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
https://github.com/kbilsted/StatePrinter专门用于将对象图转储为字符串表示，目的是编写简单的单元测试。
给定
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);
我已经写了一个简单的表达式工厂：
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));
这非常有用，因为我必须比较这些对象的集合。你可以在其他地方使用这个比较:)
以下是示例要点：https ://gist.github.com/Pzixel/b63fea074864892f9aba8ffde312094f
反序列化两个类，并进行字符串比较。
编辑： 完美运行，这是我从 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 是不同的。哦！
编辑三： 这确实有效。我在我的测试中使用它。但是您必须按照被测代码添加项目的顺序将项目添加到集合属性中。
我知道这是一个非常古老的问题，但 NUnit 仍然没有对此的原生支持。然而，如果你喜欢 BDD 风格的测试（ala Jasmine），你会对 NExpect 感到惊喜（https://github.com/fluffynuts/NExpect，从 NuGet 获得），其中包含深度相等测试.
（免责声明：我是 NExpect 的作者）
字符串化和比较两个字符串
Assert.AreEqual(JSON.stringify(LeftObject), JSON.stringify(RightObject))