Wie kann ich meine Ausnahmemeldung mit der Annotation JUnit Test bestätigen?

Ich habe einige JUnit-Tests mit @TestAnmerkungen geschrieben. Wenn meine Testmethode eine aktivierte Ausnahme auslöst und ich die Nachricht zusammen mit der Ausnahme bestätigen möchte, gibt es eine Möglichkeit, dies mit der JUnit- @TestAnnotation zu tun ? AFAIK, JUnit 4.7 bietet diese Funktion nicht, aber werden sie in zukünftigen Versionen bereitgestellt? Ich weiß, dass Sie in .NET die Nachricht und die Ausnahmeklasse bestätigen können. Auf der Suche nach ähnlichen Funktionen in der Java-Welt.

Das ist was ich will:

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

Sie können die @RuleAnmerkung folgendermaßen verwenden ExpectedException:

@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");
}

Beachten Sie, dass das Beispiel in den ExpectedExceptionDokumenten (derzeit) falsch ist - es gibt keinen öffentlichen Konstruktor, daher müssen Sie verwenden ExpectedException.none().

Ich mag die @RuleAntwort. Wenn Sie jedoch aus irgendeinem Grund keine Regeln verwenden möchten. Es gibt eine dritte 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!");
  }

Müssen Sie verwenden @Test(expected=SomeException.class)? Wenn wir die eigentliche Meldung der Ausnahme bestätigen müssen, tun wir dies.

@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());
  }
}

In JUnit 4.13 können Sie Folgendes tun:

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());
}

Dies funktioniert auch in JUnit 5, jedoch mit unterschiedlichen Importen:

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

...

Eigentlich ist die beste Verwendung mit try / catch. Warum? Weil Sie den Ort steuern können, an dem Sie die Ausnahme erwarten.

Betrachten Sie dieses Beispiel:

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

Was ist, wenn eines Tages der Code geändert wird und die Testvorbereitung eine RuntimeException auslöst? In diesem Fall wird der tatsächliche Test nicht einmal getestet, und selbst wenn keine Ausnahme ausgelöst wird, besteht der Test.

Deshalb ist es viel besser, try / catch zu verwenden, als sich auf die Annotation zu verlassen.

Raystorm hatte eine gute Antwort. Ich bin auch kein großer Fan von Regeln. Ich mache etwas Ähnliches, außer dass ich die folgende Utility-Klasse erstelle, um die Lesbarkeit und Benutzerfreundlichkeit zu verbessern. Dies ist eines der großen Pluspunkte von Anmerkungen.

Fügen Sie diese Dienstprogrammklasse hinzu:

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();

}

Dann brauche ich für meinen Unit-Test nur diesen 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"
}

Bei Verwendung von @Rule wird der Ausnahmesatz auf alle Testmethoden in der Testklasse angewendet.

Ich mochte es nie, mit Junit Ausnahmen geltend zu machen. Wenn ich das "Erwartete" in der Anmerkung verwende, scheinen wir aus meiner Sicht das Muster "Gegeben, Wann, Dann" zu verletzen, da das "Dann" oben in der Testdefinition steht.

Wenn wir "@Rule" verwenden, müssen wir uns auch mit so viel Boilerplate-Code auseinandersetzen. Wenn Sie also neue Bibliotheken für Ihre Tests installieren können, würde ich empfehlen, einen Blick auf AssertJ zu werfen (diese Bibliothek wird jetzt mit SpringBoot geliefert).

Dann ein Test, der nicht gegen die "gegebenen / wann / dann" -Prinzipien verstößt, und der mit AssertJ durchgeführt wird, um Folgendes zu überprüfen:

1 - Die Ausnahme ist das, was wir erwarten. 2 - Es hat auch eine erwartete Nachricht

Wird so aussehen:

 @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");
}

Ich mag die Antwort von user64141, habe aber festgestellt, dass sie allgemeiner sein könnte. Hier ist meine Einstellung:

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();

}

Beachten Sie, dass das Belassen der Anweisung "fail" im try-Block dazu führt, dass die zugehörige Assertion-Ausnahme abgefangen wird. Die Verwendung von return innerhalb der catch-Anweisung verhindert dies.

Importieren Sie die Catch-Exception- Bibliothek und verwenden Sie diese. Es ist viel sauberer als die ExpectedExceptionRegel oder ein try-catch.

Beispiel aus ihren Dokumenten:

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
}