Comment vérifier qu'une exception a été levée pas

tl;dr

• pré-JDK8 : je vais recommander le bon vieux try -catch bloc.

• post-JDK8: utiliser AssertJ ou custom lambdas pour affirmer exceptionnel comportement.

l'histoire

il est possible de vous écrire un le faire vous-mêmetry -catch bloquer ou utiliser les outils JUnit (@Test(expected = ...) ou @Rule ExpectedException JUnit fonction de règle).

mais ces façons ne sont pas si élégantes et ne se mélangent pas bien lisibilité sage avec d'autres outils.

1. try -catch bloc, vous devez écrire le bloc autour de l'essai de comportement, et d'écrire l'affirmation dans le bloc catch, qui peut être bien, mais beaucoup trouvent que ce style interrompt la lecture d'un test. Aussi, vous devez écrire un Assert.fail à la fin du try bloquer sinon le test peut en manquer un du côté des assertions ; PMD, findbugs ou Sonar permettra de repérer ces problèmes.

2. @Test(expected = ...) la fonctionnalité est intéressante car vous pouvez écrire moins de code et ensuite écrire ce test est supposé être moins sujet à des erreurs de codage. Mais cette approche fait défaut dans certains domaines.

   • si le test a besoin de vérifier des choses supplémentaires sur l'exception comme la cause ou le message (bons messages d'exception sont vraiment importants, avoir un type d'exception précis peut ne pas être suffisant).

   • aussi comme l'attente est placée autour de la méthode, en fonction de la façon dont le code testé est écrit, alors la mauvaise partie du code de test peut jeter l'exception, conduisant à un test faussement positif et je ne suis pas sûr que PMD, findbugs ou Sonar donnera des indices sur un tel code.

     @Test(expected = WantedException.class)
     public void call2_should_throw_a_WantedException__not_call1() {
         // init tested
         tested.call1(); // may throw a WantedException
     
         // call to be actually tested
         tested.call2(); // the call that is supposed to raise an exception
     }
     

3. le ExpectedException la règle est aussi une tentative pour résoudre les précédentes mises en garde, mais il se sent un peu difficile à utiliser, car il utilise une attente de style, EasyMock les utilisateurs connaissent très bien ce style. Il peut être pratique pour certains, mais si vous suivez Comportement Du Développement Piloté Par (BDD) or Organiser Acte Assert (AAA) principes leExpectedException la règle ne conviendra pas à ce style d'écriture. Côté de qui il peut souffrir de la même question que le que le @Test moyen, selon l'endroit où vous placez l'attente.

   @Rule ExpectedException thrown = ExpectedException.none()
   
   @Test
   public void call2_should_throw_a_WantedException__not_call1() {
       // expectations
       thrown.expect(WantedException.class);
       thrown.expectMessage("boom");
   
       // init tested
       tested.call1(); // may throw a WantedException
   
       // call to be actually tested
       tested.call2(); // the call that is supposed to raise an exception
   }
   

   même l'exception attendue est placée avant l'énoncé du test, elle casse votre lecture si les tests suivent BDD ou AAA.

   voir Aussi problème sur JUnit de l'auteur de ExpectedException.

donc ces options ci-dessus ont toutes leur charge de mises en garde, et clairement pas à l'abri des erreurs de codeur.

4. il y a un projet que j'ai connu après créer cette réponse qui semble prometteuse, c'est catch-exception.

   comme le dit la description du projet, il permet à un codeur d'écrire dans une ligne de code courante en saisissant l'exception et en offrant cette exception pour une assertion ultérieure. Et vous pouvez utiliser n'importe quelle bibliothèque d'assertions comme Hamcrest ou AssertJ.

   un exemple rapide tiré de la page d'accueil:

   // given: an empty list
   List myList = new ArrayList();
   
   // when: we try to get the first element of the list
   when(myList).get(1);
   
   // then: we expect an IndexOutOfBoundsException
   then(caughtException())
           .isInstanceOf(IndexOutOfBoundsException.class)
           .hasMessage("Index: 1, Size: 0") 
           .hasNoCause();
   

   comme vous pouvez voir le code est vraiment simple, vous prenez exception sur une ligne spécifique, le then API est un alias qui va utiliser AssertJ APIs (similaire à utiliser assertThat(ex).hasNoCause()...). a un moment donné le projet s'est appuyé sur FEST-affirmer l'ancêtre de AssertJ. EDIT: il semble que le projet soit en train de brasser un support Java 8 Lambdas.

   cette bibliothèque présente actuellement deux lacunes:

   • Au moment d'écrire ces lignes, il convient de dire que cette bibliothèque est basé sur Mockito 1.x car elle crée un simulacre de l'objet testé derrière la scène. Comme Mockito n'est toujours pas mis à jour cette bibliothèque ne peut pas fonctionner avec les classes finales ou les méthodes finales. Et même si elle était basée sur mockito 2 dans la version actuelle, cela nécessiterait de déclarer un mock maker global (inline-mock-maker), quelque chose qui peut ne pas être ce que vous voulez, car ce mockmaker a différents inconvénients que le mockmaker régulier.

   • il faut encore un autre test dépendance.

   ces problèmes ne s'appliqueront pas une fois que la bibliothèque supportera lambdas, cependant la fonctionnalité sera dupliquée par AssertJ toolset.

   en tenant compte de tous si vous ne voulez pas utiliser l'outil catch-exception, je recommanderai l'ancienne bonne façon de la try -catch bloc, au moins jusqu'au JDK7. Et pour les utilisateurs de JDK 8 vous pourriez préférer utiliser AssertJ car il offre peut-être plus que simplement affirmer exception.

5. avec le JDK8, lambdas entrent dans la scène de test, et ils se sont avérés être une façon intéressante d'affirmer un comportement exceptionnel. AssertJ a été mis à jour pour fournir une API agréable fluent pour affirmer un comportement exceptionnel.

   et un exemple de test avec AssertJ:

   @Test
   public void test_exception_approach_1() {
       ...
       assertThatExceptionOfType(IOException.class)
               .isThrownBy(() -> someBadIOOperation())
               .withMessage("boom!"); 
   }
   
   @Test
   public void test_exception_approach_2() {
       ...
       assertThatThrownBy(() -> someBadIOOperation())
               .isInstanceOf(Exception.class)
               .hasMessageContaining("boom");
   }
   
   @Test
   public void test_exception_approach_3() {
       ...
       // when
       Throwable thrown = catchThrowable(() -> someBadIOOperation());
   
       // then
       assertThat(thrown).isInstanceOf(Exception.class)
                         .hasMessageContaining("boom");
   }
   

6. Avec un près de la réécriture complète de JUnit 5, affirmations ont été amélioration de l' un peu, ils peuvent s'avérer intéressant comme une façon out of the box d'affirmer correctement l'exception. Mais en réalité L'API assertion est toujours un peu pauvre, il n'y a rien à l'extérieur assertThrows.

   @Test
   @DisplayName("throws EmptyStackException when peeked")
   void throwsExceptionWhenPeeked() {
       Throwable t = assertThrows(EmptyStackException.class, () -> stack.peek());
   
       Assertions.assertEquals("...", t.getMessage());
   }
   

   Comme vous avez remarqué assertEquals est toujours de retour void, et en tant que tel ne permet pas de enchaîner des affirmations comme AssertJ.

   aussi si vous vous souvenez de nom clash avec Matcher ou Assert, être prêt à affronter le même choc avec Assertions.

j'aimerais conclure qu'aujourd'hui (2017-03-03) AssertJ de facto la dépendance de test est la meilleure solution avec JDK8 quel que soit le framework de test (JUnit ou non), les jdks précédents devraient plutôt s'appuyer sur try -catch bloquent même s'ils se sentent clunky.