Moq a function with 5+ parameters and access invocation arguments

Question

I have a function I want to Moq. The problem is that it takes 5 parameters. The framework only contains Action<T1,T2,T3,T4> and Moq's generic CallBack() only overloads Action and the four generic versions. Is there an elegant workaround for this?

This is what I want to do:

public class Filter : IFilter  
{  
    public int Filter(int i1, int i2, int i3, int i4, int i5){return 0;}  
}

//Moq code:
var mocker = new Mock<IFilter>();  
mocker.Setup(x => x.Filter(  
    It.IsAny<int>(),  
    It.IsAny<int>(),  
    It.IsAny<int>(),  
    It.IsAny<int>(),  
    It.IsAny<int>(),  
    It.IsAny<int>())  
.Callback
(  
    (int i1, int i2, int i3, int i4, int i5) => i1 * 2  
);  

Moq doesn't allow this because there is no generic Action that takes 5+ parameters. I've resorted to making my own stub. Obviously, it would be better to use Moq with all of its verifications, etc.

Text

Probably not going to help you, but in .NET 4.0 Action<T> can take up to 16 parameters! – Astilbe

Even if you were in .NET 4.0, Moq still only supports a maximum of 4 parameters in its latest beta. To fix it, you would have to download the source and roll your own. – Gillen

You could use an extension method – Paleoecology

Answer 1

This is supported in the final release of Moq 4.0 (4.0.10827), which was released on April 12, 2011. If you're using .NET 4, you'll be able to mock up to 16 parameters.

Walleyed

Answer 2

I know this is an old post, but I thought this code may help others having this problem with an older version of Moq. Here's an example with 5 and 6 arguments, and it can be extended to support any number.

I have tested this with version 3.1.0.0, but it should it should work with other versions too.

The secret is to use reflection to access the protected method 'SetCallbackWithArguments' on the underlying class...

Hope this is of use to someone!

public delegate void Action<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
public delegate void Action<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);

public static class MoqExtensions
{
    public static ICallbackResult Callback<T1, T2, T3, T4, T5>(this ICallback call, Action<T1, T2, T3, T4, T5> callback)
    {
        call.SetCallbackWithArguments(callback);
        return (ICallbackResult)call;
    }

    public static ICallbackResult Callback<T1, T2, T3, T4, T5, T6>(this ICallback call, Action<T1, T2, T3, T4, T5, T6> callback)
    {
        call.SetCallbackWithArguments(callback);
        return (ICallbackResult)call;
    }

    public static void SetCallbackWithArguments(this ICallback call, Delegate callback)
    {
        MethodInfo methodInfo = call.GetType().GetMethod("SetCallbackWithArguments", BindingFlags.NonPublic | BindingFlags.Instance);
        methodInfo.Invoke(call, new object[] { callback });
    }
}

Banzai

Answer 3

I know this probably breaks your design, but with that many parameters wouldn't it be better to pass a param array?

Gillen

+1, although a Parameter Object might be better if the arguments represent different concepts – Horsemint

As you alluded to in your next response, I would need to change Moq itself since it doesn't allow for this overload. Regardless, I need generics so I can access the invocation parameters. – Text

Actually, as Mark points out, a better solution is to pass an object containing all of the parameters you need. Of course, that will change the way you mock it. – Gillen

Answer 4

Use an extension method to extend the moq framework if you dont want to modify the source.

//Extension Method

    public static class MoqExtensions
    {
        public static void Callback<T1, T2, T3, T4, T5>(this ICallback iCallBack, Action<T1, T2, T3, T4, T5> action)
        {
        }
    }

//Your class and interface

        public interface IMyClass
        {
            void Method(string arg1, string arg2, string arg3, string arg4, string arg5);
        }

        public class MyClass : IMyClass
        {
            public void Method(string arg1, string arg2, string arg3, string arg4, string arg5)
            {
                //Do something
            }
        }

//Your test

        [TestMethod]
        public void ExampleTest()
        {
            Mock<IMyClass> mockMyClass = new Mock<IMyClass>();
            mockMyClass.Setup(s => s.Method(It.IsAny<string>(),
                                            It.IsAny<string>(),
                                            It.IsAny<string>(),
                                            It.IsAny<string>(),
                                            It.IsAny<string>()))
                .Callback<string, string, string, string, string>((string arg1, string arg2, string arg3, string arg4, string arg5) 
                    => { /* Run your mock here */ });
        }

Paleoecology

Then what? I still need to write my own method, which isn't any easier than modifying the source code. – Text

I updated my code example to give a simple example. All you are doing is extending the ICallback interface that is part of the moq framework. Are you familiar with creating extension methods? – Paleoecology

Your extension method doesn't actually do anything, so how would it work, beyond just not making the compiler complain? – Walleyed

It works fine. Dont just cast down votes because you cant cant get it to work. Can you give a sample of what your doing. – Paleoecology

See answer from Paul Wardle, which actually accomplishes what this is attempting. – Bee

Answer 5

delegate void SubmitCallback(Bar bar1,Bar bar2,Bar bar3,Bar bar4,Bar bar5);

mock.Setup(foo => foo.Submit(It.IsAny<Bar>(),It.IsAny<Bar>(),It.IsAny<Bar>(),It.IsAny<Bar>(),It.IsAny<Bar>()))
    .Callback(new SubmitCallback((Bar bar1,Bar bar2,Bar bar3,Bar bar4,Bar bar5) => Console.WriteLine("Submitting a Bar!")));

You can use more than 16 aguments by delegate. :)

Brom

Answer 6

This is actually quite simple. Just define your own Action<T1, T2, T3, T4, T5> and you're good to go.

public delegate void Action<T1, T2, T3, T4, T5>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);

This is all that the Action, Action<T>, ..., Action<T1, T2, T3, T4> are defined as in the framework. Nothing more. Simple!

Adriaadriaens

You would still have to modify the Moq source code to support more than four parameters in a callback. – Gillen

@"Robert Harvey" - Yes, you're right. I overlooked that. Perhaps Currying could be of use? – Adriaadriaens

Changing Moq overloads to take an Action of 5+ parameters is the only solution I see. What do you mean by "currying"? – Text