С# - утверждение, что два объекта равны в модульных тестах

У вас есть два разных экземпляра Board, поэтому ваш вызов Assert.AreEqual завершится ошибкой. Даже если все их содержимое кажется одинаковым, вы сравниваете ссылки, а не базовые значения.

Вы должны указать, что делает два экземпляра Board равными.

Вы можете сделать это в своем тесте:

Assert.AreEqual(expected.Rows.Count, actual.Rows.Count);
Assert.AreEqual(expected.Rows[0].Cells[0], actual.Rows[0].Cells[0]);

// Lots more tests of equality...

Или вы можете сделать это в своих классах: (обратите внимание, я написал это на лету - вы захотите это настроить)

public class Board
{
    public List<Row> Rows = new List<Row>();

    public override bool Equals(object obj)
    {
        var board = obj as Board;

        if (board == null)
            return false;

        if (board.Rows.Count != Rows.Count)
            return false;

        return !board.Rows.Where((t, i) => !t.Equals(Rows[i])).Any();
    }

    public override int GetHashCode()
    {
        // determine what's appropriate to return here - a unique board id may be appropriate if available
    }
}

public class Row
{
    public List<int> Cells = new List<int>(); 

    public override bool Equals(object obj)
    {
        var row = obj as Row;

        if (row == null)
            return false;

        if (row.Cells.Count != Cells.Count)
            return false;

        if (row.Cells.Except(Cells).Any())
            return false;

        return true;
    }

    public override int GetHashCode()
    {
        // determine what's appropriate to return here - a unique row id may be appropriate if available
    }
}

Раньше я переопределял getHasCode и equals, но мне это никогда не нравилось, так как я не хочу менять свой производственный код ради модульного тестирования. А еще это какая-то боль.

Затем я переключился на отражение, чтобы сравнить объекты, которые были менее инвазивными... но это много работы (много угловых случаев).

В итоге использую:

http://www.nuget.org/packages/DeepEqual/ Отлично работает.

Обновление, 6 лет спустя:

Теперь я использую более общую библиотеку fluentassertions для .NET, она делает то же самое, что и выше, но с большим количеством функций и хорошим DSL, конкретной заменой будет: https://fluentassertions.com/objectgraphs/

Кроме того, после нескольких лет опыта я все еще не рекомендую маршрут переопределения, я бы даже посчитал это плохой практикой. Если вы не будете осторожны, вы можете вызвать проблемы с производительностью при использовании некоторых коллекций, таких как словари. Кроме того, когда придет время, когда у вас будет реальный бизнес-кейс для перегрузки этих методов, у вас будут проблемы, потому что у вас уже будет этот тестовый код. Рабочий код и тестовый код должны быть разделены, тестовый код не должен полагаться на детали реализации или хаки для достижения своей цели, это усложняет его поддержку и понимание.

ExpectedObjects поможет вам сравнить равенство по значению свойства. Он поддерживает:

1. простой объект: ожидаемый.ToExpectedObject().ShouldEqual(фактический);
2. коллекция: ожидаемый.ToExpectedObject().ShouldEqual(фактический);
3. составной объект: ожидаемый.ToExpectedObject().ShouldEqual(фактический);
4. частичное сравнение: ожидаемому объекту нужен дизайн с анонимным типом и используйте ожидаемый.ToExpectedObject().ShouldMatch(фактический)

Я люблю ExpectedObjects, потому что мне нужно только вызвать 2 API для подтверждения сравнения объектов:

1. ДолженРавно()
2. ShouldMatch() для частичного сравнения

Мне нужно решение, которое не требует добавления зависимости, работает с модульными тестами VS, сравнивает значения полей двух объектов и сообщает мне обо всех неравных полях. Это то, что я придумал. Обратите внимание, что его можно расширить и для работы со значениями свойств.

В моем случае это хорошо работает для сравнения результатов некоторой логики синтаксического анализа файлов, чтобы убедиться, что две технически «разные» записи имеют поля с одинаковыми значениями.

    public class AssertHelper
    {
        public static void HasEqualFieldValues<T>(T expected, T actual)
        {
            var failures = new List<string>();
            var fields = typeof(T).GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
            foreach(var field in fields)
            {
                var v1 = field.GetValue(expected);
                var v2 = field.GetValue(actual);
                if (v1 == null && v2 == null) continue;
                if(!v1.Equals(v2)) failures.Add(string.Format("{0}: Expected:<{1}> Actual:<{2}>", field.Name, v1, v2));
            }
            if (failures.Any())
                Assert.Fail("AssertHelper.HasEqualFieldValues failed. " + Environment.NewLine+ string.Join(Environment.NewLine, failures));
        }
    }

    [TestClass]
    public class AssertHelperTests
    {
        [TestMethod]     
        [ExpectedException(typeof(AssertFailedException))]           
        public void ShouldFailForDifferentClasses()
        {            
            var actual = new NewPaymentEntry() { acct = "1" };
            var expected = new NewPaymentEntry() { acct = "2" };
            AssertHelper.HasEqualFieldValues(expected, actual);
        }
    }

Для тривиальных объектов, таких как объекты домена, DTO или сущности, вы можете просто сериализовать оба экземпляра в строку и сравнить эту строку:

var object1Json = JsonConvert.SerializeObject(object1);
var object2Json = JsonConvert.SerializeObject(object2);

Assert.AreEqual(object1Json, object2Json);

Это, конечно, имеет различные предостережения, поэтому оцените, содержит ли JSON для ваших классов ожидаемые значения, которые следует сравнивать.

Например, если ваш класс содержит неуправляемые ресурсы или иным образом не сериализуемые свойства, они не будут правильно сравниваться. Он также сериализует только общедоступные свойства по умолчанию.

Методы Assert полагаются на Equals и GetHashcode объекта. Вы можете реализовать это, но если это равенство объектов не требуется вне модульных тестов, я бы вместо этого рассмотрел возможность сравнения отдельных типов примитивов на объекте. Похоже, что объекты достаточно просты, и переопределение равенства на самом деле не гарантируется.

Поскольку ни один из них еще не упоминался по этому вопросу, есть несколько других хорошо принятых библиотек, которые могут помочь с этой проблемой:

1. Свободные утверждения — см. сравнение графов объектов

   actual.Should().BeEquivalentTo(expected);

2. Семантическое сравнение

   Likeness<MyModel, MyModel>(actual).ShouldEqual(expected);

Я лично предпочитаю Fluent Assertions, так как обеспечивает большую гибкость с исключениями элементов и т. д., а также поддерживает сравнение вложенных объектов из коробки.

Надеюсь это поможет!