Primeros pasos con junit

Captura la excepción esperada

Es posible capturar fácilmente la excepción sin ningún bloque try catch.

public class ListTest {
  private final List<Object> list = new ArrayList<>();

  @Test(expected = IndexOutOfBoundsException.class)
  public void testIndexOutOfBoundsException() {
    list.get(0);
  }
}

El ejemplo anterior debería ser suficiente para casos más simples, cuando no desea/necesita verificar el mensaje que lleva la excepción lanzada.

Si desea verificar la información sobre la excepción, puede usar el bloque try/catch:

@Test
public void testIndexOutOfBoundsException() {
    try {
        list.get(0);
        Assert.fail("Should throw IndexOutOfBoundException");
    } catch (IndexOutOfBoundsException ex) {
        Assert.assertEquals("Index: 0, Size: 0", ex.getMessage());
    }
}

Para este ejemplo, debe tener en cuenta que siempre debe agregar Assert.fail() para asegurarse de que la prueba fallará cuando no se produzca una excepción.

Para casos más elaborados, JUnit tiene la ExpectedException @Rule, que también puede probar esta información y se usa de la siguiente manera:

public class SimpleExpectedExceptionTest {
     @Rule
     public ExpectedException expectedException = ExpectedException.none();

     @Test
     public void throwsNothing() {
         // no exception expected, none thrown: passes.
     }

     @Test
     public void throwsExceptionWithSpecificType() {
         expectedException.expect(NullPointerException.class);

         throw new NullPointerException();
     }

     @Test
     public void throwsExceptionWithSpecificTypeAndMessage() {
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Wanted a donut.");

         throw new IllegalArgumentException("Wanted a donut.");
     }
}

Prueba de excepciones en JUnit5

Para lograr lo mismo en JUnit 5, utiliza un mecanismo completamente nuevo:

El método probado

public class Calculator {
    public double divide(double a, double b) {
        if (b == 0.0) {
            throw new IllegalArgumentException("Divider must not be 0");
        }
        return a/b;
    }
}

El método de prueba

public class CalculatorTest {
    @Test
    void triangularMinus5() { // The test method does not have to be public in JUnit5
        Calculator calc = new Calculator();

        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class, 
            () -> calculator.divide(42.0, 0.0));
        // If the exception has not been thrown, the above test has failed.

        // And now you may further inspect the returned exception...
        // ...e.g. like this:
        assertEquals("Divider must not be 0", thrown.getMessage());
}

Ignorar pruebas

Para ignorar una prueba, simplemente agregue la anotación @Ignore a la prueba y, opcionalmente, proporcione un parámetro a la anotación con el motivo.

@Ignore("Calculator add not implemented yet.")
@Test
public void testPlus() {
    assertEquals(5, calculator.add(2,3));
}

En comparación con comentar la prueba o eliminar la anotación @Test, el ejecutor de la prueba aún informará esta prueba y notará que se ignoró.

También es posible ignorar un caso de prueba condicionalmente usando JUnit supuestos. Un caso de uso de muestra sería ejecutar el caso de prueba solo después de que un desarrollador corrija un error determinado. Ejemplo:

import org.junit.Assume;
import org.junit.Assert;
...

@Test 
public void testForBug1234() {

    Assume.assumeTrue(isBugFixed(1234));//will not run this test until the bug 1234 is fixed

    Assert.assertEquals(5, calculator.add(2,3));
}

El ejecutor predeterminado trata las pruebas con suposiciones fallidas como ignoradas. Es posible que otros corredores se comporten de manera diferente, p. tratarlos como pasados.

JUnit – Ejemplos de anotaciones básicas

Aquí hay algunas anotaciones básicas de JUnit que debe comprender: ================================================== =========

@BeforeClass – Run once before any of the test methods in the class, public static void 
@AfterClass – Run once after all the tests in the class has been run, public static void
@Before – Run before @Test, public void
@After – Run after @Test, public void
@Test – This is the test method to run, public void

Instalación o configuración

Dado que JUnit es una biblioteca de Java, todo lo que tiene que hacer para instalarlo es agregar algunos archivos JAR en el classpath de su proyecto Java y estará listo para comenzar.

Puede descargar estos dos archivos JAR manualmente: junit.jar & hamcrest-core.jar.

Si está utilizando Maven, simplemente puede agregar una dependencia en su pom.xml:

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

O si está usando Gradle, agregue una dependencia en su build.gradle:

apply plugin: 'java'

dependencies {
    testCompile 'junit:junit:4.12'
}

Después de esto puedes crear tu primera clase de prueba:

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class MyTest {
    @Test
    public void onePlusOneShouldBeTwo() {
        int sum = 1 + 1;
        assertEquals(2, sum);
    }
}

y ejecutarlo desde la línea de comando:

  • Windows java -cp .;junit-X.YY.jar;hamcrest-core-X.Y.jar org.junit.runner.JUnitCore MyTest
  • Linux u OsX java -cp .:junit-X.YY.jar:hamcrest-core-X.Y.jar org.junit.runner.JUnitCore MyTest

o con Maven: mvn test

Ejemplo de prueba de unidad básica

Este ejemplo es una configuración básica para la prueba unitaria de StringBuilder.toString() usando junit.

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class StringBuilderTest {

    @Test
    public void stringBuilderAppendShouldConcatinate()  {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("String");
        stringBuilder.append("Builder");
        stringBuilder.append("Test");

        assertEquals("StringBuilderTest", stringBuilder.toString());
    }

}

@Antes después

Se ejecutará un método anotado con @Before antes de cada ejecución de los métodos @Test. Análogamente, un método anotado @After se ejecuta después de cada método @Test. Esto se puede usar para configurar repetidamente una configuración de prueba y limpiar después de cada prueba. Por lo tanto, las pruebas son independientes y el código de preparación no se copia dentro del método @Test.

Ejemplo:

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class DemoTest {

    private List<Integer> list;

    @Before
    public void setUp() {
        list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(4);
        list.add(1);
        list.add(5);
        list.add(9);
    }

    @After
    public void tearDown() {
        list.clear();
    }

    @Test
    public void shouldBeOkToAlterTestData() {
        list.remove(0); // Remove first element of list.
        assertEquals(5, list.size()); // Size is down to five
    }

    @Test
    public void shouldBeIndependentOfOtherTests() {
        assertEquals(6, list.size());
    }
}

Los métodos anotados con @Before o @After deben ser public void y tener cero argumentos.