¿Cuándo usar el burlarse frente a la falsificación en las pruebas de la unidad C#?

Question

¿Alguien puede proponer pautas que sugieran los escenarios ideales para elegir la burla y la falsificación, es decir, configurar los elementos esenciales manualmente?

Estoy un poco confundido con la forma de abordar esta situación.

Answer 1

Bueno, tiene algunas cosas que debe resolver. Tienes dos cosas básicas que necesitarás saber: nomenclatura y mejores prácticas.

En primer lugar quiero darle un gran recurso de vídeo desde una gran probador, Roy Osherove:

la unidad de pruebas críticas de Roy Osherove

Él comienza diciendo que tiene hecho algunas revisiones de los arneses de prueba enviados con varios proyectos de código abierto . Puedes leer esos artículos aquí: http://weblogs.asp.net/rosherove/archive/tags/TestReview/default.aspx

Estas son básicamente las opiniones de vídeo donde le guía a través de estas pruebas arneses y le dice lo que es bueno y lo que es malo. Muy útil.

Roy también tiene un libro que entiendo es muy bueno.

Nomenclatura

Este podcast ayudará a cabo inmensamente: http://www.hanselminutes.com/default.aspx?showID=187

Voy a parafrasear el podcast, aunque (que es música de la introducción Hanselminutes terrible):

Básicamente todo Hing lo haces con un framework de aislamiento (como Moq, Rhino Mocks, Type Mock, etc.) se llama falso.

Un falsa es un objeto en uso durante una prueba de que el código que está probando puede llamar en lugar del código de producción. Una falsificación se utiliza para aislar el código que está tratando de probar desde otras partes de su aplicación .

Hay (principalmente) dos tipos de falsificaciones: talones de y burla.

Un simulacro es una falsificación que se pone en lugar para que el código que está probando puede llamar a él y afirmar que la llamada fue hecha con los correctos parámetros . El ejemplo siguiente hace justamente esto usando el aislamiento Moq marco:

[TestMethod] 
public void CalculateTax_ValidTaxRate_DALCallIsCorrect() 
{ 
    //Arrange 
    Mock<ITaxRateDataAccess> taxDALMock = new Mock<ITaxRateDataAccess>(); 
    taxDALMock.Setup(taxDAL => taxDAL.GetTaxRateForZipCode("75001")) 
        .Returns(0.08).Verifiable(); 

    TaxCalculator calc = new TaxCalculator(taxDALMock.Object); 

    //Act 
    decimal result = calc.CalculateTax("75001", 100.00); 

    //Assert 
    taxDALMock.VerifyAll(); 
} 

Un talón de es casi lo mismo que un simulacro de , salvo que se pone en su lugar para asegurarse de que el código que está probando recupera datos consistentes de su llamada (por ejemplo, si su código llama a una capa de acceso a datos, un stub sería devuelve datos falsos), pero no lo hace afirmar contra el mismo stub. Que es, no importa verificar que el método llamó a su capa de acceso de datos falso - está intentando probar algo más. Proporcione el código auxiliar para obtener el método que está tratando de probar para trabajar de forma aislada.

He aquí un ejemplo con un talón:

[TestMethod] 
public void CalculateTax_ValidTaxRate_TaxValueIsCorrect() 
{  
    //Arrange 
    Mock<ITaxRateDataAccess> taxDALStub = new Mock<ITaxRateDataAccess>(); 
    taxDALStub.Setup(taxDAL => taxDAL.GetTaxRateForZipCode("75001")) 
        .Returns(0.08); 

    TaxCalculator calc = new TaxCalculator(taxDALStub.Object); 

    //Act 
    decimal result = calc.CalculateTax("75001", 100.00); 

    //Assert 
    Assert.AreEqual(result, 8.00); 
} 

Note aquí que estamos probando la salida del método, en lugar de la hecho de que el método realiza una llamada a otro recurso.

Moq realmente no hace una distinción entre el API una maqueta y un talón (nótese que ambos fueron declarados como Mock<T>), pero el uso aquí es importante en la determinación del tipo.

Espero que esto ayude a enderezarlo.

Answer 2

Quiere probar un trozo de código, correcto, digamos un método. Su método descarga un archivo de una url http, y luego guarda el archivo en el disco, y luego envía por correo que el archivo está en el disco. Todas estas tres acciones son, por supuesto, clases de servicio que su método llama, porque entonces son fáciles de burlar. Si no se burla de esto, su prueba descargará cosas, accederá al disco y enviará un mensaje por correo cada vez que ejecute esa prueba. Entonces no solo está probando el código en el método, sino que también está probando el código que descarga, escribe en el disco y envía un correo. Ahora si te estás burlando de estos, estás probando solo el código de métodos. También puede simular una falla de descarga, por ejemplo, para ver que el código de su método se comporta correctamente.

Ahora, en cuanto a la falsificación, suelo falsificar clases que solo tienen valores y no tienen mucha lógica. Si está enviando un objeto que contiene algunos valores, que cambian en el método, puede leerlo en la prueba para ver si el método hace lo correcto.

Por supuesto, las reglas pueden (y algunas veces deben) doblarse un poco, pero la forma general de pensar es probar su código, y su código solamente.

Answer 3

Existen en total 5 tipos diferentes de pruebas dobles: maniquíes, stubs, mocks, spies y fakes. Una buena descripción está en http://code.google.com/testing/TotT-2008-06-12.pdf y también se clasifican en http://xunitpatterns.com/Mocks,%20Fakes,%20Stubs%20and%20Dummies.html

Answer 4

The Little Mocker, de Bob Martin, es una muy buena lectura sobre el tema.

[...] hace mucho tiempo, algunas personas muy inteligentes escribieron un documento que introdujo y definió el término Objeto simulado. Muchas otras personas lo leyeron y comenzaron a usar ese término. Otras personas, que no habían leído el documento, escucharon el término y comenzaron a usarlo con un significado más amplio. Incluso convirtieron la palabra en un verbo.Ellos decían: "Vamos a burlarnos de ese objeto" o "Tenemos que burlarnos mucho de ellos".

El artículo explica las diferencias entre burla de, falsificaciones, spys y talones.