web-dev-qa-db-ja.com

Javaでは、JUnitでスローされた例外をどのように検証できますか？

Java APIの単体テストを作成するときに、例外のより詳細な検証を実行したい場合があります。つまり、@ JUnitが提供するtestアノテーション。

たとえば、他のインターフェイスからの例外をキャッチし、その例外をラップして、ラップされた例外をスローするクラスを考えてみましょう。確認することをお勧めします。

  1. ラップされた例外をスローする正確なメソッド呼び出し。
  2. ラッパー例外が原因として元の例外を持っていること。
  3. ラッパー例外のメッセージ。

ここでの主なポイントは、単体テストで例外の追加検証を実行したいということです（あなたがすべきかどうかについての議論ではなく例外メッセージ）。

これに適したアプローチは何ですか？

javaexceptionexception-handlingjunit
28
Iain

JUnit 4では ExpectedException ルールを使用して簡単に行うことができます。

以下はjavadocsの例です。

// These tests all pass.
public static class HasExpectedException {
    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Test
    public void throwsNothing() {
        // no exception expected, none thrown: passes.
    }

    @Test
    public void throwsNullPointerException() {
        thrown.expect(NullPointerException.class);
        throw new NullPointerException();
    }

    @Test
    public void throwsNullPointerExceptionWithMessage() {
        thrown.expect(NullPointerException.class);
        thrown.expectMessage("happened?");
        thrown.expectMessage(startsWith("What"));
        throw new NullPointerException("What happened?");
    }
}
21
Jonas

あなたの答え で提供されているように、それは良いアプローチです。それに加えて：

関数expectExceptionをExpectedExceptionという新しいアノテーションにラップできます。
注釈付きメソッドは次のようになります：

@Test
@ExpectedException(class=WrapperException.class, message="Exception Message", causeException)
public void testAnExceptionWrappingFunction() {
  //whatever you test
}

この方法は読みやすくなりますが、まったく同じアプローチです。

もう1つの理由は次のとおりです。注釈が好きです:)

24
guerda

提案された回答を見ると、Javaにクロージャーがないことの痛みを実感できます。私見、最も読みやすい解決策はあなたがたは古き良きトライキャッチです。

@Test
public void test() {
    ...
    ...
    try {
        ...
        fail("No exception caught :(");
    }
    catch (RuntimeException ex) {
        assertEquals(Whatever.class, ex.getCause().getClass());
        assertEquals("Message", ex.getMessage());
    }
}
18
akuhn

JUNIT 3.xの場合

public void test(){
   boolean thrown = false;
   try{
      mightThrowEx();
   } catch ( Surprise expected ){
      thrown = true;
      assertEquals( "message", expected.getMessage());
   }
  assertTrue(thrown );
}
11
mP.

この投稿までは、次のようにして例外の検証を行いました。

try {
    myObject.doThings();
    fail("Should've thrown SomeException!");
} catch (SomeException e) {
    assertEquals("something", e.getSomething());
}

私はこの問題について少し考えてから、次のことを思いつきました（Java5、JUnit 3.x）。

// Functor interface for exception assertion.
public interface AssertionContainer<T extends Throwable> {
    void invoke() throws T;
    void validate(T throwable);
    Class<T> getType();
}

// Actual assertion method.
public <T extends Throwable> void assertThrowsException(AssertionContainer<T> functor) {
    try {
        functor.invoke();
        fail("Should've thrown "+functor.getType()+"!");
    } catch (Throwable exc) {
        assertSame("Thrown exception was of the wrong type! Expected "+functor.getClass()+", actual "+exc.getType(),
                   exc.getClass(), functor.getType());
        functor.validate((T) exc);
    }
}

// Example implementation for servlet I used to actually test this. It was an inner class, actually.
AssertionContainer<ServletException> functor = new AssertionContainer<ServletException>() {
    public void invoke() throws ServletException {
        servlet.getRequiredParameter(request, "some_param");
    }

    public void validate(ServletException e) {
        assertEquals("Parameter \"some_param\" wasn't found!", e.getMessage());
    }

    public Class<ServletException> getType() {
        return ServletException.class;
    }
}

// And this is how it's used.
assertThrowsException(functor);

この2つを見ると、どちらが好きか判断できません。これは、6つ以上のコードを実行して試してみる方がはるかに簡単なので、目標を達成すること（私の場合、functorパラメータを使用したアサーションメソッド）が長期的に見れば価値のない問題の1つだと思います..catchブロック。

繰り返しになりますが、おそらく、金曜日の夕方に問題を解決した私の10分の結果は、これを行うための最もインテリジェントな方法ではありません。

5
Esko

@akuhn：

クロージャーがなくても、より読みやすいソリューションを得ることができます（ catch-exception を使用）：

import static com.googlecode.catchexception.CatchException.*;

public void test() {
    ...
    ...
    catchException(nastyBoy).doNastyStuff();
    assertTrue(caughtException() instanceof WhateverException);
    assertEquals("Message", caughtException().getMessage());
}
4
rwitzel

私はとても簡単なことをしました

testBla(){
    try {
        someFailingMethod()
        fail(); //method provided by junit
    } catch(Exception e) {
          //do nothing
    }
}
2
Andreas Petersson

次のヘルパーメソッド（ this ブログ投稿から適応）がトリックを実行します。

/**
 * Run a test body expecting an exception of the
 * given class and with the given message.
 *
 * @param test              To be executed and is expected to throw the exception.
 * @param expectedException The type of the expected exception.
 * @param expectedMessage   If not null, should be the message of the expected exception.
 * @param expectedCause     If not null, should be the same as the cause of the received exception.
 */
public static void expectException(
        Runnable test,
        Class<? extends Throwable> expectedException,
        String expectedMessage,
        Throwable expectedCause) {
    try {
        test.run();
    }
    catch (Exception ex) {
        assertSame(expectedException, ex.getClass());
        if (expectedMessage != null) {
            assertEquals(expectedMessage, ex.getMessage());
        }

        if (expectedCause != null) {
            assertSame(expectedCause, ex.getCause());
        }

        return;
    }

    fail("Didn't find expected exception of type " + expectedException.getName());
}

テストコードは、次のようにこれを呼び出すことができます。

TestHelper.expectException(
        new Runnable() {
            public void run() {
                classInstanceBeingTested.methodThatThrows();
            }
        },
        WrapperException.class,
        "Exception Message",
        causeException
);
2
Iain

JUnit 5の場合、はるかに簡単です。

_    @Test
    void testAppleIsSweetAndRed() throws Exception {

        IllegalArgumentException ex = assertThrows(
                IllegalArgumentException.class,
                () -> testClass.appleIsSweetAndRed("orange", "red", "sweet"));

        assertEquals("this is the exception message", ex.getMessage());
        assertEquals(NullPointerException.class, ex.getCause().getClass());
    }
_

例外オブジェクト自体を返すことで、assertThrows()を使用すると、スローされた例外に関するあらゆる側面をテストできます。

0
Marcus K.

私は他の投稿されたものと同様のヘルパーを作りました：

public class ExpectExceptionsExecutor {

    private ExpectExceptionsExecutor() {
    }

    public static  void execute(ExpectExceptionsTemplate e) {
        Class<? extends Throwable> aClass = e.getExpectedException();

        try {
            Method method = ExpectExceptionsTemplate.class.getMethod("doInttemplate");
            method.invoke(e);
        } catch (NoSuchMethodException e1) {


            throw new RuntimeException();
        } catch (InvocationTargetException e1) {


            Throwable throwable = e1.getTargetException();
            if (!aClass.isAssignableFrom(throwable.getClass())) {
                //  assert false
                fail("Exception isn't the one expected");
            } else {
                assertTrue("Exception captured ", true);
                return;
            }
            ;


        } catch (IllegalAccessException e1) {
            throw new RuntimeException();
        }

        fail("No exception has been thrown");
    }


}

そしてクライアントが実装すべきテンプレート

public interface ExpectExceptionsTemplate<T extends Throwable> {


    /**
     * Specify the type of exception that doInttemplate is expected to throw
     * @return
     */
    Class<T> getExpectedException();


    /**
     * Execute risky code inside this method
     * TODO specify expected exception using an annotation
     */
    public void doInttemplate();

}

そして、クライアントコードは次のようになります。

@Test
    public void myTest() throws Exception {
        ExpectExceptionsExecutor.execute(new ExpectExceptionsTemplate() {
            @Override
            public Class getExpectedException() {
                return IllegalArgumentException.class;
            }

            @Override
            public void doInttemplate() {
                riskyMethod.doSomething(null);
            }
        });
     }

非常に冗長に見えますが、IDEをオートコンプリートで使用する場合は、例外のタイプとテスト中の実際のコードを記述するだけで済みます。 （残りはIDE：Dによって行われます）

0
Jaime Hablutzel