web-dev-qa-db-fra.com

JUnit bonne façon de tester les exceptions attendues

Bonjour les gars, je me demandais si cette façon de tester mon exception est correcte, j'ai cette exception, je dois ajouter la deuxième annotation de test, je reçois en conséquence une barre rouge maléfique, et un succès et un échec, comme vous pouvez le deviner l'échec est ma préoccupation, j'ai un échec (); là mais la raison est parce que j'ai lu c'est la façon de tester l'exception et maintenant je suis confus.

Je dois également dire que je vais obtenir la barre verte car je m'attends à l'exception, mais je ne sais pas si l'échec est la bonne façon de voir la réponse de l'exception attendue.

Aussi si vous aviez des conseils, j'apprécierais

@Before
    public void setUp() throws Exception {
        LogPack.logPacConfig(Constants.LOGGING_FILE);
        gtfri = "+RESP:GTFRI,380502,869606020101881,INCOFER-gv65,,10,1,1,0.0,0,888.1,-84.194560,9.955602,20170220074514,,,,,,0.0,,,,100,210100,,,,20170220074517,40A2$";
        weirdProtocol = "+RESP:GRI,380502,869606020101881,INCOFER-gv65,,10,1,1,0.0,0,888.1,-84.194560,9.955602,20170220074514,,,,,,0.0,,,,100,210100,,,,20170220074517,40A2$";
        factory = new LocomotiveFactory();
    }
    @Test
    public void GTFRICreationTester_shouldPass() throws TramaConProtolocoloDesconocido {
        assertTrue(factory.createLocomotive(gtfri, false, new Date()) instanceof LocomotiveGTFRI);
    }

    @Test(expected = TramaConProtolocoloDesconocido.class)
    public void GTFRICreationTester_shouldFail()  {
        try {
            factory.createLocomotive(weirdProtocol, false, new Date());
            fail("Expected an TramaConProtolocoloDesconocido");
        } catch (TramaConProtolocoloDesconocido e) {
            //assertSame("exception thrown as expected", "no se conoce el protocolo dado para la creacion de este factory", e.getMessage());;
        }
    }
javaunit-testingjunitjunit4
16
Daniel Vega

Il existe 3 façons les plus courantes de tester l'exception attendue:

La première est la méthode la plus courante, mais vous ne pouvez tester que le type d'exception attendue. Ce test échouera si ExceptionType ne sera pas lancé:

@Test(expected = ExceptionType.class)
public void testSomething(){
    sut.doSomething();
}

Vous ne pouvez pas non plus spécifier le message d'échec en utilisant cette approche

La meilleure option consiste à utiliser ExpectedException JUnit @Rule . Ici, vous pouvez affirmer beaucoup plus pour l'exception attendue

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

@Test
public void testSomething(){
    thrown.expect(ExceptionType.class);
    thrown.expectMessage("Error message");
    thrown.expectCause(is(new CauseOfExeption()));
    thrown.reportMissingExceptionWithMessage("Exception expected"); 
    //any other expectations
    sut.doSomething();
}

La troisième option vous permettra de faire la même chose qu'avec l'utilisation d'ExpectedException @Rule, mais toute l'assertion doit être écrite manuellement. Cependant, l'avantage de cette méthode est que vous pouvez utiliser n'importe quelle assertion personnalisée et n'importe quelle bibliothèque d'assertions que vous souhaitez:

@Test
public void testSomething(){
    try{
        sut.doSomething();
        fail("Expected exception");
    } catch(ExceptionType e) {
    //assert ExceptionType e
    } 
}
16
Sergii Bishyr

Vous pouvez utiliser ExpectedException qui peut vous fournir des informations plus précises sur l'exception qui devrait être levée avec la possibilité de vérifier le message d'erreur, comme suit:

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
public class TestClass {

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


    @Test
    public void GTFRICreationTester_shouldFail()  {
        expectedException.expect(TramaConProtolocoloDesconocido.class);
        factory.createLocomotive(weirdProtocol, false, new Date());
    }
}

Pour en savoir plus à ce sujet, vous pouvez vous référer au blog que j'ai écrit ici - Règle d'exception attendue et méthodes statiques moqueuses - JUnit

4
Arpit

si vous utilisez Java 8, je recommanderais d'aller pour la bibliothèque AssertJ

public void GTFRICreationTester_shouldFail()  {
    assertThatExceptionOfType(EXCEPTION_CLASS).isThrownBy(() -> { factory.createLocomotive(weirdProtocol, false, new Date()) })
                                               .withMessage("MESSAGE")
                                               .withMessageContaining("MESSAGE_CONTAINING")
                                               .withNoCause();         

    }

avec cette solution, vous pouvez à la fois vérifier le type d'exception, avec un message, etc.

pour plus de lecture, jetez un œil à: http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#exception-assertion

2
pezetem

Vous n'avez pas besoin d'attraper le Exception avec try-catch

@Test(expected = TramaConProtolocoloDesconocido.class)
public void GTFRICreationTester_shouldFail()  {

    factory.createLocomotive(weirdProtocol, false, new Date());

}

Si nous supposons que factory.createLocomotive(weirdProtocol, false, new Date()) jette le exception lorsque vous appliquez un scénario qui rend le exception jeté.

void createLocomotive(param...) {

    //something...

    throw new TramaConProtolocoloDesconocido();
}
1
Mouad EL Fakir