Sé que una forma de hacerlo sería:

@Test
public void foo(){
   try{
      //execute code that you expect not to throw Exceptions.
   }
   catch(Exception e){
      fail("Should not have thrown any exception");
   }
}

¿Hay alguna forma más limpia de hacer esto? (¿Probablemente usando Junit's @Rule?)

Te estás acercando a esto de la manera incorrecta. Simplemente pruebe su funcionalidad: si se produce una excepción, la prueba fallará automáticamente. Si no se produce ninguna excepción, todas sus pruebas se volverán verdes.

He notado que esta pregunta genera interés de vez en cuando, así que me expandiré un poco.

Antecedentes de las pruebas unitarias

Cuando realiza pruebas unitarias, es importante que se defina lo que considera una unidad de trabajo. Básicamente: una extracción de su base de código que puede o no incluir múltiples métodos o clases que representan una sola pieza de funcionalidad.

O, como se define en The art of Unit Testing, 2nd Edition de Roy Osherove , página 11:

Una prueba de unidad es una pieza de código automatizada que invoca la unidad de trabajo que se está probando y luego verifica algunos supuestos sobre un resultado final único de esa unidad. Una prueba unitaria casi siempre se escribe utilizando un marco de prueba unitaria. Se puede escribir fácilmente y se ejecuta rápidamente. Es confiable, legible y mantenible. Es consistente en sus resultados siempre que el código de producción no haya cambiado.

Lo importante es darse cuenta de que una unidad de trabajo generalmente no es solo un método, sino que en el nivel más básico es un método y luego se encapsula en otra unidad de trabajo.

Idealmente, debe tener un método de prueba para cada unidad de trabajo por separado para que siempre pueda ver de inmediato dónde van las cosas mal. En este ejemplo, hay un método básico llamado getUserById()que devolverá un usuario y hay un total de 3 unidades de trabajo.

La primera unidad de trabajo debe probar si se devuelve o no un usuario válido en el caso de una entrada válida o no válida.
Aquí se deben manejar las excepciones lanzadas por el origen de datos: si no hay ningún usuario presente, debe haber una prueba que demuestre que se produce una excepción cuando no se puede encontrar al usuario. Una muestra de esto podría ser la IllegalArgumentExceptionque se captura con la @Test(expected = IllegalArgumentException.class)anotación.

Una vez que haya manejado todos sus casos de uso para esta unidad básica de trabajo, sube de nivel. Aquí haces exactamente lo mismo, pero solo manejas las excepciones que provienen del nivel justo debajo del actual. Esto mantiene su código de prueba bien estructurado y le permite ejecutar rápidamente la arquitectura para encontrar dónde van las cosas mal, en lugar de tener que saltar por todas partes.

Manejo de una entrada válida y defectuosa de las pruebas

En este punto, debería quedar claro cómo manejaremos estas excepciones. Hay 2 tipos de entrada: entrada válida y entrada defectuosa (la entrada es válida en sentido estricto, pero no es correcta).

Cuando trabaja con una entrada válida , está estableciendo la expectativa implícita de que cualquier prueba que escriba funcionará.

Tal llamada al método puede tener este aspecto: existingUserById_ShouldReturn_UserObject. Si este método falla (por ejemplo, se produce una excepción), entonces sabe que algo salió mal y puede comenzar a cavar.

Al agregar otra prueba ( nonExistingUserById_ShouldThrow_IllegalArgumentException) que usa la entrada defectuosa y espera una excepción, puede ver si su método hace lo que se supone que debe hacer con una entrada incorrecta.

TL; DR

Intentaba hacer dos cosas en su prueba: verificar la entrada válida y defectuosa. Al dividir esto en dos métodos para que cada uno haga una cosa, tendrá pruebas mucho más claras y una visión general mucho mejor de dónde van las cosas mal.

Al tener en cuenta la unidad de trabajo en capas, también puede reducir la cantidad de pruebas que necesita para una capa que es más alta en la jerarquía porque no tiene que tener en cuenta todo lo que podría haber salido mal en las capas inferiores: las capas debajo de la actual son una garantía virtual de que sus dependencias funcionan y si algo sale mal, está en su capa actual (suponiendo que las capas inferiores no arrojen ningún error).

Me topé con esto debido a la regla de SonarQube "calamar: S2699": "Agregue al menos una afirmación a este caso de prueba".

Tuve una prueba simple cuyo único objetivo era pasar sin lanzar excepciones.

Considere este código simple:

public class Printer {

    public static void printLine(final String line) {
        System.out.println(line);
    }
}

¿Qué tipo de afirmación se puede agregar para probar este método? Claro, puedes hacer un intento de atraparlo, pero eso es solo una acumulación de código.

La solución proviene de JUnit en sí.

En caso de que no se produzca ninguna excepción y desee ilustrar explícitamente este comportamiento, simplemente agregue expectedcomo en el siguiente ejemplo:

@Test(expected = Test.None.class /* no exception expected */)
public void test_printLine() {
    Printer.printLine("line");
}

Test.None.class es el valor predeterminado para el valor esperado.

Con afirmaciones fluidas AssertJ 3.7.0 :

Assertions.assertThatCode(() -> toTest.method())
    .doesNotThrowAnyException();

JUnit 5 (Júpiter) proporciona tres funciones para verificar la ausencia / presencia de excepción:

● assertAll​()

  Afirma que todos los suministrados executables
  no arrojan excepciones.

● assertDoesNotThrow​()

  Afirma que la ejecución del
  suministrado executable/ supplier
  no arroja ningún tipo de excepción .

  Esta función está disponible
  desde JUnit 5.2.0 (29 de abril de 2018).

● assertThrows​()

  Afirma que la ejecución de los executable
  lanzamientos suministrados genera una excepción expectedType
  y devuelve la excepción .

Ejemplo

package test.mycompany.myapp.mymodule;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class MyClassTest {

    @Test
    void when_string_has_been_constructed_then_myFunction_does_not_throw() {
        String myString = "this string has been constructed";
        assertAll(() -> MyClass.myFunction(myString));
    }

    @Test
    void when_string_has_been_constructed_then_myFunction_does_not_throw__junit_v520() {
        String myString = "this string has been constructed";
        assertDoesNotThrow(() -> MyClass.myFunction(myString));
    }

    @Test
    void when_string_is_null_then_myFunction_throws_IllegalArgumentException() {
        String myString = null;
        assertThrows(
            IllegalArgumentException.class,
            () -> MyClass.myFunction(myString));
    }

}

Java 8 hace esto mucho más fácil, y Kotlin / Scala doblemente.

Podemos escribir una pequeña clase de utilidad

class MyAssertions{
  public static void assertDoesNotThrow(FailingRunnable action){
    try{
      action.run()
    }
    catch(Exception ex){
      throw new Error("expected action not to throw, but it did!", ex)
    }
  }
}

@FunctionalInterface interface FailingRunnable { void run() throws Exception }

y luego tu código se vuelve simplemente:

@Test
public void foo(){
  MyAssertions.assertDoesNotThrow(() -> {
    //execute code that you expect not to throw Exceptions.
  }
}

Si no tiene acceso a Java-8, usaría una instalación java dolorosamente antigua: bloques de código arbitrario y un simple comentario

//setup
Component component = new Component();

//act
configure(component);

//assert 
/*assert does not throw*/{
  component.doSomething();
}

Y finalmente, con kotlin, un idioma del que me he enamorado recientemente:

fun (() -> Any?).shouldNotThrow() 
    = try { invoke() } catch (ex : Exception){ throw Error("expected not to throw!", ex) }

@Test fun `when foo happens should not throw`(){

  //...

  { /*code that shouldn't throw*/ }.shouldNotThrow()
}

Aunque hay mucho espacio para jugar con exactamente cómo quieres expresar esto, siempre fui un fanático de las afirmaciones fluidas .

Respecto a

Te estás acercando a esto de la manera incorrecta. Simplemente pruebe su funcionalidad: si se produce una excepción, la prueba fallará automáticamente. Si no se produce ninguna excepción, todas sus pruebas se volverán verdes.

Esto es correcto en principio pero incorrecto en conclusión.

Java permite excepciones para el flujo de control. Esto se hace por el mismo tiempo de ejecución JRE en las API como Double.parseDoublea través de un NumberFormatExceptione Paths.gettravés de una InvalidPathException.

Dado que ha escrito un componente que valida las cadenas de números para Double.ParseDouble, tal vez utilizando un Regex, tal vez un analizador escrito a mano, o tal vez algo que incorpore otras reglas de dominio que restrinjan el rango de un doble a algo específico, la mejor manera de probar esto ¿componente? Creo que una prueba obvia sería afirmar que, cuando se analiza la cadena resultante, no se produce ninguna excepción. Escribiría esa prueba usando lo anterior assertDoesNotThrowo el /*comment*/{code}bloque. Algo como

@Test public void given_validator_accepts_string_result_should_be_interpretable_by_doubleParseDouble(){
  //setup
  String input = "12.34E+26" //a string double with domain significance

  //act
  boolean isValid = component.validate(input)

  //assert -- using the library 'assertJ', my personal favourite 
  assertThat(isValid).describedAs(input + " was considered valid by component").isTrue();
  assertDoesNotThrow(() -> Double.parseDouble(input));
}

También le animo a que parametrice esta prueba al inputusar Theorieso Parameterizedpara que pueda reutilizar esta prueba más fácilmente para otras entradas. Alternativamente, si quieres ir exótico, puedes optar por una herramienta de generación de pruebas (y esto ). TestNG tiene mejor soporte para pruebas parametrizadas.

Lo que me parece particularmente desagradable es la recomendación de usar @Test(expectedException=IllegalArgumentException.class), esta excepción es peligrosamente amplia . Si su código cambia de manera tal que el componente bajo el constructor de la prueba tiene if(constructorArgument <= 0) throw IllegalArgumentException(), y su prueba estaba suministrando 0 para ese argumento porque era conveniente, y esto es muy común, porque generar buenos datos de prueba es un problema sorprendentemente difícil, entonces su prueba será de color verde aunque no pruebe nada. Tal prueba es peor que inútil.

Si tiene la mala suerte de atrapar todos los errores en su código. Puedes hacer estupidamente

class DumpTest {
    Exception ex;
    @Test
    public void testWhatEver() {
        try {
            thisShouldThrowError();
        } catch (Exception e) {
            ex = e;
        }
        assertEquals(null,ex);
    }
}

JUnit5 agrega el método ClaimAll () para este propósito exacto.

assertAll( () -> foo() )

fuente: JUnit 5 API

Aunque esta publicación tiene 6 años, sin embargo, mucho ha cambiado en el mundo Junit. Con Junit5, ahora puedes usar

org.junit.jupiter.api.Assertions.assertDoesNotThrow()

Ex:

public void thisMethodDoesNotThrowException(){
   System.out.println("Hello There");
}

@Test
public void test_thisMethodDoesNotThrowException(){
  org.junit.jupiter.api.Assertions.assertDoesNotThrow(
      ()-> thisMethodDoesNotThrowException()
    );
}

Espero que ayude a las personas que usan una versión más reciente de Junit5

Si desea probar si su objetivo de prueba consume la excepción. Simplemente deje la prueba como (simulacro de colaborador usando jMock2):

@Test
public void consumesAndLogsExceptions() throws Exception {

    context.checking(new Expectations() {
        {
            oneOf(collaborator).doSth();
            will(throwException(new NullPointerException()));
        }
    });

    target.doSth();
 }

La prueba pasaría si su objetivo consume la excepción lanzada, de lo contrario, la prueba fallaría.

Si desea probar su lógica de consumo de excepción, las cosas se vuelven más complejas. Sugiero delegar el consumo a un colaborador que podría ser burlado. Por lo tanto, la prueba podría ser:

@Test
public void consumesAndLogsExceptions() throws Exception {
    Exception e = new NullPointerException();
    context.checking(new Expectations() {
        {
            allowing(collaborator).doSth();
            will(throwException(e));

            oneOf(consumer).consume(e);
        }
    });

    target.doSth();
 }

Pero a veces está sobrediseñado si solo desea iniciar sesión. En este caso, este artículo ( http://java.dzone.com/articles/monitoring-declarative-transac , http://blog.novoj.net/2008/09/20/testing-aspect-pointcuts-is-there -an-easy-way / ) puede ayudar si insiste en tdd en este caso.

Utilice afirmar nulo (...)

@Test
public void foo() {
    try {
        //execute code that you expect not to throw Exceptions.
    } catch (Exception e){
        assertNull(e);
    }
}

Puede esperar que no se genere una excepción al crear una regla.

@Rule
public ExpectedException expectedException = ExpectedException.none();

Puede que esta no sea la mejor manera, pero definitivamente se asegura de que no se genere una excepción desde el bloque de código que se está probando.

import org.assertj.core.api.Assertions;
import org.junit.Test;

public class AssertionExample {

    @Test
    public void testNoException(){
        assertNoException();
    }    

    private void assertException(){
        Assertions.assertThatThrownBy(this::doNotThrowException).isInstanceOf(Exception.class);
    }

    private void assertNoException(){
        Assertions.assertThatThrownBy(() -> assertException()).isInstanceOf(AssertionError.class);
    }

    private void doNotThrowException(){
        //This method will never throw exception
    }
}

Puede hacerlo utilizando una @Rule y luego llamar al método reportMissingExceptionWithMessage como se muestra a continuación: Este es el código Scala.

Lo siguiente falla la prueba para todas las excepciones, marcadas o no marcadas:

@Test
public void testMyCode() {

    try {
        runMyTestCode();
    } catch (Throwable t) {
        throw new Error("fail!");
    }
}

Puede crear cualquier tipo de sus propias aserciones basadas en aserciones de junit:

static void assertDoesNotThrow(Executable executable) {
    assertDoesNotThrow(executable, "must not throw");
}
static void assertDoesNotThrow(Executable executable, String message) {
    try {
        executable.execute();
    } catch (Throwable err) {
        fail(message);
    }
}

Y prueba:

//the following will succeed
assertDoesNotThrow(()->methodMustNotThrow(1));
assertDoesNotThrow(()->methodMustNotThrow(1), "fail with specific message: facepalm");
//the following will fail
assertDoesNotThrow(()->methodMustNotThrow(2));
assertDoesNotThrow(()-> {throw new Exception("Hello world");}, "Fail: must not trow");

En términos generales, existe la posibilidad de fallar instantáneamente ("bla bla bla") la prueba en cualquier escenario, en cualquier lugar donde tenga sentido. Por ejemplo, úselo en un bloque try / catch para fallar si se arroja algo en el caso de prueba:

try{methodMustNotThrow(1);}catch(Throwable e){fail("must not throw");}
//or
try{methodMustNotThrow(1);}catch(Throwable e){Assertions.fail("must not throw");}

Esta es la muestra del método que probamos, suponiendo que tengamos un método que no debe fallar en circunstancias específicas, pero puede fallar:

void methodMustNotThrow(int x) throws Exception{
    if (x == 1) return;
    throw new Exception();
}

El método anterior es una muestra simple. Pero esto funciona para situaciones complejas, donde el fracaso no es tan obvio. Están las importaciones:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import static org.junit.jupiter.api.Assertions.*;