Thanks to @MarkSeemann for some hints, I get a solution to this "problem".

My thinking

I started with the MockRelay class in the AutoFixture.AutoMoq nuget package. I have created an overload of MockRelayExtras and I will add this to AutoMoqCustomozation.

What it will do is reflect the interface or abstract class and adjust the mock accordingly

ex.

Mock.Get(TInterface.Instance)
    .Setup( i => i.Method( It.IsAny<TParamType>() ) )
    .Returns( () => fixture.Create<TMethodResult>() );

      

        
        
        
      

    

For now this will only work for interfaces and abstract classes (no constructors)

Its beginning. However, the code needs some cleaning up. Also, I hope other people will like, enjoy and use this?

Happy coding!

Complete code

This is a working solution with some kind of basic test proving it works.

app.config

(this fixes the repeated call to en test runner)

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="Moq" publicKeyToken="69f491c39445e920" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-4.2.1408.717" newVersion="4.2.1408.717" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="nunit.core.interfaces" publicKeyToken="96d09a1eb7f44a77" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-2.6.3.13283" newVersion="2.6.2.12296" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>

      

        
        
        
      

    

nuget packages:

<packages>
  <package id="AutoFixture" version="3.19.2" targetFramework="net45" />
  <package id="AutoFixture.AutoMoq" version="3.19.2" targetFramework="net45" />
  <package id="AutoFixture.NUnit2" version="3.19.2" targetFramework="net45" />
  <package id="Moq" version="4.2.1408.0717" targetFramework="net45" />
  <package id="NUnit" version="2.6.3" targetFramework="net45" />
</packages>

      

        
        
        
      

    

Attribute

public class AutoMoqDataAttribute : AutoDataAttribute
{
    public AutoMoqDataAttribute()
        : base(new Fixture().Customize(new AutoMoqCustomization(new MockRelayExtras())))
    {

    }
}

      

        
        
        
      

    

Updated class MockRelay

public class MockRelayExtras : MockRelay, ISpecimenBuilder
{
    public new object Create(object request, ISpecimenContext context)
    {
        object result = base.Create(request, context);

        var requestType = request as Type;
        if (requestType != null && result != null)
        {
            SetupMockWithInterface(requestType, result, context);
        }

        return result;
    }

    public static void SetupMockWithInterface(Type requestType, object result, ISpecimenContext context)
    {
        typeof (MockRelayExtras).GetMethod("SetupMockWithInterfaceGeneric")
            .MakeGenericMethod(requestType).Invoke(null, new[] {result, context});
    }

    public static void SetupMockWithInterfaceGeneric<TType>(TType result, ISpecimenContext context)
        where TType : class
    {
        //Mock.Get(stubMock).Setup(r => r.GetObject(It.IsAny<int>())).Returns(() => myObject);
        Mock<TType> genericMock = Mock.Get(result);

        foreach (MethodInfo methodInfo in typeof (TType).GetMethods())
        {
            // ISetup<TType,TMethodResult> setup = genericMock.Setup<TType,TMethodResult>( methodInfo )
            object setup =
                typeof (MockRelayExtras).GetMethod("SetupAsGenericFunc")
                    .MakeGenericMethod(typeof (TType), methodInfo.ReturnType)
                    .Invoke(null, new object[] {methodInfo, genericMock});

            // setup.Returns( () => context.Create<TResult>() )
            typeof (MockRelayExtras).GetMethod("SetupReturnsAsGenericFunc")
                .MakeGenericMethod(typeof (TType), methodInfo.ReturnType)
                .Invoke(null, new[] {setup, context});
        }
    }

    public static ISetup<TMock, TResult> SetupAsGenericFunc<TMock, TResult>(MethodInfo method, Mock<TMock> mock)
        where TMock : class
    {
        ParameterExpression input = Expression.Parameter(typeof (TMock));

        ParameterInfo[] parameters = method.GetParameters();

        Expression<Func<TMock, TResult>> setup = null;

        if (parameters.Length > 0)
        {
            IEnumerable<MethodCallExpression> properties =
                parameters.Select(
                    pi => Expression.Call(typeof (It), "IsAny", new[] {pi.ParameterType}, new Expression[0]));
            setup = Expression.Lambda<Func<TMock, TResult>>(
                Expression.Call(input, method, properties), input);
        }
        else
        {
            setup = Expression.Lambda<Func<TMock, TResult>>(
                Expression.Call(input, method), input);
        }


        return mock.Setup(setup);
    }

    public static void SetupReturnsAsGenericFunc<TMock, TResult>(ISetup<TMock, TResult> setup,
        ISpecimenContext context)
        where TMock : class
    {
        setup.Returns(() => context.Create<TResult>());
    }
}

      

        
        
        
      

    

Tests

[TestFixture]
public class MockRelayExtrasTests
{
    public class RelayTestClass
    {
        public int Id { get; set; }
    }

    public class RandomInputData
        {
            public int Prop1 { get; set; }
            public string Prop2 { get; set; }
        }

    public interface ISingleResultNoInput
    {
        RelayTestClass SingleResultNoInput();
        IEnumerable<RelayTestClass> ListResultNoInput();
        RelayTestClass GetItemById(int id);
        RelayTestClass GetItemById(int id, string randomSearch);
        RelayTestClass GetItemBySearch(RandomInputData data);
    }

    [Test, AutoMoqData]
    public void Create_AutoMockInterfaceIEnumerableResults_InterfaceIsSetupWithIEnumerable(
        [Frozen] RelayTestClass itemTemplate,
        [Frozen] ISingleResultNoInput sut,
        [Frozen] IFixture fixture
        )
    {
        List<RelayTestClass> result = sut.ListResultNoInput().ToList();
        Assert.That(result[0], Is.EqualTo(itemTemplate));
    }

    [Test, AutoMoqData]
    public void Create_AutoMockInterfaceMethodsAutoMoqData_InterfaceIsSetup(
        [Frozen] RelayTestClass frozenItem, [Frozen] ISingleResultNoInput sut, int expectedId)
    {
        frozenItem.Id = expectedId;
        RelayTestClass result = sut.SingleResultNoInput();
        Assert.That(result.Id, Is.EqualTo(expectedId));
    }

    [Test, AutoMoqData]
    public void Create_AutoMockInterfaceMethodParameter_InterfaceIsSetup(
        [Frozen] RelayTestClass frozenItem, [Frozen] ISingleResultNoInput sut, int id)
    {
        frozenItem.Id = id;
        RelayTestClass result = sut.GetItemById(id);
        Assert.That(result.Id, Is.EqualTo(id));
    }

    [Test, AutoMoqData]
    public void Create_AutoMockInterfaceMethodsAutoMoqDataMultipleInput_InterfaceIsSetup(
        [Frozen] RelayTestClass frozenItem, [Frozen] ISingleResultNoInput sut, int id, string searchString)
    {
        frozenItem.Id = id;
        RelayTestClass result = sut.GetItemById(id, searchString);
        Assert.That(result.Id, Is.EqualTo(id));
    }

    [Test, AutoMoqData]
    public void Create_AutoMockInterfaceMethodsAutoMoqDataComplexInput_InterfaceIsSetup(
        [Frozen] RelayTestClass frozenItem, [Frozen] ISingleResultNoInput sut, RandomInputData input)
    {
        frozenItem.Id = input.Prop1;
        RelayTestClass result = sut.GetItemBySearch(input);
        Assert.That(result.Id, Is.EqualTo(input.Prop1));
    }
}

      

        
        
        
      

    

automatically generated add-on by package

[NUnitAddin]
public class LocalAddin : Addin
{
}