在 JUnit 中的每个“@Test”之后和每个“@After”之前应用“@Rule”答案

【问题标题】：Apply '@Rule' after each '@Test' and before each '@After' in JUnit在 JUnit 中的每个“@Test”之后和每个“@After”之前应用“@Rule”
【发布时间】：2012-08-22 18:11:32
【问题描述】：

我有一个测试套件，我在@After 中注销系统并在@AfterClass 中关闭浏览器。我正在尝试使用 @Rule 为每种测试方法使用 Selenium 拍摄失败的测试屏幕截图。我手动检查了@Rule 只在每个@Before 之前运行，但我想在@Test 之后和@After 之前设置它。我找不到简单的解决方案。任何帮助将不胜感激。

public class MorgatgeCalculatorTest  {

@Before
public void before(){
    System.out.println("I am before");
}
@BeforeClass
public static void beforeclass(){
    System.out.println("I am beforeclass");
}
@Test
    public void test(){
        System.out.println("I am Test");
    }
@Test
public void test2(){
    System.out.println("I am Test2");
}
@After
    public void after(){
        System.out.println("I am after");
    }
@AfterClass
        public static  void afterclass(){
            System.out.println("I am afterclass");

}
@Rule
ExpensiveExternalResource ExpensiveExternalResource = new ExpensiveExternalResource();

static class ExpensiveExternalResource implements MethodRule  {
    public ExpensiveExternalResource(){
        System.out.println("I am rule");
    }

    @Override
    public Statement apply(Statement arg0, FrameworkMethod arg1, Object arg2) {
        // TODO Auto-generated method stub
        return null;
    }    
}

我得到的输出是

I am beforeclass
I am rule
I am before
I am Test
I am after
I am rule
I am before
I am Test2
I am after
I am afterclass

【问题讨论】：

我提到我只想在测试失败时截屏。不是每个测试：D
有趣。我只对订单感兴趣，所以实际上你的问题就是我的答案:)
@GáborLipták :) 我很高兴！
@GáborLipták 实际上显示的顺序不正确，因为它只显示规则被实例化的时间，而不是应用规则的时间。正确的测试在 Rule 中根本没有构造函数，而是在调用前后调用 arg0.evaluate() logging。这将表明该规则是围绕@Before / @After 运行的，就像在 JUnit 的 JavaDoc 中一样。

标签： java selenium webdriver junit4 junit-rule

【解决方案1】：

由于规则的设置方式，您不能在@before 或@after 之前设置规则。您可以将规则想象成您放在测试方法上的 shell。第一个shell 是@before/@after。此后应用@rules。

做你想做的事的一个快速方法是完全避免@After。可以创建一个规则，以便在方法失败时截取屏幕截图，然后在代码之后执行您的。它不像@After 那样漂亮，但它确实有效。（我也实现了 TestRule 因为 MethodRule 已被贬值）。

public class MortgageCalculatorTest  {
    @Before
    public void before(){
        System.out.println("I am before");
    }

    @BeforeClass
    public static void beforeclass(){
        System.out.println("I am beforeclass");
    }

    @Test
    public void test(){
        System.out.println("I am a Test");
    }

    @Test
    public void test2(){
        System.out.println("I am a Failed Test");
        fail();
    }

    @AfterClass
            public static  void afterclass(){
                System.out.println("I am afterclass");

    }

    @Rule
    public ExpensiveExternalResource ExpensiveExternalResource = new ExpensiveExternalResource();

    public static class ExpensiveExternalResource implements TestRule  {


      //  public ExpensiveExternalResource(){}


        public class ExpansiveExternalResourceStatement extends Statement{

            private Statement baseStatement;

            public ExpansiveExternalResourceStatement(Statement b){
                baseStatement = b;
            }

            @Override
            public void evaluate() throws Throwable {
                try{
                    baseStatement.evaluate();
                }catch(Error e){
                    System.out.println("I take a Screenshot");
                    throw e;   
                }finally{
                    after();
                }
            }

            //Put your after code in this method!
            public void after(){
                System.out.println("I am after");
            }
        }

        public Statement apply(Statement base, Description description) {
            return new ExpansiveExternalResourceStatement(base);

        }


    }
}

规则的所有工作都在一个语句中完成。 org.junit.runners.model.Statement 是一个代表代码包的类。所以这里的 apply 方法接收到你放置一个 shell 的代码包。 Apply 返回执行你给它的代码包的语句，并用 try/catch 语句包围它以捕获方法失败。

这个方法的输出是：

I am beforeclass
I am before
I am a Test
I am after
I am before
I am a Failed Test
I take a Screenshot
I am after
I am afterclass

希望这会有所帮助！

【讨论】：

特洛伊，感谢您的评论。从您的解决方案中得到提示。
我建议在输出中添加@After 方法，使其可见，baseStatement.evaluate() 实际上导致@Before，然后是测试方法，然后是@After 运行。跨度>

【解决方案2】：

public class ScreenshotTestRule implements MethodRule {
    public Statement apply(final Statement statement, final FrameworkMethod frameworkMethod, final Object o) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                try {
                    statement.evaluate();

                } catch (Throwable t) {
                    captureScreenshot(frameworkMethod.getName());
                    throw t; // rethrow to allow the failure to be reported to JUnit                     
                } finally {
                    tearDown();
                }
            }

            public void tearDown() {
                //logout to the system;
            }


            public void captureScreenshot(String fileName) {
                try {
                    new File("target/surefire-reports/screenshot").mkdirs(); // Insure directory is there
                    FileOutputStream out = new FileOutputStream("target/surefire-reports/screenshot/screenshot-" + fileName + ".png");
                    out.write(((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES));
                    out.close();
                } catch (Exception e) {
                    // No need to crash the tests if the screenshot fails
                }
            }
        };
    }
}

【讨论】：

【解决方案3】：

使用ExternalResource 规则怎么样？
看起来它可以为您提供足够的灵活性来满足您的需求。
如果这不是您所需要的，请查看外部资源的source code。
例如，如何实现仅在测试调用后才起作用的规则是很容易理解的。

【讨论】：