模拟从抽象类派生的抽象类

Question

I have two classes like this

public abstract class Foo<T> where T : Bar {
  public Bar Do(Bar obj) {
   //I cast to T here and the call the protected one.
  }
  ...
  protected abstract Bar Do(T obj);
}

public abstract class FooWithGoo<T> : Foo<T> where T:Bar {
  ...
}

Trying to mock this in a unit test using Moq with this line new Mock<FooWithGoo<Bar>>() gives me this exception.

System.ArgumentException: Type to mock must be an interface or an abstract or non-sealed class. ---> System.TypeLoadException: Method 'Do' in type 'Castle.Proxies.FooWithGoo``1Proxy' from assembly 'DynamicProxyGenAssembly2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' does not have an implementation.

Is there something I am doing wrong here? How can I mock this?

UPDATE: This shows the problem nicely for me.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
namespace UnitTestProject1
{

public class Bar
{

}

public class BarSub : Bar
{

}

public abstract class Foo<T> where T : Bar
{
    public Bar Do(Bar obj)
    {
        return null;
    }
    protected abstract Bar Do(T obj);
}

public abstract class FooWithGoo<T> : Foo<T> where T : Bar
{
    public FooWithGoo(string x)
    {

    }
}

[TestClass]
public class UnitTest1
{
    [TestMethod]
    public void TestMethod1()
    {
        var mock = new Mock<FooWithGoo<Bar>>("abc");
        FooWithGoo<Bar> foo = mock.Object;
    }

    [TestMethod]
    public void TestMethod2()
    {
        var mock = new Mock<FooWithGoo<BarSub>>("abc");
        FooWithGoo<BarSub> foo = mock.Object;
    }
}
}

Test1 fails while test 2 passes. The problem is that the generic abstract gets the same signature than the concrete method ... and it gets confused by that I guess.

Answer 1

I was able to reproduce your issue with the example provided.

I got TestMethod1 to pass by making Do a virtual method.

public abstract class Foo<T> where T : Bar {
    public virtual Bar Do(Bar obj) {
        return null;
    }
    protected abstract Bar Do(T obj);
}

Moq requires public methods to be either virtual or abstract in order to be able to mock their implementation.