Test unitarios

Test Unitarios

Diseño al cubo : Plan TDD

Donostia, 06/05/2011

Plan TDDTest unitarios

Plan TDD Donewtech:Plan TDD Donewtech:

– Formación test unitariosFormación test unitarios

– Formación TDDFormación TDD

– Dojonewtech

– Coaching Carlos Blé a primeros de octubreCoaching Carlos Blé a primeros de octubre

Formación test unitariosTest unitarios

Agenda :Agenda :

– Tipos de test Tipos de test

– Test unitariosTest unitarios

– Mocks y StubsMocks y Stubs

– Tareas / etxeko-lanakTareas / etxeko-lanak

Tipos de test :Tipos de test :

– Test funcionales o aceptaciónTest funcionales o aceptación

Test que garantiza que el software hace lo que desea el usuario.– Test de integraciónTest de integración

Test que garantizan que el software se integra correctamente con los recursos externos: BBDD, LDAP, API externas, etc.

– Test de rendimientoTest de rendimiento

Test que garantizan el rendimiento del software en las situaciones requeridas por el usuario.

Test que prueba la correcta funcionalidad de las clases y garantizan la mantenibilidad del software.

Tipos de test :Tipos de test :

Software

FrenteFrente

Frente

Test de aceptaciónTest de aceptación Test de integraciónTest de integración

Test de rendimiento Test de rendimiento

Test unitariosTest unitarios

Agenda :Agenda :

Test Unitarios:Test Unitarios:

Qué es una prueba unitaria?Qué es una prueba unitaria?

Una prueba unitaria es una pieza de código escrito por un desarrollador que prueba una pequeña área específica de la funcionalidad del código

Escusas para no hacer test unitarioEscusas para no hacer test unitario

- Cuesta mucho tiempo hacer los test

- Cuesta mucho tiempo ejecutar los test

- No es mi trabajo testear mi código

- Ya compila... no vale?

- Cuesta mucho tiempo hacer los test

- A mi me pagan por escribir código, no por escribir tests

Beneficios de hacer test unitariosBeneficios de hacer test unitarios- Mejora el diseño de la implementación

- Reduce el tiempo invertido debuggeando

- Se gana “seguridad” en los cambios

- Te hace la vida más fácil y tranquila Te hace la vida más fácil y tranquila

- Ayuda a documentar el código

- Se pone el código en situaciones extremas

Estructura de un testEstructura de un test

- Preparar y configurar el estado necesario para realizar el test

- Realizar la llamada al método que se quiere testear

- Verificar el resultado obtenido

Arrange Act Assert

Propiedades de un buen testPropiedades de un buen test

- Automatic: los tests se deben ejecutar automáticamente

- Thorough: exaustivos, se prueba todo que sea sensible al fallo

- Repeatable: ejecutar el test una y otra vez, con el mismo resultado

- Independent: Independiente entre los otros test y del entorno

- Professional: Debe ser código como si fuera producción

Qué testear?Qué testear?- Right: Si el código se ejecuta correctamente, ¿cómo lo sé?

Right-BICEPRight-BICEP

- Boundary: Probar condiciones límite, muchos “bugs” viven allí

- Inverse: Testear la lógica inversa si es posible

- Cross-check: Cotejar los resultados utilizando diferentes medios

- Error conditions: Forzar las situaciones de error

- Performance: Probar las características de rendimiento si requiere

Ejemplo de clase :Ejemplo de clase :

Ejemplo de test:Ejemplo de test:

Agenda :Agenda :

Plan TDDDobles de prueba

Un doble de prueba es un objeto que no es el real y que usamos para poder probar una funcionalidad aislándonos

del resto de los objetos del sistema

¿Qué son los doble de prueba?

Plan TDD

Tipos de doble de prueba (o roles)

Stub Mock Spy Fake dummy

Dobles de prueba

Frameworks para trabajar con dobles de prueba

Java mockito easyMock Jmock …

JavaScript JsTestDriver

Jsmockito JsHamcrest

Sinon.JS Qunit

Un stub es un objeto que programamos para que nos devuelva lo que nos de la gana y poder probar cómo reacciona

nuestro código ante los distintos valores de respuesta del colaborador en cuestión

Ejemplo de stub (usando mockito)

public class CompraTest {

Producto unProductoStub = mock(Producto.class); Producto otroProductoStub = mock(Producto.class); PasarelaDePago pasarelaDePagoStub = mock(PasarelaDePago.class); Compra compra = new Compra(pasarelaDePagoStub); @Test public void si_el_cliente_tiene_fondos_para_realizar_la_compra_la_puedo_confirmar() { when(unProductoStub.precio()).thenReturn(50); when(otroProductoStub.precio()).thenReturn(25); when(pasarelaDePagoStub.tieneElUsuarioFondosPorValorDe(75)).thenReturn(true); compra.anadir(unProductoStub); compra.anadir(otroProductoStub); assertTrue(compra.confirmar()); } }

Plan TDD

public class Compra {

private final List<Producto> productos = new ArrayList();

private final PasarelaDePago pasarelaDePago;

public Compra(PasarelaDePago pasarelaDePagoStub) {

this.pasarelaDePago = pasarelaDePagoStub;

public void anadir(Producto producto) {

productos.add(producto);

public int precio() {

int precioTotalCompra = 0;

for (Producto producto : productos) {

precioTotalCompra+=producto.precio();

return precioTotalCompra;

boolean confirmar() {

return pasarelaDePago.tieneElUsuarioFondosPorValorDe(precio());

Dobles de prueba

Un mock es un doble que nos sirve para verificar salidas indirectas del objeto que estamos probando

Ejemplo de mock (usando easyMock)

public class CompraTestMocks {

PasarelaDePago pasarelaDePagoMock = createMock(PasarelaDePago.class); Producto unProductoStub = createMock(Producto.class); Compra compra = new Compra(pasarelaDePagoMock);

@Test public void si_el_cliente_tiene_fondos_para_realizar_la_compra_tengo_que_cobrarle_a_traves_de_la_pasarela_de_pago() { expect(unProductoStub.precio()).andReturn(50); expect(pasarelaDePagoMock.tieneElUsuarioFondosPorValorDe(50)).andReturn(true); pasarelaDePagoMock.cobrar(50);

replay(pasarelaDePagoMock); replay(unProductoStub);

compra.anadir(unProductoStub); compra.confirmar();

verify(pasarelaDePagoMock); }}

Plan TDD

boolean confirmar() {

int elPrecioDeLaCompra = precio();

boolean tieneElUsuarioFondos = pasarelaDePago.tieneElUsuarioFondosPorValorDe(elPrecioDeLaCompra);

if (tieneElUsuarioFondos){

pasarelaDePago.cobrar(elPrecioDeLaCompra);

return tieneElUsuarioFondos;

Dobles de prueba

Al igual que los mocks, los spies sirven para hacer comprobaciones sobre salidas indirectas. La diferencia es que con un Spy lo que hacemos es después de ejecutar el método a probar verificar si sobre el doble se ha invocado a tal o cual

método

Ejemplo de Spy (usando mockito)

public class CompraTestSpies {

PasarelaDePago pasarelaDePagoSpy = mock(PasarelaDePago.class); Producto unProductoStub = mock(Producto.class); Compra compra = new Compra(pasarelaDePagoSpy);

@Test public void si_el_cliente_tiene_fondos_para_realizar_la_compra_tengo_que_cobrarle_a_traves_de_la_pasarela_de_pago() { when(unProductoStub.precio()).thenReturn(50); when(pasarelaDePagoSpy.tieneElUsuarioFondosPorValorDe(50)).thenReturn(false);

compra.anadir(unProductoStub); compra.confirmar();

verify(pasarelaDePagoSpy).cobrar(50); }}

Entonces ¿Mocks o Spies?

Un fake es una implementación falsa de un determinado interfaz, más simple normalmente, con el objetivo de hacer

que el test se pueda ejecutar más rápido o sin dependencias de un sistema externo.

Por ejemplo un fake de un objeto que acceda a la persistencia podría ser una implementación en memoria del mismo objeto.

Un dummy es simplemente cuando el objeto a probar tiene algún colaborador que no vamos a utilizar en este test,

entonces se le pasa un dummy que puede ser simplemente un nulo

Plan TDD

Webs de referencia

Mock Suckshttp://www.testingtv.com/2010/12/20/mocks-suck-and-what-to-do-about-it/

Java Mock Frameworks Comparisonhttp://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html

Diferencias entre mocks y stubshttp://theproc.es/2009/5/21/658/diferencias-entre-mocks-y-stubs

Escribiendo mejores testshttp://weblogs.javahispano.org/artesanodeprimera/entry/

escribiendo_mejores_test_iii_mocking

Dobles de prueba

Agenda :Agenda :

Tarea:Tarea:

– Descargar proyecto “Descargar proyecto “encryptorencryptor” (//dominio/proyectos/dnt)” (//dominio/proyectos/dnt)

– Realizar test unitarios de los métodos públicosRealizar test unitarios de los métodos públicos

Tarea :Tarea :

– Crear un tarea/job en el servidor CI Jenkins Crear un tarea/job en el servidor CI Jenkins – http://192.168.0.21:9090http://192.168.0.21:9090

Tarea :Tarea :

– Empezar a crear test unitarios en los proyectos Empezar a crear test unitarios en los proyectos – Programar la ejecución de los test en Jenkins CIProgramar la ejecución de los test en Jenkins CI

¡Nos vemos en 15 días!¡Nos vemos en 15 días!

Ruben EgiluzSoftware Engineer

Ivan RodriguezSoftware Engineer

Donewtech Solutions, S.L.Zubiberri Bidea 31Edificio Urumea20018 Donostia – San Sebastián

+34 943 223 031www.donewtech.com

¡¡Gracias!!

Test unitarios

Technology

Transcript of Test unitarios

Objetos Mocks en Test Unitarios

Test Test Test

Precios Unitarios

RefactoringTanto el refactoring como los test unitarios son pilares fundamentales de la programación extrema. En Java se da soporte a este tipo de tests unitarios por medio de JUnit.

procesos unitarios

unitarios vr1

unitarios vias

unitarios arquitectura

COSTOS UNITARIOS

Unitarios Nh

precio unitarios

Ejemplo Unitarios