Comment utiliser Hamcrest en Java pour tester une exception?

Je ne pouvais pas la mettre en œuvre dans une belle façon si on compte l'affirmation d'erreur de description (c'est probablement pourquoi Hamcrest ne fournit pas une telle fonctionnalité), mais si vous jouez bien avec Java 8, alors vous pourriez vouloir quelque chose comme ça (mais je ne pense pas que ce soit jamais utilisé parce que les enjeux décrits ci-dessous):

IThrowingRunnable

Cette interface est utilisée pour encapsuler du code qui pourrait lancer des exceptions. Callable<E> peut être aussi bien utilisé, mais celui-ci exige de retourner une valeur, donc je pense qu'un exécutable ("vide-callable") est plus pratique.

@FunctionalInterface
public interface IThrowingRunnable<E extends Throwable> {

    void run()
            throws E;

}

FailsWithMatcher

Cette classe implémente un comparateur qui exige le rappel de lancer une exception. Un inconvénient de cette mise en œuvre est que le fait d'avoir un rappel de lancer une exception inattendue (ou même de ne pas jeter un seul) ne décrit pas ce qui est erroné et que vous souhaitez voir totalement obscur des messages d'erreur.

public final class FailsWithMatcher<EX extends Throwable>
        extends TypeSafeMatcher<IThrowingRunnable<EX>> {

    private final Matcher<? super EX> matcher;

    private FailsWithMatcher(final Matcher<? super EX> matcher) {
        this.matcher = matcher;
    }

    public static <EX extends Throwable> Matcher<IThrowingRunnable<EX>> failsWith(final Class<EX> throwableType) {
        return new FailsWithMatcher<>(instanceOf(throwableType));
    }

    public static <EX extends Throwable> Matcher<IThrowingRunnable<EX>> failsWith(final Class<EX> throwableType, final Matcher<? super EX> throwableMatcher) {
        return new FailsWithMatcher<>(allOf(instanceOf(throwableType), throwableMatcher));
    }

    @Override
    protected boolean matchesSafely(final IThrowingRunnable<EX> runnable) {
        try {
            runnable.run();
            return false;
        } catch ( final Throwable ex ) {
            return matcher.matches(ex);
        }
    }

    @Override
    public void describeTo(final Description description) {
        description.appendText("fails with ").appendDescriptionOf(matcher);
    }

}

ExceptionMessageMatcher

Ceci est un exemple de la correspondance de faire une simple vérification pour la levée d'une exception message.

public final class ExceptionMessageMatcher<EX extends Throwable>
        extends TypeSafeMatcher<EX> {

    private final Matcher<? super String> matcher;

    private ExceptionMessageMatcher(final Matcher<String> matcher) {
        this.matcher = matcher;
    }

    public static <EX extends Throwable> Matcher<EX> exceptionMessage(final String message) {
        return new ExceptionMessageMatcher<>(is(message));
    }

    @Override
    protected boolean matchesSafely(final EX ex) {
        return matcher.matches(ex.getMessage());
    }

    @Override
    public void describeTo(final Description description) {
        description.appendDescriptionOf(matcher);
    }

}

Et le test de l'échantillon lui-même

@Test
public void test() {
    assertThat(() -> emptyList().get(0), failsWith(IndexOutOfBoundsException.class, exceptionMessage("Index: 0")));
    assertThat(() -> emptyList().set(0, null), failsWith(UnsupportedOperationException.class));
}

Noter que cette approche:

• ... test-coureur indépendant
• ... permet de spécifier plusieurs assertions dans un seul test

Et le pire, c', typique de l'échec ressemblera

java.lang.AssertionError:  
Expected: fails with (an instance of java.lang.IndexOutOfBoundsException and is "Index: 0001")  
     but: was <foo.bar.baz.FailsWithMatcherTest$$Lambda$1/127618319@6b143ee9>

Peut-être en utilisant une mesure de mise en œuvre de la assertThat() méthode pourrait résoudre.

OriginalL'auteur Lyubomyr Shaydariv

Je suppose que la façon la plus propre est de définir une fonction comme

public static Throwable exceptionOf(Callable<?> callable) {
    try {
        callable.call();
        return null;
    } catch (Throwable t) {
        return t;
    }
}

quelque part et puis par exemple, appeler

    assertThat(exceptionOf(() -> callSomethingThatShouldThrow()),
        instanceOf(TheExpectedException.class));

peut-être aussi à l'aide de quelque chose comme la ExceptionMessageMatcher de cette réponse.

OriginalL'auteur Hans-Peter Störr