¿Qué es un buen marco de burla para empezar a burlarse en asp.net MVC? (novato y probablemente no un imbécil hardcore)

Question

quiero usar burla en mis pruebas unitarias.

Hasta ahora he programado más 'pruebas' y no 'pruebas unitarias' porque probé los flujos completos del programa, pero leyendo las discusiones puedo ver la belleza de un objeto simulado, de vez en cuando.

Pero, mirando a su alrededor, hay una gran cantidad de marcos disponibles, y quiero asegurarme de comenzar con uno bueno, porque me gustaría invertir tiempo en aprender un marco simulado una sola vez.

Así que como dije en el título, soy un novato de la burla, usando asp.net mvc, y no creo que vaya a ser un burlador incondicional, investigando los bordes de un marco de burla.

Para darle una idea de lo que me gusta en los marcos de IOC me gusta unity y structuremap.

Michel

Answer 1

He usado tanto Rhino Mocks como Moq como parte de ASP.NET MVC projects con gran éxito. Si bien en el pasado estos marcos diferían bastante, sus conjuntos de características han convergido a lo largo de los años, por lo que cualquiera de los dos sería una buena opción.

Dado que se dirige específicamente a MVC, también debería considerar what Phil Haack has to say.

Answer 2

lo recomiendo Moq. Intenté anteriormente con Rhino, pero personalmente encuentro que la API de Moq es más astuta.

Answer 3

Recomiendo Moq.

Digamos que tienes una clase MyClass define de la siguiente manera:

public class MyClass{ 

    private IMyDependency dependency; 

    public MyClass(IMyDependency dependency){ 
     this.dependency = dependency; 
    } 

    public void DoSomething(){ 
     //invoke a method on the dependency 
     this.dependency.DoWork(); 
    } 

} 

IMyDependency se declara así:

public interface IMyDependency{ 
    void DoWork(); 
} 

Ahora, utilizando Moq, usted podría probar que la dependencia se llama así:

public void DoSomethingWillInvokeDoWorkCorrectly() 
{ 
    var mock = new Mock<IMyDependency>(); 
    mock.Setup(imd => imd.DoWork()).Verifiable(); 
    var sut = new MyClass(mock.Object); 
    sut.DoSomething(); 
    //Verify that the mock was called correctly 
    mock.Verify(); 
} 

Ahora que era un ejemplo muy simple, así que condimentarlo un poco.

clase pública miclase2 {

private IMyDependency2 dependency; 

    public MyClass2(IMyDependency2 dependency){ 
     this.dependency = dependency; 
    } 

    public void DoSomething(int i){ 
     //invoke a method on the dependency 
     this.dependency.DoWork(i * 2); 
    } 

} 

IMyDependency2 se declara así:

public interface IMyDependency2{ 
    void DoWork(int i); 
} 

Un método de ensayo que prueba que el parámetro correcto se pasa a la dependencia podría tener este aspecto:

public void DoSomethingV2WillInvokeDoWorkCorrectly() 
{ 
    var mock = new Mock<IMyDependency2>(); 
    int parameter = 60; 
    mock.Setup(imd => imd.DoWork(It.Is<int>(i => i == 2 * parameter)).Verifiable(); 
    var sut = new MyClass2(mock.Object); 
    sut.DoSomething(parameter); 
    //Verify that the mock was called correctly 
    mock.Verify(); 
} 

Como puede ver, el Setup método ahora agrega una restricción en el parámetro pasado a DoWork, diciendo que es un int cuyo valor debe ser el doble del valor de la variable parameter.