JUnit assume. Tipos de assumptions.
JUnit assume que es?? Este poderoso framework para hacer pruebas unitarias aparte de los metodos assertions(Afirmaciones), posee los metodos de assumptions(Supuestos) que sirven para hacer las pruebas unitarias un poco mas fuertes. Supongamos que escribimos nuestro test y antes de hacer el assert queremos asumir que un objeto tiene el valor que nosotros creemos que tendra para llevar a cabo la prueba, ahora si el objeto no tiene el valor que estamos asumiendo la prueba falla lanzando la excepcion AssumptionViolatedException, el hecho de que un supuesto assume falle no quiere decir que todo el test esta malo pero si nos permite hacer las pruebas unitarias un poco mas fuertes, así no tenemos que ejecutar todo el test para saber si pasa o no la prueba. A continuación te presento un ejemplo: // Solo haremos la prueba unitaria si la conexión a la base de datos esta bien.
@Test
public void testAssume() {
CallableStatement callableStatement = null;
Connection connection = null;
connection = getConnection();
assumeNotNull(connection);
// ..
}
A continuación les voy a detallar todos los metodos
assumptions(Supuestos) que posee JUnit.
| Assumptions | Descripción |
|---|---|
assumeNoException |
Se usa para asumir que una operación se completo normalmente. |
assumeNotNull |
Se usa par asumir que un objeto no esta null. |
assumeThat |
A diferencia de los demas metodos este utiliza un Matcher para asumir propiedades del objeto. |
assumeTrue |
Se usa para asumir que un objeto esta true. |
assumeNoException: @Test
public void testAssumeNoException(String nombre) {
CallableStatement callableStatement = null;
Connection connection = null;
String sql = "{ CALL USER_DATOJAVA.PKG_PRUEBAS.SP_VALIDAR(?) }";
try {
connection = getConnection();
callableStatement = connection.prepareCall(sql);
callableStatement.setString(1, nombre);
callableStatement.execute();
} catch (SQLException ex) {
// Si hay error hasta aqui llega la prueba
assumeNoException(ex);
}
//..
}
En el ejemplo anterior vemos que se logra hacer una conexion a la base de datos "supuestamente", en el caso de que halla una excepción en esa parte con el
assumeNoException(ex) vamos a poder dejar de ejecutar la prueba unitaria, lo cual hace la prueba un poco mas fuerte.
assumeNotNull: Supongamos que tenemos este metodo de prueba:
@Test
public void testClasesPorDia() {
String[] clasesLunes = null;
String dia = null;
String diaParametro = "Sabado";
// Verificamos el dia del parametro
switch (diaParametro) {
case "Lunes":
dia = "Lunes";
break;
case "Martes":
dia = "Martes";
break;
}
try {
assumeNotNull(dia);
switch (dia) {
case "Lunes":
clasesLunes = new String[2];
clasesLunes[0] = "matematica";
clasesLunes[1] = "programacion";
break;
case "Martes":
// ....
} catch (AssumptionViolatedException e) {
fail("El supuesto no es el esperado: " + e.getStackTrace());
}
// ..
}
Como vemos en el ejemplo anterior nosotros vamos asumir que la variable dia no puede estar null para seguir haciendo la prueba unitaria. En el ejemplo anterior la variable dia siempre sera null lo que quiere decir que lanza la excepción AssumptionViolatedException. Al ejecutar la prueba unitaria esto es lo que sucede:
assumeThat: Este metodo es el que mas se usa cuando estamos asumiendo algo, este metodo trabaja al igual que el
assertThat con Matcher, esto quiere decir que utilizamos la librería Hamcrest. Vamos a utilizar el ejemplo anterior para mostrar como se utiliza este metodo.
@Test
public void testClasesPorDia() {
String[] clasesLunes = null;
String dia = null;
String diaParametro = "Lunes";
//Primero vamos asumir que el "diaParametro" no esta vacio
assumeThat(diaParametro, is(not("")));
// Verificamos el dia del parametro
switch (diaParametro) {
case "Lunes":
dia = "Lunes";
break;
case "Martes":
dia = "Martes";
break;
}
try {
// Vamos asumir que el "dia" es = "Lunes"
assumeThat(dia, is("Lunes"));
//Si es "Lunes" ejecuta este codigo
switch (dia) {
case "Lunes":
clasesLunes = new String[2];
clasesLunes[0] = "matematica";
clasesLunes[1] = "programacion";
break;
}
//Ahora vamos asumir que el arreglo "clasesLunes" tiene 3 clases
assumeThat(clasesLunes.length, is(3));
// ....
} catch (AssumptionViolatedException e) {
fail("El supuesto no es el esperado: " + e);
}
// ..
}
En el metodo vemos algunas variantes del assumeThat, si analizamos el codigo vemos que falla en la linea 32 ya que el arreglo no tiene 3 clases. Esto es lo que pasa.
assumeTrue: Este es obvio que sirve para asumir que una variable se encuentra en
true, igual les pondre su ejemplo para que vean como se utiliza.
@Test
public void testAssumeTrue() {
boolean esCierto = false;
int num1 = 3;
int num2 = 6;
int resultado = num1 + num2;
if (resultado == 9) {
esCierto = true;
}
assumeTrue(esCierto);
}
Ya con este ejemplo terminamos con los metodos de assumptions.
No hay comentarios :
Publicar un comentario