junit Tutorial
Empezando con Junit

Observaciones

Versiones

Instalación o configuración

Ya que JUnit es una biblioteca de Java, todo lo que tiene que hacer para instalarla es agregar algunos archivos JAR en la ruta de clases 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á utilizando 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-XYjar org.junit.runner.JUnitCore MyTest
• Linux o OsX java -cp .:junit-X.YY.jar:hamcrest-core-XYjar 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 unittesting 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álogo un @After método anotado es ejecutado después de cada @Test método. Esto se puede usar para establecer repetidamente una configuración de prueba y limpiar después de cada prueba. Así que 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 con cero argumentos.

Atrapa la excepción esperada

Es posible atrapar 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 o necesita verificar el mensaje transmitido por 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 no se Assert.fail() cuando no se lance una excepción.

Para casos más elaborados, JUnit tiene la ExpectedException @Rule , que también puede probar esta información y se utiliza 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.");
     }
}

Pruebas de excepciones en JUnit5

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

El metodo 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 metodo 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());
}

Ignorando las 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 corredor de la prueba seguirá informando esta prueba y notará que se ignoró.

También es posible ignorar un caso de prueba condicionalmente utilizando supuestos de JUnit. Un ejemplo de caso de uso sería ejecutar el caso de prueba solo después de que un desarrollador arregle un determinado error. 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 corredor predeterminado trata las pruebas con suposiciones fallidas como ignoradas. Es posible que otros corredores se comporten de manera diferente, por ejemplo, trátelos como pasados.

JUnit - Ejemplos básicos de anotación.

Aquí hay algunas anotaciones básicas de JUnit que debes entender:

@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