prueba Unidad de métodos muy triviales (sí o no)

Question

Suponga que tiene un método:

public void Save(Entity data) 
{ 
    this.repositoryIocInstance.EntitySave(data); 
} 

escribirías una prueba de unidad en absoluto?

public void TestSave() 
{ 
    // arrange 
    Mock<EntityRepository> repo = new Mock<EntityRepository>(); 
    repo.Setup(m => m.EntitySave(It.IsAny<Entity>()); 

    // act 
    MyClass c = new MyClass(repo.Object); 
    c.Save(new Entity()); 

    // assert 
    repo.Verify(m => EntitySave(It.IsAny<Entity>()), Times.Once()); 
} 

porque más adelante si lo hace la implementación del método de cambio para hacer más "complejo" cosas como:

public void Save(Entity data) 
{ 
    if (this.repositoryIocInstance.Exists(data)) 
    { 
     this.repositoryIocInstance.Update(data); 
    } 
    else 
    { 
     this.repositoryIocInstance.Create(data); 
    } 
} 

... su unidad de prueba fracasaría pero probablemente no romper su aplicación ...

pregunta

¿Debo siquiera se molestan creación de pruebas unitarias en los métodos que no tiene ningún tipo de devolución * o ** no cambia nada fuera de la simulación interna?

Answer 1

Es cierto que su prueba depende de su implementación, que es algo que debe evitar (aunque a veces no es así de simple) y no es necesariamente malo. Pero se espera que este tipo de pruebas se rompa aunque su cambio no rompa el código.

Usted podría tener muchos enfoques para esto:

• Crear una prueba de que realmente va a la base de datos y comprobar si el estado se cambió como se esperaba (que no ser una pruebaunidad más)
• Cree un objeto de prueba que falsifique una base de datos y realice operaciones en memoria (otra implementación para su repositorioIocInstance) y verifique que el estado se modificó como se esperaba. Los cambios en la interfaz del repositorio también implicarían cambios en este objeto. Pero sus interfaces no deberían estar cambiando mucho, ¿verdad?
• Ver todo esto como demasiado caro, y usar su enfoque, que incidan sobre innecesariamente romper pruebas más tarde (pero una vez que la oportunidad es bajo, es bien tomar el riesgo)

Answer 2

La regla general es que usted prueba todas las cosas, que probablemente podrían romperse. Si está seguro de que el método es lo suficientemente simple (y se mantiene lo suficientemente simple) como para no ser un problema, déjelo salir con pruebas.

Lo segundo es que debe probar el contrato del método, no la implementación. Si la prueba falla luego de un cambio, pero no la aplicación, entonces su prueba no es la correcta. La prueba debe cubrir casos que son importantes para su aplicación. Esto debería garantizar que cada cambio al método que no rompa la aplicación tampoco falle la prueba.

Answer 3

Un método que no devuelve ningún resultado todavía cambia el estado de su aplicación. La prueba de su unidad, en este caso, debería probar si el nuevo estado es el deseado.

Answer 4

"la prueba de la unidad fallaría pero probablemente no rompería su aplicación"

Esto es - en realidad - muy importante saber. Puede parecer molesto y trivial, pero cuando alguien más comienza a mantener su código, es posible que haya hecho un cambio realmente malo para Guardar y (de manera improbable) quebrar la aplicación.

El truco está en priorizar.

Pruebe primero las cosas importantes. Cuando las cosas son lentas, agregue pruebas para cosas triviales.

Answer 5

No olvide que las pruebas unitarias no se limitan a probar el código. Se trata de permitirle determinar cuando el comportamiento cambia.

Así que es posible que tenga algo que es trivial. Sin embargo, su implementación cambia y puede tener un efecto secundario. Desea que su suite de pruebas de regresión lo cuente.

p. Ej. A menudo la gente dice que no debes probar setters/getters ya que son triviales. No estoy de acuerdo, no porque sean métodos complicados, sino que alguien puede cambiarlos inadvertidamente por ignorancia, escenarios de dedos gordos, etc.

Teniendo en cuenta todo lo que acabo de decir, definitivamente implementaría pruebas para lo anterior (a través de la burla , y/o tal vez vale la pena diseñar sus clases con la capacidad de prueba en mente y hacer que denuncien el estado, etc.)

Answer 6

Cuando hay ISN' En una afirmación en un método, esencialmente estás afirmando que las excepciones no se lanzan.

También estoy luchando con la cuestión de cómo probar el vacío público myMethod(). Supongo que si decide agregar un valor de retorno para la capacidad de prueba, el valor de retorno debe representar todos los hechos importantes necesarios para ver qué cambió sobre el estado de la aplicación.

public void myMethod() 

convierte

public ComplexObject myMethod() { 
DoLotsOfSideEffects() 
return new ComplexObject { rows changed, primary key, value of each column, etc }; 
} 

y no

public bool myMethod() 
    DoLotsOfSideEffects() 
    return true; 

Answer 7

La respuesta corta a tu pregunta es: Sí , debería métodos de prueba por el estilo.

Asumo que es importante que el método Save realidad guarda los datos. Si no escribe una prueba unitaria para esto, ¿cómo lo sabe?

Alguien más puede aparecer y eliminar esa línea de código que invoca el método EntitySave, y ninguna de las pruebas de unidad fallará. Más adelante, se preguntará por qué los artículos nunca se conservan ...

En su método, podría decir que cualquier persona que borre esa línea solo lo haría si tienen intenciones malignas, pero la cosa es: las cosas simples no lo hacen Para ser más simple, es mejor escribir las pruebas unitarias antes de que las cosas se compliquen.

Es no detalle de la implementación que el método Save invoca EntitySave en el repositorio; es parte del comportamiento esperado, y una parte bastante crucial, si se me permite decirlo. Desea asegurarse de que los datos se estén guardando realmente.

El hecho de que un método no devuelva un valor no significa que no valga la pena probarlo.En general, si observa una buena separación de comando/consulta (CQS), se espera que cualquier método de vacío cambie el estado de algo.

A veces ese algo es la clase en sí, pero otras veces, puede ser el estado de otra cosa. En este caso, cambia el estado del Repositorio, y eso es lo que debería probar.

Esto se llama prueba salidas Indirecta, en lugar de las salidas directas (valores de retorno) más normales.

El truco está en escribir pruebas unitarias para que no se rompan con demasiada frecuencia. Al usar Mocks, es fácil escribir accidentalmente Pruebas sobre especificadas, por lo que la mayoría de los simuladores dinámicos (como Moq) se configuran de manera predeterminada en el modo Stub, donde no importa cuántas veces invoque un método determinado.

Todo esto, y mucho más, se explica en el excelente xUnit Test Patterns.

Answer 8

Hazte dos preguntas. "¿Cuál es el equivalente manual de esta prueba unitaria?" y "¿vale la pena automatizar?". En su caso, sería algo así como:

¿Qué es el equivalente manual? - iniciar depurador - paso en "Guardar" método - paso en siguiente, asegúrese de que está dentro de la aplicación IRepository.EntitySave

¿Vale la pena la automatización? Mi respuesta es no". Es 100% obvio desde el código. De cientos de pruebas de residuos similares, no vi ninguna que fuera útil.