No direct inverse for Contains.Key

[chrisoldwood]

The DictionaryContainsKeyConstraint allows an assertion to be written against the presence of a key in a dictionary:

Assert.That(dictionary, Contains.Key("test"));

However it's not possible to directly write the inverse - that a dictionary does not contain a key:

Assert.That(dictionary, Does.Not.ContainKey("test"));

The closest is probably to inspect the dictionary's Keys property and assert on that:

Assert.That(dictionary.Keys, Does.Not.Contains("test"));

Aside from the lack of symmetry, the grammar of this approach is slightly jarring and a dedicated ContainKey method would be preferable.

As an aside it's possible to solve this locally in the test code using an extension method:

public static class Extensions
{
    public static DictionaryContainsKeyConstraint ContainKey(this ConstraintExpression constraint, string value)
    {
        var keyConstraint = new DictionaryContainsKeyConstraint(value);

        constraint.Append(keyConstraint);

        return keyConstraint;
    }
}

[JustinRChou]

Was this fixed?

I tried a test and the using !Contains.Keys was working. Unless I am misunderstanding the issue?

[Test]
public void SucceedsWhenKeyIsNotPresent()
{
    var dictionary = new Dictionary<string, string> { { "Hello", "World" }, { "Hola", "Mundo" } };
    Assert.That(dictionary, !Contains.Key("NotKey")); //assert passed
    Assert.That(dictionary, !Contains.Key("Hello")); //assert failed as key does exist
}

[CharliePoole]

That has always worked. Every constraint automatically works with !.

The requester wanted to write Does.Not.ContainKey, which is still not supported.

The priority is low precisely because there are other ways to do the same thing. :-)

[JustinRChou]

I see.

[JustinRChou]

Update:
Realized that you needed an actual key pair for the test to fail correctly.
Assert.That(dictionary, Does.Not.Contains(new System.Collections.Generic.KeyValuePair<string,string>("Hello", "World")));

Is there a reason why Contains is only accessible using Does.Not.Contains and not Does.Contains?

----ignore----
But is Does.Contains supposed to work on Dictionaries?

I have been running the following

var dictionary = new Dictionary<string, string> { { "Hello", "World" }, { "Hola", "Mundo" } };
Assert.That(dictionary, Does.Not.Contains("Hello")); 
Assert.That(dictionary, Does.Not.Contains("a"));

And the test passed.

Seems like the dictionary was not properly converted a collection type for Contains.

[CharliePoole]

Yes, as you see, a dictionary is a collection of key pairs. So your original negative tests passed because the dictionary never contains "Hello". You could have written either of the following:

Assert.That(dictionary.Keys, Does.Contain("Hello"));
Assert.That(dictionary, Contains.Key("Hello"));

This is a byproduct of the fact that NUnit generally treats the actual value in an assertion as an object and any type-checking done is dynamic. We hope to get past that some day, but it isn't likely to happen soon.