ContainsKey doesn't support IgnoreCase, IgnoreWhiteSpace, or IgnoreLineEndingFormat

[Bartleby2718]

Summary

IgnoreLineEndingFormat (added in #4975) doesn't work for ContainsKey.

Minimal Reproducible Example

	// tested with 4.4.0-alpha.0.17
	[Test]
	public void ContainKey()
	{
		Dictionary<string, int> values = new() { { "a\r", 1 } };
		Assert.That(values, Does.ContainKey("a\n").IgnoreLineEndingFormat);
	}

Explanation

The current implementation of DictionaryContainsKeyConstraint uses reflection:

nunit/src/NUnitFramework/framework/Constraints/DictionaryContainsKeyConstraint.cs

Lines 100 to 112 in d4a5c38

	private static MethodInfo? GetContainsKeyMethod(object keyedItemContainer)
	{
	var instanceType = keyedItemContainer.GetType();
	var method = FindContainsKeyMethod(instanceType)
	?? instanceType
	.GetInterfaces()
	.Concat(GetBaseTypes(instanceType))
	.Select(FindContainsKeyMethod)
	.FirstOrDefault(m => m is not null);
	return method;
	}

Unlike Enumerable.Contains, however, Dictionary<TKey,TValue>.ContainsKey(TKey) doesn't have an overload that takes in IEqualityComparer<TSource>. Therefore, DictionaryContainsKeyConstraint cannot use the IgnoreLineEndingFormatStringComparer

nunit/src/NUnitFramework/framework/Constraints/Comparers/IgnoreLineEndingFormatStringComparer.cs

Line 10 in d4a5c38

internal sealed class IgnoreLineEndingFormatStringComparer : IEqualityComparer<string>

and therefore fails to treat "a\r" and "a\n" equally.

Potential Solution

Haven't looked too much into the code base, but the first thing I can think of is (in pseudocode):

1. for IDictionary<string, TValue>, do d.Keys.ToArray().Contains(key, IgnoreLineEndingFormatComparer<string>)
2. for IEnumerable<KeyValuePair<string, TValue>>, do d.Select(kvp => kvp.Key).Contains(key, IgnoreLineEndingFormatComparer<string>)

[Bartleby2718]

Maybe add overloads of these methods that take in a string:

nunit/src/NUnitFramework/framework/Does.cs

Lines 66 to 74 in d4a5c38

	/// <summary>
	/// Returns a new DictionaryContainsKeyConstraint checking for the
	/// presence of a particular key in the Dictionary key collection.
	/// </summary>
	/// <param name="expected">The key to be matched in the Dictionary key collection</param>
	public static DictionaryContainsKeyConstraint ContainKey(object expected)
	{
	return Contains.Key(expected);
	}

nunit/src/NUnitFramework/framework/Contains.cs

Lines 34 to 41 in d4a5c38

	/// <summary>
	/// Returns a new DictionaryContainsKeyConstraint checking for the
	/// presence of a particular key in the dictionary.
	/// </summary>
	public static DictionaryContainsKeyConstraint Key(object expected)
	{
	return new DictionaryContainsKeyConstraint(expected);
	}

and create DictionaryContainsStringKeyConstraint?

[Bartleby2718]

• Looks like IgnoreLineEndingFormat isn't the only one that doesn't work. IgnoreCase and IgnoreWhiteSpace also don't work, and tests were missing, so I've updated the title accordingly.
• Curious what _isDeprecatedMode (added in 968d125) is:

  nunit/src/NUnitFramework/framework/Constraints/DictionaryContainsKeyConstraint.cs

  Lines 64 to 74 in d4a5c38

  	if (_isDeprecatedMode)
  	{
  	var dictionary = ConstraintUtils.RequireActual<IDictionary>(actual, nameof(actual));
  	foreach (var obj in dictionary.Keys)
  	{
  	if (ItemsEqual(obj, Expected))
  	return true;
  	}
  	return false;
  	}

[Bartleby2718]

Huh, IgnoreCase was Obsoleted in #2967 but the attribute was later removed...?

[Bartleby2718]

and missed in #3836 when deletion actually happened?

[manfred-brands]

The idea is that Nunit's ContainsKey matches the one on Dictionary itself. Therefore none of the suffixes should do anything. Ideally they should not be available on the constraint at all.

[OsirisTerje]

@manfred-brands So, closed-by-design ?

[stevenaw]

I agree with closed-by-design if @manfred-brands does.

The behaviour of ContainsKey() can still be modified by passing in a custom IEqualityComparer<T> to the constructor of the dictionary itself. .NET also provides a few out-of-the-box for strings such as StringComparer.OrdinalIgnoreCase that could be applied, and culture-specific or Invariant comparers could also be easily used if needed. Custom comparers could be written for other cases not supported by .NET.

For example (untested):

var dictionaryA = new Dictionary<string, int>() {  // case-sensitive
  { "foo", 1 }
};
var dictionaryB = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase) { // case-insensitive
  { "FOO", 1 }
};

// Both should work
Assert.That(dictionaryA, Contains.Key("foo"));
Assert.That(dictionaryB, Contains.Key("foo"));

[manfred-brands]

@manfred-brands So, closed-by-design ?

Implementation is by design.
I left it open for: Ideally they should not be available on the constraint at all.
Let me see if I can change DictionaryContainsKeyConstraint to not inherit the modifiers.