Mocking specific expression in repository

Question

I want to mock a specific expression in one of my repositories and I'm having some trouble.

I currently have:

Mock<Container> returnContainer = new Mock<Container>();
Mock<IRepository<Container>> CntnrRepository =
    new Mock<IRepository<Container>>();

CntnrRepository.Setup<Container>(repo => repo
    .Find(x => x.Name == "foo")
    .Returns(returnContainer.Object);

Whenever the following code runs it's returning null instead of my Mock<Container> above.

Container found = 
    containerRepository.Find(x => x.Name == cntnrName);

What am I doing wrong here?

Edit

Below is the code that is using the injected repository:

public int Foo(Guid id, string name)
{
    Container found = 
        containerRepository.Find(x => x.Name == name);

    if (found != null)
        return CONTAINER_NOT_FREE;

    Container cntnrToAssociate =
        containerRepository.Find(x => x.Id == cntnrId);

    if (cntnrToAssociate == null)
        return CONTAINER_NOT_FOUND;

    return OK;
}

In the code above for one of my tests I need to return a value only in the first query (Find) to the containerRepository

Answer 1

Edit: i updated the solution, this works with Expression-arguments Edit2: i added a more general solution (look at the last test) which uses the ExpressionComparer from IQToolkit. That should satisfy any generic expression in a setup

If you set it up as shown below you can return not null only for some input arguments

    [Test]
    public void SetupFunc_TestWithExpectedArgument_ReturnsNotNull()
    {
        // Arrange
        var repository = new Mock<IRepository<Container>>();
        repository.Setup(r => r.Find(It.Is<Expression<Func<Container, bool>>>(x => NameIsFoo(x)))).Returns(new Container());

        // Act
        Container container = repository.Object.Find(x => x.Name == "foo");

        // Assert
        Assert.That(container, Is.Not.Null);
    }

    [Test]
    public void SetupFunc_TestWithOtherargument_ReturnsNull()
    {
        // arrange
        var repository = new Mock<IRepository<Container>>();
        repository.Setup(r => r.Find(It.Is<Expression<Func<Container, bool>>>(x => NameIsFoo(x)))).Returns(new Container());

        // Act
        Container container = repository.Object.Find(x => x.Name == "bar");

        // Assert
        Assert.That(container, Is.Null);
    }

    private static bool NameIsFoo(Expression<Func<Container, bool>> expression)
    {
        if (expression == null)
            return false;

        var mExpr = expression.Body as BinaryExpression;

        if (mExpr == null)
            return false;

        var constantExpression = mExpr.Right as ConstantExpression;

        if (constantExpression == null)
            return false;

        return Equals(constantExpression.Value, "foo");
    }

    [Test]
    public void SetupFunc_TestWithExpectedArgumentUsingExpressionComparer_ReturnsNotNull()
    {
        // Arrange
        var repository = new Mock<IRepository<Container>>();

        Expression<Func<Container, bool>> expectedArgument = x => x.Name == "foo";

        repository.Setup(r => r.Find(It.Is<Expression<Func<Container, bool>>>(x => ExpressionComparer.AreEqual(x, expectedArgument)))).Returns(new Container());

        // Act
        Container container = repository.Object.Find(x => x.Name == "foo");

        // Assert
        Assert.That(container, Is.Not.Null);
    }

Answer 2

Following seems to return non null object:

    static void Main(string[] args)
    {
        Mock<Container> returnContainer = new Mock<Container>();
        var CntnrRepository = new Mock<IRepository<Container>>();

        CntnrRepository.Setup<Container>(repo => repo.Find(x => x.Name == "foo")).Returns(returnContainer.Object);

        var found = CntnrRepository.Object.Find(x => x.Name == "foo");

        // Or if you want to pass the mock repository to a method
        var container = GetContainer(CntnrRepository.Object);
    }

    public static Container GetContainer(IRepository<Container> container)
    {
        return container.Find(x => x.Name == "foo");
    }

Instead of calling containerRepository.Find you have to call containerRepository.Object.Find. I wasn't even able to compile the code if I dropped the .Object part.

Edit: I added example how to pass the IRepository to a method

Answer 3

It appears that the answer is "it can't be done."

See Jason Punyon's answer to Moq.Mock - how to setup a method that takes an expression.

As per his answer, you can use

CntnrRepository.Setup(repo => repo.FindAll(
    It.IsAny<Expression<Func<Container, bool>>>()))
    .Returns(returnContainer.Object);

but you can't put any constraints on the expression. I suppose you could parse the expression using It.Is, but that's likely more trouble than it's worth for a mock.

This is one of several reasons why I am in the camp of "don't expose IQueryable on repositories." While you're only exposing IList, using Expression is going down the same slippery slope IMHO.

Answer 4

Workaround

I haven't found the solution I'm looking for as of now but I did find a decent workaround. I ended up using Moq's Callback method to do what I want. Please see the following:

int numCalls = 0;
List<Container> expectedContainers = new List<Container>();

//Add list of expected containers here.  Since I want the first call to return null
//and the 2nd call to return a valid container object I will fill the array with null
//in the 1st entry and a valid container in the 2nd
expectedContainers.Add(null);
expectedContainers.Add(new Container());

CntnrRepository.Setup<Container>(
                repo => repo.Find(It.IsAny<Expression<Func<Container, bool>>>()))
                .Returns(() => returnContainers[numCalls])
                .Callback(() => numCalls++);

The above code allows me to return different results at different times from the same repository.

So instead of looking for looking for specific linq expressions I return the correct objects based on the number of calls the function makes to the repository.