Does FluentAssertions support WithStrictOrdering for dictionaries?

Question

I'm comparing two simple dictionaries. I add items to the dictionaries in opposite order. I'm using the WithStrictOrdering option in FluentAssertions but this test passes and I think it should fail:

var actual = new Dictionary<string, string>();
actual.Add("a", "1");
actual.Add("b", "2");

var expected = new Dictionary<string, string>();
expected.Add("b", "2");
expected.Add("a", "1");

actual.Should().BeEquivalentTo(expected, options => options.WithStrictOrdering());

When I look at these dictionaries in the debugger, the items appear to be in different order, as expected. I can use the WithStrictOrdering option for lists and it behaves as expected. Does the WithStrictOrdering option work for dictionaries?

Answer 1

WithStrictOrdering is ignored when comparing two dictionaries.

In Fluent Assertions two dictionaries are consider equivalent if:

• the two dictionaries have the same length, and
• for every key in the expectation, the subject contains a value for that key (respecting its comparer) that is equivalent to the value for the same key in the expectation.

The source code is found here.

Regarding the order you're observing through the debugger: The order of elements may change, e.g. if the Dictionaries are re-hashed. In general you should not rely on the order of elements in a Dictionary.

From the documentation

For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair<TKey,TValue> structure representing a value and its key. The order in which the items are returned is undefined.

If you still want to compare the elements in two dictionaries respecting the undefined order of retrieving the elements a workaround is to cast the Dictionary<string,string> to an IEnumerable<object>

actual.Cast<object>().Should().BeEquivalentTo(expected, options => options.WithStrictOrdering());

Note: In Fluent Assertions V5 using Cast<KeyValuePair<string, string>>() will also work, but in the upcoming V6 a type implementing IEnumerable<KeyValuePair<TKey, TValue>> is considered to be a dictionary-like type and hence Cast<object>() is necessary to make Should() resolve to GenericCollectionAssertions instead of GenericDictionaryAssertions.