Specifying the expected number of occurrences in IsIn()

[madstt]

In a verification step, I would like to specify the number of times an expected value should occur.

Using the current version:

serviceMock.Verify(service => service.GetPet(It.IsIn(expectedListOfValues)), Times.Once);

But that does not catch cases where you need to verify an exact number of times an expected value is allowed, it just verifies that the value is in the list.

I did an honest attempt to make this possible. Since the It class is static and sealed, it is not possible to create an extension method nor inherit from It, so I made my static class and method:

serviceMock.Verify(service => service.GetPet(It.IsExactlyIn(expectedListOfValues, 1)), Times.Once);

This would require that the mock is only called once for either of the expected values in expectedListOfValues.

I took the current implementation of IsIn() and added a requirement:

public static TValue IsExactlyIn<TValue>(IEnumerable<TValue> items, int times)
    where TValue : class
{
    return Match.Create<TValue>(value => items.Contains(value) && items.Count(item => item == value) == times);
}

I'm wondering whether I should create a PR for this or you don't see any reason to add this Moq?

[stakx]

It is sometimes a pity that static classes cannot be extended that way, right? Nevertheless, I think it doesn't make sense to add all possible kinds of specific predicates to Moq's It class. We have the basic constructs in place that can be used to create further predicates – It.Is and custom argument matchers – and my vote goes towards leaving it at that and keep more specific predicates in user code.

(There are some fairly specific It methods that, judging from retrospective, perhaps shouldn't be in the core library either. Nothing to be done about those, removing them isn't worth a breaking change IMHO.)

[madstt]

Ok, that sounds reasonable. Is it actually possible to create the same logic using current constructs and custom argument matchers? If so, could show an example?

[stakx]

I think you've already figured out how to use custom matchers for this. But here goes.

You can replace It.IsIn(xs) with It.Is(x => xs.Contains(x)), right?

From there, it should be easy to adjust the predicate so it checks for n occurrences instead; say, It.Is(x => xs.Count(y => y == x) == n).

You could then wrap this up similar to how you've done already:

static T IsExactlyIn<T>(IEnumerable<T> items, int times)
{
    return It.Is(x => items.Count(y => y == x) == times);
}

(I probably wouldn't even go down the custom matcher path for this; wrapping It.Is seems perfectly sufficient.)

[madstt]

Thank you.

I'll close this.