¿Cómo crear Mock para la clase base abstracta utilizando el marco MOQ?

Question

Quiero escribir pruebas unitarias para MyClass pero su clase base es una clase abstracta.

public class MyClass : AbstractBaseClass 
{ 
} 

Quiero burlarse de la clase AbstractBase, de modo que pueda pasar por alto algunos de la lógica en su constructor cuando se crea la instancia MiClase quiero probar. ¿Hay alguna forma de que pueda hacer esto?

//Unit Test 
var test = new Mock<IInterface>(); 
var derivedclass = new DerivedClass(test.Object); 

test.Setup(d=>d.MyMethod(It.IsAny<string>()).returns(2); 
derivedclass.MyMethod("hello"); 


// Derived Class 
class DerivedClass : AbstractClass{ 

    //constuctor 
    public DerivedClass(IInterface interface){ 
     _interface = interface; 
    } 
    public MyMethod(string str){ 
     return 2; 
    } 
} 

//Abstract Class 
public abstract class AbstractClass 
{ 

// This method gets called when i create the instance of the derived class in my unit 
    test.. 

    protected AbstractedClass() : this(new SomeOtherClass()){ 
     DoSomethingElse(); /// I want to skip this method or mock it. 
    } 
} 

Answer 1

heredando de la clase base se está extendiendo. Se trata más de obtener su código en un estado comprobable en lugar de tener Moq para usted.

1. Puede utilizar la composición en lugar de una clase base y luego usar la inyección de dependencia (a través de una interfaz) que puede simular.
2. O si tiene que heredar, extraiga la lógica que no desea ejecutar en otra clase que inyecte nuevamente a través de la inyección de dependencia.

3. O tiene esa lógica que no desea ejecutar sea parte de un método virtual que puede simular. (Como respuesta :) de @Ohad Horesh

   public virtual void DoSomethingElse(); 
   
   mock.Setup(abs => abs.Foo()); //here the mocked method will be called 
              // rather than the real one 
   

Si estas opciones no son viables a continuación, usted tendrá que poner a prueba esa funcionalidad a través de la clase derivada o utilizar otro marco de burla como Typemock aislador, lunares o JustMock .

Answer 2

Sí, este es un escenario bastante básico en Moq.
Asumiendo que su clase abstracta tiene el siguiente aspecto:

public class MyClass : AbstractBaseClass 
{ 
    public override int Foo() 
    { 
     return 1; 
    } 
} 

Usted puede escribir la siguiente prueba:

[Test] 
public void MoqTest() 
{ 
    var mock = new Moq.Mock<AbstractBaseClass>();    
    // set the behavior of mocked methods 
    mock.Setup(abs => abs.Foo()).Returns(5); 

    // getting an instance of the class 
    var abstractBaseClass = mock.Object; 
    // Asseting it actually works :) 
    Assert.AreEqual(5, abstractBaseClass.Foo()); 
}