Mock same method in a test using Moq with different linq expressions

Question

I have a repository with this method

    public virtual IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, 
IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "");

I have a method that is using it as such to get a user to work on

var user = this.applicationUserRepository.Get(x => x.EmailAddress == userName).FirstOrDefault();

It then calls the same method with a different expression further in the method as follows to check the user working on the first user

var changingUser = this.applicationUserRepository.Get(x => x.Id == changingUserId).FirstOrDefault();

I am trying to mock the repository with two setups to call it twice in the same test.

string emailAddress = "myaddresss@test.com";
int changingUserId = 5;

    var targetUsers = new List<ApplicationUser>
        {
            new ApplicationUser { Id = 1, Password = "Testing123", EmailAddress = emailAddress }
        };

// Setup the user that will be modified to be found
var mockApplicationUserRepository = new Mock<IRepository<ApplicationUser>>();
    mockApplicationUserRepository
            .Setup(aur => aur.Get(x => x.EmailAddress == userName, null, string.Empty))
            .Returns(targetUsers.AsEnumerable());


    // Set up to query the changing user to not be found
    mockApplicationUserRepository
        .Setup(aur2 => aur2.Get(x => x.Id == changingUserId, null, string.Empty))
        .Returns(new List<ApplicationUser>().AsEnumerable());   // Empty list

Even though the second call will never be hit, for this test, I want to learn how to set this up. When I run the test the first call

var user = this.applicationUserRepository.Get(x => x.EmailAddress == userName).FirstOrDefault();

I get null

If I change the mock to have

It.IsAny<Expression<Func<ApplicationUser, bool>>>()

I get the expected user back.

I can not figure out how I will set the two calls up so it will know which expression to use. Any help will be appreciated.

score 2 · Accepted Answer · edited May 23 '17 at 10:26

The problem is that Moq does not compare the expressions you use (only reference equality).

Using this little helper class:

public static class LambdaCompare
{
    public static bool Eq<TSource, TValue>(
        Expression<Func<TSource, TValue>> x,
        Expression<Func<TSource, TValue>> y)
    {
        return ExpressionsEqual(x, y, null, null);
    }

    public static Expression<Func<Expression<Func<TSource, TValue>>, bool>> Eq<TSource, TValue>(Expression<Func<TSource, TValue>> y)
    {
        return x => ExpressionsEqual(x, y, null, null);
    }

    private static bool ExpressionsEqual(Expression x, Expression y, LambdaExpression rootX, LambdaExpression rootY)
    {
        if (ReferenceEquals(x, y)) return true;
        if (x == null || y == null) return false;

        var valueX = TryCalculateConstant(x);
        var valueY = TryCalculateConstant(y);

        if (valueX.IsDefined && valueY.IsDefined)
            return ValuesEqual(valueX.Value, valueY.Value);

        if (x.NodeType != y.NodeType
            || x.Type != y.Type) return false;

        if (x is LambdaExpression)
        {
            var lx = (LambdaExpression) x;
            var ly = (LambdaExpression) y;
            var paramsX = lx.Parameters;
            var paramsY = ly.Parameters;
            return CollectionsEqual(paramsX, paramsY, lx, ly) && ExpressionsEqual(lx.Body, ly.Body, lx, ly);
        }
        if (x is MemberExpression)
        {
            var mex = (MemberExpression) x;
            var mey = (MemberExpression) y;
            return Equals(mex.Member, mey.Member) && ExpressionsEqual(mex.Expression, mey.Expression, rootX, rootY);
        }
        if (x is BinaryExpression)
        {
            var bx = (BinaryExpression) x;
            var by = (BinaryExpression) y;
            return bx.Method == @by.Method && ExpressionsEqual(bx.Left, @by.Left, rootX, rootY) &&
                   ExpressionsEqual(bx.Right, @by.Right, rootX, rootY);
        }
        if (x is ParameterExpression)
        {
            var px = (ParameterExpression) x;
            var py = (ParameterExpression) y;
            return rootX.Parameters.IndexOf(px) == rootY.Parameters.IndexOf(py);
        }
        if (x is MethodCallExpression)
        {
            var cx = (MethodCallExpression)x;
            var cy = (MethodCallExpression)y;
            return cx.Method == cy.Method
                   && ExpressionsEqual(cx.Object, cy.Object, rootX, rootY)
                   && CollectionsEqual(cx.Arguments, cy.Arguments, rootX, rootY);
        }

        throw new NotImplementedException(x.ToString());
    }

    private static bool ValuesEqual(object x, object y)
    {
        if (ReferenceEquals(x, y))
            return true;
        if (x is ICollection && y is ICollection)
            return CollectionsEqual((ICollection) x, (ICollection) y);

        return Equals(x, y);
    }

    private static ConstantValue TryCalculateConstant(Expression e)
    {
        if (e is ConstantExpression)
            return new ConstantValue(true, ((ConstantExpression) e).Value);
        if (e is MemberExpression)
        {
            var me = (MemberExpression) e;
            var parentValue = TryCalculateConstant(me.Expression);
            if (parentValue.IsDefined)
            {
                var result =
                    me.Member is FieldInfo
                        ? ((FieldInfo) me.Member).GetValue(parentValue.Value)
                        : ((PropertyInfo) me.Member).GetValue(parentValue.Value);
                return new ConstantValue(true, result);
            }
        }
        if (e is NewArrayExpression)
        {
            var ae = ((NewArrayExpression) e);
            var result = ae.Expressions.Select(TryCalculateConstant);
            if (result.All(i => i.IsDefined))
                return new ConstantValue(true, result.Select(i => i.Value).ToArray());
        }

        return default(ConstantValue);
    }

    private static bool CollectionsEqual(IEnumerable<Expression> x, IEnumerable<Expression> y, LambdaExpression rootX, LambdaExpression rootY)
    {
        return x.Count() == y.Count()
               && x.Select((e, i) => new {Expr = e, Index = i})
                   .Join(y.Select((e, i) => new { Expr = e, Index = i }),
                         o => o.Index, o => o.Index, (xe, ye) => new { X = xe.Expr, Y = ye.Expr })
                   .All(o => ExpressionsEqual(o.X, o.Y, rootX, rootY));
    }

    private static bool CollectionsEqual(ICollection x, ICollection y)
    {
        return x.Count == y.Count
               && x.Cast<object>().Select((e, i) => new { Expr = e, Index = i })
                   .Join(y.Cast<object>().Select((e, i) => new { Expr = e, Index = i }),
                         o => o.Index, o => o.Index, (xe, ye) => new { X = xe.Expr, Y = ye.Expr })
                   .All(o => Equals(o.X, o.Y));
    }

    private struct ConstantValue
    {
        public ConstantValue(bool isDefined, object value) : this()
        {
            IsDefined = isDefined;
            Value = value;
        }

        public bool IsDefined { get; private set; }

        public object Value { get; private set; }
    }
}

you can setup your mock like this:

Expression<Func<ApplicationUser, bool>> expr = x => x.EmailAddress == emailAddress;
    var mockApplicationUserRepository = new Mock<IRepository<ApplicationUser>>();
    mockApplicationUserRepository
            .Setup(aur => aur.Get(It.Is<Expression<Func<ApplicationUser, bool>>>(x => LambdaCompare.Eq(x, expr)), null, string.Empty))
            .Returns(targetUsers.AsEnumerable());

score 0 · Answer 2 · edited May 16 '18 at 08:37

0

Just adding a comment to this old answer (though quite useful code)

This version of LambdaCompare class is missing a case to compare an UnaryExpression, something which is included in the code in the original post.

Use that code instead of this (I learnt the hard way...)

edited May 16 '18 at 08:37

Eric Aya

69,473
35
181
253

answered May 16 '18 at 07:55

agascon

718
1
6
25

Mock same method in a test using Moq with different linq expressions

2 Answers2