Wie testet man, dass keine Ausnahme geworfen wird?

Question

Ich weiß, dass eine Möglichkeit, dies zu tun, wäre:

@Test
public void foo() {
   try {
      // Führe den Code aus, von dem du keine Ausnahmen erwartest.
   } catch(Exception e) {
      fail("Sollte keine Ausnahme geworfen haben");
   }
}

Gibt es einen saubereren Weg, dies zu tun? (Vielleicht mit Junit's @Rule?)

Answer 1

Ich enden damit, so zu machen

@Test
fun `Sollte nicht werfen`() {
    whenever(authService.isAdmin()).thenReturn(true)

    assertDoesNotThrow {
        service.throwIfNotAllowed("client")
    }
}

Answer 2

Dies ist vielleicht nicht der beste Weg, aber es stellt auf jeden Fall sicher, dass keine Ausnahme aus dem getesteten Codeblock geworfen wird.

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(){
        //Diese Methode wird nie eine Ausnahme werfen
    }
}

Answer 3

Sie können beliebige eigene Aussagen basierend auf Aussagen von junit erstellen, da diese speziell für die Erstellung benutzerdefinierter Aussagen entwickelt wurden, die genau wie junit-Aussagen funktionieren sollen:

static void assertDoesNotThrow(Executable executable) {
    assertDoesNotThrow(executable, "darf nicht geworfen werden");
}
static void assertDoesNotThrow(Executable executable, String message) {
    try {
        executable.execute();
    } catch (Throwable err) {
        fail(message);
    }
}

Jetzt testen wir das sogenannte Szenario methodMustNotThrow und protokollieren alle Fehler im junit-Stil:

//testen und protokollieren mit Standard- und benutzerdefinierten Nachrichten
//das folgende wird erfolgreich sein
assertDoesNotThrow(()->methodMustNotThrow(1));
assertDoesNotThrow(()->methodMustNotThrow(1), "benutzerdefinierter Facepalm");
//das folgende wird fehlschlagen
assertDoesNotThrow(()->methodMustNotThrow(2));
assertDoesNotThrow(()-> {throw new Exception("Hallo Welt");}, "Nachricht");
//Siehe Implementierung von methodMustNotThrow unten

Im Allgemeinen besteht die Möglichkeit, sofort in jedem Szenario, an jedem Ort, an dem es sinnvoll ist, durch Aufrufen von fail(someMessage) zu scheitern, was genau für diesen Zweck vorgesehen ist. Verwenden Sie es beispielsweise in einem try/catch-Block, um zu versagen, wenn im Testfall etwas geworfen wird:

try{methodMustNotThrow(1);}catch(Throwable e){fail("darf nicht geworfen werden");}
try{methodMustNotThrow(1);}catch(Throwable e){Assertions.fail("darf nicht geworfen werden");}

Dies ist das Beispiel für die Methode, die wir testen, vorausgesetzt, wir haben eine solche Methode, die unter bestimmten Umständen nicht fehlschlagen darf, aber fehlschlagen kann:

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

Die obige Methode ist ein einfaches Beispiel. Aber dies funktioniert auch für komplexe Situationen, in denen der Fehler nicht so offensichtlich ist. Hier sind die Imports:

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.*;

Answer 4

Verwenden Sie assertNull(...)

@Test
public void foo() {
    try {
        // Führen Sie Code aus, von dem Sie erwarten, dass er keine Ausnahmen auslöst.
    } catch (Exception e){
        assertNull(e);
    }
}

Answer 5

Ich stand vor derselben Situation, ich musste überprüfen, ob die Ausnahme geworfen wird, wenn sie sollte, und nur wenn sie sollte. Am Ende habe ich den Ausnahmehandler zu meinem Vorteil genutzt mit folgendem Code:

    try {
        functionThatMightThrowException()
    } catch (Exception e) {
        Assert.fail("sollte keine Ausnahme werfen");
    }
    RestOfAssertions();

Der Hauptvorteil für mich war, dass es ziemlich einfach ist und die andere Möglichkeit des "wenn und nur wenn" in derselben Struktur wirklich einfach zu überprüfen ist