Как совместить @Rule и @ClassRule в JUnit 4,12

Question

Согласно the 4.12 release notes, можно аннотировать статические члены тестового класса как с @Rule и @ClassRule:

статический член с аннотацией как @ Правило и @ClassRule теперь считаются действительными. Это означает, что для выполнения действий как до, так и после класса может использоваться одно правило (например, установка/отключение внешнего ресурса) и между тестами (например, сброс внешнего ресурса),

Я хочу использовать эту функциональность для инициализации ресурса в начале всех тестов в файле, выполните некоторую очистку на ресурсе между каждым тестом и утилизируйте его после завершения всех тестов. Этот ресурс в настоящее время представлен классом, который расширяет ExternalResource.

В моих методах before и after, как я могу различать «до/после всех тестов» и «до/после каждого теста»? Нужно ли использовать другую/пользовательскую реализацию TestRule, чтобы выполнить это?

Answer 1

Вы можете реализовать TestRule#apply и использовать isTest и isSuite методы Description, чтобы определить, какой Statement ваш TestRule прикладывается к.

Вот пример интерфейса можно создать, чтобы дать правило, которое имеет полный before, after, verify, beforeClass, afterClass, verifyClass тип поведения:

public interface CombinedRule extends TestRule { 
    default Statement apply(Statement base, Description description) { 
     if (description.isTest()) { 
      return new Statement() { 
       public void evaluate() throws Throwable { 
        before(); 
        try { 
         base.evaluate(); 
         verify(); 
        } finally { 
         after(); 
        } 
       } 
      }; 
     } 
     if (description.isSuite()) { 
      return new Statement() { 
       public void evaluate() throws Throwable { 
        beforeClass(); 
        try { 
         base.evaluate(); 
         verifyClass(); 
        } finally { 
         afterClass(); 
        } 
       } 
      }; 
     } 
     return base; 
    } 

    default void before() throws Exception { 
     //let the implementer decide whether this method is useful to implement 
    } 

    default void after() { 
     //let the implementer decide whether this method is useful to implement 
    } 

    /** 
    * Only runs for Tests that pass 
    */ 
    default void verify() { 
     //let the implementer decide whether this method is useful to implement 
    } 

    default void beforeClass() throws Exception { 
     before(); 
    } 

    default void afterClass() { 
     after(); 
    } 

    /** 
    * Only runs for Suites that pass 
    */ 
    default void verifyClass() { 
     verify(); 
    } 
} 

Answer 2

методы аннотированные с @Before и @After будет работать до и после каждого испытания, в то время как те, с аннотацией @BeforeClass и @AfterClass будет работать до и после первого/последнего теста в классе соответственно.

Методы до/после @Rule выполняются до и после каждого теста, в то время как методы до и после @ClassRule выполняются до/после всего тестового класса.

Вы можете использовать ExternalResource для случая @Rule или @ClassRule, если методы обработчика должным образом реагируют на оба сценария. Насколько я могу судить по документации, нет никаких средств для разграничения между двумя категориями правил в методах класса правил. Если вы используете класс правил для обоих случаев, он будет применяться одинаково для обоих.

Answer 3

Нельзя проводить различие между @BeforeClass и @Before или @AfterClass и @After. Более подробную информацию о причине добавления этой функции можно найти в pull request.

Answer 4

Вы можете создать собственное правило, реализующий как TestRule и MethodRule:

public SharableExternalResource implements TestRule, MethodRule { 

    public final Statement apply(
     final Statement base, Description description) { 
    return 
     new Statement() { 
      @Override 
      public void evaluate() throws Throwable { 
      beforeClass(); 

      List<Throwable> errors = new ArrayList<Throwable>(); 
      try { 
       base.evaluate(); 
      } catch (Throwable t) { 
       errors.add(t); 
      } finally { 
       try { 
        afterClass(); 
       } catch (Throwable t) { 
        errors.add(t); 
       } 
      } 
      MultipleFailureException.assertEmpty(errors); 
      } 
     }; 
    } 

    public final Statement apply(
     Statement base, FrameworkMethod method, Object target) { 
    return 
     new Statement() { 
      @Override 
      public void evaluate() throws Throwable { 
      before(); 

      List<Throwable> errors = new ArrayList<Throwable>(); 
      try { 
       base.evaluate(); 
      } catch (Throwable t) { 
       errors.add(t); 
      } finally { 
       try { 
        after(); 
       } catch (Throwable t) { 
        errors.add(t); 
       } 
      } 
      MultipleFailureException.assertEmpty(errors); 
      } 
     }; 
    } 

    public void beforeClass() throws Exception { 
    // do nothing 
    } 

    protected void before() throws Exception { 
    // do nothing 
    } 

    protected void after() throws Exception { 
    // do nothing 
    } 

    public void afterClass() throws Exception { 
    // do nothing 
    } 
}