Comment puis-je affirmer mon message d'exception avec l'annotation JUnit Test?

J'ai écrit quelques tests JUnit avec @Testannotation. Si ma méthode de test lève une exception vérifiée et si je veux affirmer le message avec l'exception, existe-t-il un moyen de le faire avec l' @Testannotation JUnit ? AFAIK, JUnit 4.7 ne fournit pas cette fonctionnalité mais est-ce que les futures versions la fourniront? Je sais qu'en .NET, vous pouvez affirmer le message et la classe d'exception. Vous recherchez une fonctionnalité similaire dans le monde Java.

C'est ce que je veux:

@Test (expected = RuntimeException.class, message = "Employee ID is null")
public void shouldThrowRuntimeExceptionWhenEmployeeIDisNull() {}

Vous pouvez utiliser l' @Ruleannotation avec ExpectedException, comme ceci:

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

@Test
public void shouldThrowRuntimeExceptionWhenEmployeeIDisNull() throws Exception {
    expectedEx.expect(RuntimeException.class);
    expectedEx.expectMessage("Employee ID is null");

    // do something that should throw the exception...
    System.out.println("=======Starting Exception process=======");
    throw new NullPointerException("Employee ID is null");
}

Notez que l'exemple dans la ExpectedExceptiondocumentation est (actuellement) erroné - il n'y a pas de constructeur public, vous devez donc l'utiliser ExpectedException.none().

J'aime la @Ruleréponse. Cependant, si pour une raison quelconque vous ne souhaitez pas utiliser de règles. Il existe une troisième option.

@Test (expected = RuntimeException.class)
public void myTestMethod()
{
   try
   {
      //Run exception throwing operation here
   }
   catch(RuntimeException re)
   {
      String message = "Employee ID is null";
      assertEquals(message, re.getMessage());
      throw re;
    }
    fail("Employee Id Null exception did not throw!");
  }

Devez-vous utiliser @Test(expected=SomeException.class)? Lorsque nous devons affirmer le message réel de l'exception, c'est ce que nous faisons.

@Test
public void myTestMethod()
{
  try
  {
    final Integer employeeId = null;
    new Employee(employeeId);
    fail("Should have thrown SomeException but did not!");
  }
  catch( final SomeException e )
  {
    final String msg = "Employee ID is null";
    assertEquals(msg, e.getMessage());
  }
}

Dans JUnit 4.13, vous pouvez faire:

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;

...

@Test
void exceptionTesting() {
  IllegalArgumentException exception = assertThrows(
    IllegalArgumentException.class, 
    () -> { throw new IllegalArgumentException("a message"); }
  );

  assertEquals("a message", exception.getMessage());
}

Cela fonctionne également dans JUnit 5 mais avec des importations différentes:

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

...

En fait, la meilleure utilisation est avec try / catch. Pourquoi? Parce que vous pouvez contrôler l'endroit où vous attendez l'exception.

Considérez cet exemple:

@Test (expected = RuntimeException.class)
public void someTest() {
   // test preparation
   // actual test
}

Que se passe-t-il si un jour le code est modifié et que la préparation du test génère une exception RuntimeException? Dans ce cas, le test réel n'est même pas testé et même s'il ne déclenche aucune exception, le test réussit.

C'est pourquoi il est préférable d'utiliser try / catch que de s'appuyer sur l'annotation.

Raystorm avait une bonne réponse. Je ne suis pas non plus un grand fan des règles. Je fais quelque chose de similaire, sauf que je crée la classe d'utilité suivante pour aider la lisibilité et l'utilisabilité, qui est l'un des gros avantages des annotations en premier lieu.

Ajoutez cette classe d'utilitaires:

import org.junit.Assert;

public abstract class ExpectedRuntimeExceptionAsserter {

    private String expectedExceptionMessage;

    public ExpectedRuntimeExceptionAsserter(String expectedExceptionMessage) {
        this.expectedExceptionMessage = expectedExceptionMessage;
    }

    public final void run(){
        try{
            expectException();
            Assert.fail(String.format("Expected a RuntimeException '%s'", expectedExceptionMessage));
        } catch (RuntimeException e){
            Assert.assertEquals("RuntimeException caught, but unexpected message", expectedExceptionMessage, e.getMessage());
        }
    }

    protected abstract void expectException();

}

Ensuite, pour mon test unitaire, tout ce dont j'ai besoin est ce code:

@Test
public void verifyAnonymousUserCantAccessPrivilegedResourceTest(){
    new ExpectedRuntimeExceptionAsserter("anonymous user can't access privileged resource"){
        @Override
        protected void expectException() {
            throw new RuntimeException("anonymous user can't access privileged resource");
        }
    }.run(); //passes test; expected exception is caught, and this @Test returns normally as "Passed"
}

Si vous utilisez @Rule, le jeu d'exceptions est appliqué à toutes les méthodes de test de la classe Test.

Je n'ai jamais aimé la façon d'affirmer des exceptions avec Junit. Si j'utilise le «attendu» dans l'annotation, il me semble que nous violons le modèle «donné, quand, puis» parce que le «alors» est placé en haut de la définition du test.

De plus, si nous utilisons "@Rule", nous devons faire face à tant de code standard. Donc, si vous pouvez installer de nouvelles bibliothèques pour vos tests, je vous suggère de jeter un œil à AssertJ (cette bibliothèque est désormais livrée avec SpringBoot)

Ensuite, un test qui ne viole pas les principes "donnés / quand / alors", et il est fait en utilisant AssertJ pour vérifier:

1 - L'exception est ce que nous attendons. 2 - Il a aussi un message attendu

Ressemblera à ceci:

 @Test
void should_throwIllegalUse_when_idNotGiven() {

    //when
    final Throwable raisedException = catchThrowable(() -> getUserDAO.byId(null));

    //then
    assertThat(raisedException).isInstanceOf(IllegalArgumentException.class)
            .hasMessageContaining("Id to fetch is mandatory");
}

J'aime la réponse de user64141 mais j'ai trouvé qu'elle pourrait être plus généralisée. Voici mon point de vue:

public abstract class ExpectedThrowableAsserter implements Runnable {

    private final Class<? extends Throwable> throwableClass;
    private final String expectedExceptionMessage;

    protected ExpectedThrowableAsserter(Class<? extends Throwable> throwableClass, String expectedExceptionMessage) {
        this.throwableClass = throwableClass;
        this.expectedExceptionMessage = expectedExceptionMessage;
    }

    public final void run() {
        try {
            expectException();
        } catch (Throwable e) {
            assertTrue(String.format("Caught unexpected %s", e.getClass().getSimpleName()), throwableClass.isInstance(e));
            assertEquals(String.format("%s caught, but unexpected message", throwableClass.getSimpleName()), expectedExceptionMessage, e.getMessage());
            return;
        }
        fail(String.format("Expected %s, but no exception was thrown.", throwableClass.getSimpleName()));
    }

    protected abstract void expectException();

}

Notez que laisser l'instruction "fail" dans le bloc try provoque la capture de l'exception d'assertion associée; l'utilisation de return dans l'instruction catch empêche cela.

Importez la bibliothèque catch-exception et utilisez-la. C'est beaucoup plus propre que la ExpectedExceptionrègle ou a try-catch.

Exemple de leurs documents:

import static com.googlecode.catchexception.CatchException.*;
import static com.googlecode.catchexception.apis.CatchExceptionHamcrestMatchers.*;

// given: an empty list
List myList = new ArrayList();

// when: we try to get the first element of the list
catchException(myList).get(1);

// then: we expect an IndexOutOfBoundsException with message "Index: 1, Size: 0"
assertThat(caughtException(),
  allOf(
    instanceOf(IndexOutOfBoundsException.class),
    hasMessage("Index: 1, Size: 0"),
    hasNoCause()
  )
);

@Test (expectedExceptions = ValidationException.class, expectedExceptionsMessageRegExp = "This is not allowed")
public void testInvalidValidation() throws Exception{
     //test code
}