I remember that I encountered an interesting bug that was not detected by unit tests because the behaviour of the test framework did not match my expectations.
The test was supposed to verify that the contents of an array (or a list) returned by the code under test match an expected array of elements in the specific order of that expected array. The unit test was passing, however, later the team discovered a bug, and the root cause was that the array was not in the correct order! This is exactly why we write automated tests, but the test failed us.
The test, which uses FluentAssertions library basically looked like:
[Test]
public void FluentAssertions_Unordered_Pass()
{
var actual = new List<int> {1, 2, 3}; // SUT invocation here
var expected = new [] {3, 2, 1};
actual.Should().BeEquivalentTo(expected);
}
Although the order of the elements of the actual array don't match the expected, the test passes. This is not a bug in FluentAssertions. It's by design, and the solution is simple:
actual.Should().BeEquivalentTo(expected, config => config.WithStrictOrdering());
The config parameter enforces a specific order of the collection. It's also possible to configure this globally, when initializing the test assembly for example:
AssertionOptions.AssertEquivalencyUsing(config => config.WithStrictOrdering());
The default behavior of this method annoyed me. In my opinion, the test method should be strict by default. That is, it should assume that the collection should be sorted, and can be made more lenient by overriding this behavior. Not the opposite.
Probably I got into the habit of using BeEquivalentTo()
, while an Equal()
assertion exists, which "Expects the current collection to contain all the same elements in the same order" as it's default behavior. There are other differences between BeEquivalentTo()
and Equal()
that don't matter in this context.
Similar behavior applies to Nunit assertions, although there is no way to override the equivalence behavior:
[Test]
public void NUnit_Unordered_Pass()
{
var actual = new [] {1, 2, 3};
var expected = List<int> {3, 2, 1};
Assert.That(actual, Is.EquivalentTo(expected)); // pass
CollectionAssert.AreEquivalent(expected, actual); // pass
}
[Test]
public void NUnit_Unordered_Fail()
{
var actual = new [] {1, 2, 3};
var expected = new List<int> {3, 2, 1};
Assert.That(actual, Is.EqualTo(expected)); // fail
CollectionAssert.AreEqual(expected, actual); // fail
}
It's important to understand the behavior of the testing library to avoid similar mistakes. We rely on tests as our safetly net, and they better be reliable!