Question

我需要创建一个规则来检查自定义消息的异常。下面是我的尝试，但这并不完全正确，因为我只是使用标准“ ExpectedException”中的方法。怎么做对呢？

public class CustomExpectedExceptionRule implements TestRule {
    private final ExpectedException delegate = ExpectedException.none();

    public static CustomExpectedExceptionRule none() {
        return new CustomExpectedExceptionRule();
    }

    private CustomExpectedExceptionRule() {
    }

    public void expect(Class<? extends Throwable> type) {
        delegate.expect(type);
    }

    public void expectMessage(String message) {
        delegate.expectMessage(message);
    }

    @Override
    public Statement apply(Statement base, Description description) {
        return delegate.apply(base, description);
    }

现在我正在尝试类似的事情：

 private final ExpectedException expectedException = ExpectedException.none();
    private Object exception;
    private String expectedMessage;

    @Override
    public Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                expectedException.expect((Class<? extends Throwable>) exception);
                expectedException.expectMessage(expectedMessage);
                base.evaluate();
            }
        };
    }

    public void expectedMessage(String expectedMessage) {
        this.expectedMessage = expectedMessage;
    }

    public void expectedException(Object exception) {
        this.exception = exception;
    }

但是，尽管通过了此处的所有字段，但在未通过引发异常的地方，此测试不起作用。如何以正确的形式重新制作它？

Answer 1

据我了解的要求，在您的测试中，您需要：

public class MyTest {
    @Rule 
    ExpectedException expExc = ExpectedException.none();

    @Test
    public void throwsNothing() {
        // "normal tests" not affected.
    }

    @Test
    public void throwsExceptionWithSpecificTypeAndMessage() {
       expExc.expect(MyCustomException.class);
       expExc.expectMessage("substring, that passes test");// other matchers possible
       // do something that (is expected to) raise(s) 
       // MyCustomException("substring, that passes test").
    }
}

..其中MyCustomException.class是自定义异常类（在继承层次结构中可能要传递的最低级别，您要“传递”），而substring, that passes test是消息的（一部分）所需来“通过”。

引入自定义TestRule可为您节省1 line/Test。在这种简单情况下，我建议您不要实现该接口，而是扩展ExternalResource（，see here））：

class CustomExpectedException extends ExternalResource /*implements (!) TestRule*/ {

    private ExpectedException expExc = ExpectedException.none();

    /* Parameterize the message and also the class, if it fits your needs, 
     * alternatively && additionally implement defaults/constants/more methods.*/
    public void myExpect(String substr) {
        expExc.expect(MyCustomException.class);
        expExc.expectMessage(substr);// other matchers possible
    }
}

...然后像这样使用它：

public class MyTest {
    @Rule 
    CustomExpectedException expExc = new CustomExpectedException();
    ...
    @Test
    public void throwsExceptionWithSpecificTypeAndMessage() {
       expExc.myExpect("substring, that passes test");
      // do something...
    }
}

一种无规则的方法（，see here）：

public class MyTest {
    @Test
    public void throwsExceptionWithSpecificTypeAndMessage() {
        try { // !
            // do something ...
            // after that, fail the test:
            org.junit.Assert.fail("expected exception!");
        } catch (Exception exc) { // ! here i would recommend "the highest possible Exception" (in inheritance hierarchy) ...even better <code>Throwable</code>.
           // this code can be moved to a (static) util method:
           if (exc instanceof MyCustomException) {
               // make assertions on ((MyCustomException) exc).getMessage();
           } else {
               org.junit.Assert.fail("UNexpected exception!");
               // or rethrow:
               // throw exc;
           }
        }          
    }
}

如何创建自定义“ ExpectedException” junit规则？

1 个答案: