comment gérer les exceptions dans junit

J'ai écrit quelques scénarios de test pour tester la méthode. Mais certaines méthodes de lever une exception. Suis-je la faire correctement?

private void testNumber(String word, int number) {
    try {
        assertEquals(word,  service.convert(number));
    } catch (OutOfRangeNumberException e) {
        Assert.fail("Test failed : " + e.getMessage());
    }
}

@Test
public final void testZero() {
    testNumber("zero", 0);
}

Si je passe -45, il échouera avec OutOfRangeException mais je ne suis pas en mesure de tester exception spécifique comme @Test(Expected...)

InformationsquelleAutor Sammy Pawar | 2013-05-16

48

Une exception inattendue est un échec de test, de sorte que vous n'avez ni besoin ni envie d'attraper un.
```
@Test
public void canConvertStringsToDecimals() {
    String str = "1.234";
    Assert.assertEquals(1.234, service.convert(str), 1.0e-4);
}
```
Jusqu'à service ne pas jeter un IllegalArgumentException parce que str a un point décimal, ce sera un simple échec du test.

Attendu exception devrait être traité par la possibilité expected argument de @Test.
```
@Test(expected=NullPointerException.class)
public void cannotConvertNulls() {
    service.convert(null);
}
```
Si le programmeur était paresseux et jeta Exception, ou s'il avait service retour 0.0, le test échouera. Seulement un NPE va réussir. Notez que les sous-classes de l'exception de travail. C'est rare pour NPEs, mais commun avec IOExceptions et SQLExceptions.

Dans les rares cas où vous souhaitez tester pour un message d'exception, vous utilisez le newish ExpectedException JUnit @Rule.
```
@Rule
public ExpectedException thrown= ExpectedException.none();
@Test
public void messageIncludesErrantTemperature() {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("-400"); //Tests that the message contains -400.
    temperatureGauge.setTemperature(-400);
}
```
Maintenant, à moins que le setTemperature jette un IAE et le message contient la température de l'utilisateur tente de mettre, le test échoue. Cette règle peut être utilisée de manière plus complexe.

Votre exemple peut être mieux traitées par:
```
private void testNumber(String word, int number)
        throws OutOfRangeNumberException {
    assertEquals(word,  service.convert(number));
}

@Test
public final void testZero()
        throws OutOfRangeNumberException {
    testNumber("zero", 0);
}
```
Vous pouvez inline testNumber; maintenant, il ne nous aide pas beaucoup. Vous pouvez la transformer en un paramétrées de la classe de test.

InformationsquelleAutor Eric Jablow
22

Retirer le bloc try-catch et ajouter throws Exception à votre méthode de test, comme:
```
@Test
public final void testZero() throws Exception {
    assertEquals("zero",  service.convert(0));
}
```
JUnit s'attend à défaut de tests permettra de lancer des Exceptions, votre capture est tout simplement l'arrêt de JUnit d'être en mesure de signaler correctement. Aussi de cette façon, la propriété attendue sur l'annotation @Test fonctionne.

InformationsquelleAutor Nathan Hughes
7

Vous n'avez pas besoin d'attraper l'exception d'échouer le test. Juste le laisser aller (en déclarant throws) et ce sera un échec de toute façon.

Un autre cas est quand vous avez réellement s'attendre à l'exception, alors vous mettre échoue à la fin du bloc try.

Par exemple:
```
@Test
public void testInvalidNumber() {
  try {
      String dummy = service.convert(-1));
      Assert.fail("Fail! Method was expected to throw an exception because negative numbers are not supported.")
  } catch (OutOfRangeException e) {
      //expected
  }
}
```
Vous pouvez utiliser ce genre de test pour vérifier si votre code est bien la validation d'une entrée et poignées d'entrée non valide avec une bonne exception.
- ExpectedException est la meilleure façon de tester prévu des exceptions.
- Je suis d'accord et je l'ai déjà upvoted Eric réponse.
- Vous avez seulement besoin ExpectedException si vous avez besoin de vérifier la structure de l'exception. Par exemple, CmisExceptions sont censés avoir une certaine raison de défaut défini à l'intérieur d'eux. J'ai eu à écrire des tests pour vérifier, et j'ai utilisé Hamcrest de rapprochement à cette fin. Si vous comptez juste une exception, utiliser l'argument de @Test.
InformationsquelleAutor javadeveloper

Il existe plusieurs stratégies que vous pouvez utiliser pour traiter avec les exceptions dans vos tests. Je pense que la JUnit des annotations et des try/catch idiome qui ont déjà été mentionnés ci-dessus. Je voudrais attirer l'attention de la Java 8 option d'expressions Lambda.

Par exemple donné:

class DummyService {
public void someMethod() {
    throw new RuntimeException("Runtime exception occurred");
}

public void someOtherMethod(boolean b) {
    throw new RuntimeException("Runtime exception occurred",
            new IllegalStateException("Illegal state"));
}

}

Vous pouvez faire ceci:

@Test
public void verifiesCauseType() {
    //lambda expression
    assertThrown(() -> new DummyService().someOtherMethod(true))
            //assertions
            .isInstanceOf(RuntimeException.class)
            .hasMessage("Runtime exception occurred")
            .hasCauseInstanceOf(IllegalStateException.class);
}

Prendre un coup d'oeil à ce blog qui couvre la plupart des options, avec des exemples.

http://blog.codeleak.pl/2013/07/3-ways-of-handling-exceptions-in-junit.html

Et celui-ci explique la Java 8 Lambda option plus pleinement:

http://blog.codeleak.pl/2014/07/junit-testing-exception-with-java-8-and-lambda-expressions.html

InformationsquelleAutor raghera

Vous devez vous connecter pour publier un commentaire.