¿Alguien puede explicar el enfoque "Fake it till you it it" en Test Driven Development?

Tengo un problema para comprender la evolución del código cuando ha adoptado el enfoque TDD "Fake It Until You Make IT".¿Alguien puede explicar el enfoque "Fake it till you it it" en Test Driven Development?

Ok, lo ha fingido, digamos que ha devuelto una constante para que la prueba dañada sea verde al principio. Luego volviste a factorizar tu código. ¡Entonces ejecutas la misma prueba que va a pasar obviamente porque la has falsificado!

Pero si pasa una prueba, ¿cómo puedes confiar en eso, especialmente cuando sabes que lo fingiste?

¿Cómo se debe refactorizar la prueba falsa con la refactorización de código real para que siga siendo confiable?

Gracias

Fuente

2010-11-12 pencilCake

FWIW si adopta esta estrategia, le recomiendo encarecidamente que utilice una herramienta de productividad para desarrolladores, como Jetbrains Resharper, ya que acelerará en gran medida su capacidad para hacerlo. –

Una sola constante devuelta por un método es técnicamente la forma más sencilla de hacer que una prueba tenga éxito. Sin embargo, es muy probable que tenga múltiples pruebas de corroboración para cualquier método, y se necesitará más que una constante para pasarlos a todos. – mellamokb

crear por primera vez una prueba de unidad de prueba nueva funcionalidad que no existe.

Ahora, tiene una prueba unitaria para un método no existente. Luego creas ese método que no hace nada y tu unidad de prueba compila, pero por supuesto, falla.

Luego sigue construyendo su método, funcionalidad subyacente, etc. hasta que la prueba de su unidad sea exitosa.

Eso es (tipo de) desarrollo impulsado por pruebas.

La razón por la que debe poder confiar en esto es que debe hacer su prueba de unidad para que realmente pruebe su funcionalidad. Por supuesto, si solo devuelve una constante y simplemente prueba sobre eso, usted tiene un problema. Pero luego, su prueba de unidad no está completa.

Las pruebas unitarias deben (en teoría) probar cada línea. Y si lo has hecho bien, esto debería funcionar.

Fuente

2010-11-12 15:52:10

Una prueba de unidad no debe probar cada línea. Un método con una condición de falla tendrá una prueba solo para esa condición y pruebas adicionales para cada condición adicional de éxito/falla. Por lo tanto, pocas pruebas, incluso en teoría, alguna vez probarán cada línea. –

Lo que quiero decir con "cada línea" es la cobertura del código. Sé lo que quieres decir, pero creo que todos estos términos son relativos porque la cobertura del 100% del código significa técnicamente cada línea. Por supuesto, no es posible verificar la existencia de cada línea de código en su código, pero está probando si el código que espera estar allí está allí. Cambió "prueba" a "pruebas" :). –

@PietervanGinkel Hay muchos tipos de métricas para la cobertura de código, se refiere a la cobertura de extracto. La cobertura de código 100% no necesita significar cada línea. Esta respuesta es una descripción de TDD, pero no toca el "falso hasta que lo hagas", la estrategia utilizada en TDD. – Alex

La respuesta corta es: escriba más pruebas.

Si el método devuelve una constante (cuando debería calcular algo), simplemente agregue una prueba para una condición con un resultado diferente. Por lo tanto, vamos a decir que tenía el siguiente:

@Test 
public void testLength() 
{ 
    final int result = objectUnderTest.myLength("hello"); 
    assertEquals(5, result); 
}

y myLength se implementó como return 5, a continuación, se escribe un (adicional) prueba similar, pero pasa en "foobar" lugar y afirmar que la salida es 6.

Cuando está escribiendo pruebas, debe tratar de ser muy vengativo contra la implementación y tratar de escribir algo que exponga sus deficiencias. Cuando está escribiendo código, creo que está destinado a ser muy laissez-faire y hacer tan poco se requiere para hacer esas pruebas repugnantes verde.

Fuente

2010-11-12 15:59:46

Pero suena como Triangulación que el patrón de "Falsifíquelo hasta que lo hagas", ¿no crees? – pencilCake

Creo que la triangulación y la falsificación hasta que lo hagas están relacionadas. FITYMI es "hacer lo más simple que podría funcionar". Cuando escribe su primer caso de prueba, lo más simple es simplemente devolver la respuesta correcta. ¡Hurra! Tenemos una prueba de aprobación. ¿Terminamos? Claramente no, porque si toda la implementación fuera así de simple, probablemente ni siquiera la estemos escribiendo y en lugar de eso solo usaremos una constante. Fingir hasta que lo hagas solo te ayuda a obtener bootstrapped y continuar con la próxima prueba que desarrolla el sistema. Puedo usar "Fake it" para la primera prueba, pero raramente sobrevive la segunda o tercera prueba. – legalize

Esto se puede estar refiriendo a la práctica de usar mocks/stubs/falsificaciones con las que colabora su sistema/clase bajo prueba.

En este escenario, "falsifica" al colaborador, no lo que está probando, porque no tiene una implementación de la interfaz de este colaborador.

Por lo tanto, lo falsifica hasta que "lo hace", lo que significa que lo implementa en una clase concreta.

Fuente

2010-11-12 16:15:21 Jay

Esto suena como una respuesta razonable. No solo puede que no haya implementado el colaborador, incluso puede ser perjudicial usarlo en un entorno de prueba. Piensa en interactuar con una base de datos real, por ejemplo. – helpermethod

Fake it 'till you make it dice que escribir lo más simple posible para pasar sus pruebas actuales. Con frecuencia, cuando ha escrito un caso de prueba único para una nueva característica, lo más simple posible es devolver una constante. Cuando algo tan simple satisface tus pruebas, es porque aún no tienes suficientes pruebas. Así que escriba otra prueba, como dice @Andrzej Doyle. Ahora la característica que está desarrollando necesita algo de lógica. Quizás esta vez lo más simple posible sea escribir una lógica if-else muy básica para manejar sus dos casos de prueba. Usted sabe está fingiendo, para que sepa que no ha terminado. Cuando sea más fácil escribir el código real para resolver su problema que extender su falso para cubrir otro caso de prueba, eso es lo que hace. Y tienes suficientes casos de prueba para asegurarte de que lo estás escribiendo correctamente.

Fuente

2010-11-12 22:30:36

En TDD, todos los requisitos se expresan como pruebas. Si falsifica algo y todas las pruebas pasan, sus requisitos se cumplen. Si esto no le está dando el comportamiento esperado, entonces no ha expresado todos sus requisitos como pruebas.

Si continúa falsificando cosas en este punto, eventualmente notará que la solución más fácil sería resolver el problema.

Fuente

2014-01-28 07:17:52 Alex

¿Alguien puede explicar el enfoque "Fake it till you it it" en Test Driven Development?

Respuesta

Cuestiones relacionadas