Rules

我们之前处理异常的时候用到过Rules，当然还有很多其他规则。Rules允许弹性的添加或者重定义测试方法的行为。测试者可以重复使用或者扩展下面的某一个Rules，也可以写一个属于自己的规则。

这里先展示一张 TestRule的类图：

基本的规则有：

1.TemporaryFolder Rule

该规则建立的文件或者文件夹会在测试方法结束之后自动删除（不管测试pass还是fail）。默认情况下，即使资源删不掉也不会抛出异常。

import java.io.File;
import java.io.IOException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;  

public class RuleTest {
    @Rule
    public TemporaryFolder folder=new TemporaryFolder();  

    @Test
    public void test() throws IOException {
        File aFile=folder.newFile("myfile.txt");
        File aFolder=folder.newFolder("subfolder");
    }
}  

• TemporaryFolder#newFolder(String...folderNames) 会递归深入的新建多个文件夹。
• TemporaryFolder#newFile() 会新建一个带有随机名字的文件，#newFolder() 会新建一个带有随机名字的文件夹。
• 从 4.13开始，如果测试结束之后资源不能被删除， TemporaryFolder 可以选择允许测试以 AssertionError的方式fail。但是这个特性只有在使用 #builder()的方法才可以被激活。为了向后兼容默认情况下还是不会抛出异常。

@Rule
public TemporaryFolder folder=TemporaryFolder.builder().assureDeletion().build();

2.ExternalResource Rules

ExternalResource用来对外部资源进行管理，包括在测试之前进行外部资源准备，测试之后对测试资源进行回收等工作。在创建测试文件、连接服务器、准备数据库连接等情况下用的比较多。

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExternalResource; 

public class RuleTest2 { 

@Rule
public ExternalResource external = new ExternalResource()
{
protected void before() throws Throwable
{
System.out.println("Perparing test data.");
System.out.println("Test data is Ready!");
} 

protected void after()
{
System.out.println("Cleaning test data.");
}
}; 

@Test
public void test1()
{
System.out.println("Test 1 executing...");
} 

@Test
public void test2()
{
System.out.println("Test 2 executing...");
} 

@Test
public void test3()
{
System.out.println("Test 3 executing...");
}
} 

运行结果：

Perparing test data.
Test data is Ready!
Test 1 executing...
Cleaning test data.
Perparing test data.
Test data is Ready!
Test 2 executing...
Cleaning test data.
Perparing test data.
Test data is Ready!
Test 3 executing...
Cleaning test data.

3. ErrorCollector Rule

• 继承自下面的Verifier Rule。ErrorCollector
  规则允许测试在第一个问题出现的时候继续执行，然后执行完之后一次性汇报结果。比如说测试一个表格里的所有的行，在第一行发现错误之后继续执行，直到所有
  的错误都发现才停止，然后一次性汇报所有的结果。

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ErrorCollector;  

public class TestRule3 {
    @Rule
    public ErrorCollector collector=new ErrorCollector();
    @Test
    public void test() {
        collector.addError(new Throwable("first things went wrong!"));
        collector.addError(new Throwable("second things went wrong!"));
    }
}  

运行结果：

4. Verifier Rule

它是ErrorCollector的父类。当每个测试结束之后会执行ErrorCollector的verify方法，如果执行不通过这个测试会被标记为fail。

import static org.junit.Assert.*;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Verifier; 

public class RuleTest4 {
String sequence=""; 

@Rule
public Verifier collector=new Verifier(){
@Override
protected void verify(){
System.out.println("this is verify...");
assertEquals("test verify ",sequence);
}
}; 

@Test
public void test01(){
System.out.println("this is testing 01...");
sequence += "test ";
} 

@Test
public void test02(){
System.out.println("this is testing 02...");
sequence="test verify ";
}
} 

测试结果：

this is testing 01...
this is verify...
this is testing 02...
this is verify...

test01为 fail，而test02 pass。

5. TestWatchman/TestWatcher Rules

从4.9版本开始，TestWatcher开始代替 TestWatchman。TestWatcher实现了TestRule类，而不是MethodRule类。

TestWatchman从4.7版本开始引入，它使用 MethodRule，而MethodRule目前已经弃用。

TestWatcher 不会改变测试的任何行为，提供了 succeeded、failed、skipped、starting、finished方法用来监控一个测试方法生命周期的各个阶段，所有方法都包含一 个 org.junit.runner.Description 类型的参数用来描述当前执行的测试。

import static org.junit.Assert.*;
import org.junit.AfterClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.internal.AssumptionViolatedException;
import org.junit.rules.TestWatcher;
import org.junit.runner.Description;
import org.junit.runners.model.Statement; 

public class RuleTest5 {
private static String watchedLog=""; 

@Rule
public TestWatcher watchman=new TestWatcher(){
@Override
public Statement apply(Statement base,Description description){
return super.apply(base,description);
} 

@Override
protected void succeeded(Description description) {
watchedLog += description.getDisplayName() + " " + "success!\n";
} 

@Override
protected void failed(Throwable e, Description description) {
watchedLog += description.getDisplayName() + " " + e.getClass().getSimpleName() + "\n";
} 

@Override
protected void skipped(AssumptionViolatedException e, Description description) {
watchedLog += description.getDisplayName() + " " + e.getClass().getSimpleName() + "\n";
} 

@Override
protected void starting(Description description) {
super.starting(description);
} 

@Override
protected void finished(Description description) {
super.finished(description);
}
}; 

@Test
public void fails() {
fail();
} 

@Test
public void succeeds(){ 

} 

@AfterClass
public static void printlog(){
System.out.println(watchedLog);
}
} 

测试结果：

succeeds(com.junit.org.RuleTest5) success!
fails(com.junit.org.RuleTest5) AssertionError

在每一条测试执行完之后，分别调用了 succeeded（）和failed（）方法对 watchedLog进行处理。当然我们还可以在监控方法里做一些其他的事情。

6. TestName Rule

有了这条规则，即使在测试方法内部我们也可以引用方法名。

import static org.junit.Assert.*;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName; 

public class RuleTest6 {
@Rule
public TestName name=new TestName(); 

@Test
public void testA(){
assertEquals("testA",name.getMethodName());
} 

@Test
public void testB(){
assertEquals("testB",name.getMethodName());
}
} 

7. Timeout Rule

参考“七 Timeout for tests" 。

8. ExpectedException Rules

参考 ” 四 Exception testing"。

9. ClassRule

@ClassRule 注释扩展了方法级别的规则，它增加了一些静态属性，从而影响整个类。ParentRunner 的任何子类，包括 BlockJUnit4ClassRunner 和 Suite类，都支持 @ClassRule S.

比如说，将ExternalResource 从 @Rule 变成 @ ClassRule，则在整个类里的测试执行过程中它只会执行一次，也就是所有的测试类开始之前会执行 before()，所有的测试类执行结束之后会执行 after()。

import org.junit.ClassRule;
import org.junit.rules.ExternalResource;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses; 

@RunWith(Suite.class)
@SuiteClasses({RuleTest.class,RuleTest2.class,RuleTest3.class})
public class TestSuite01 { 

@ClassRule
public static ExternalResource resource= new ExternalResource() {
@Override
protected void before() throws Throwable {
System.out.println("Before Class testing ......");
}; 

@Override
protected void after() {
System.out.println("After Class testing......");
};
};
} 

测试执行结果：

Before Class testing ......
Test Method 1 executing...
Test Method 2 executing...
Test Method 3 executing...
After Class testing......
可以看到，整个过程中ClassRule只执行了一遍。

10 RuleChain

RuleChain 规则允许制定 TestRule的顺序。RuleChain提供一种将多个TestRule串在一起执行的机制，它首先从outChain()方法开始创建一个最外层的TestRule创建的Statement，而后调用round()方法，不断向内层添加TestRule创建的Statement。

public static class UseRuleChain {
@Rule
public TestRule chain= RuleChain
.outerRule(new LoggingRule("outer rule"))
.around(new LoggingRule("middle rule"))
.around(new LoggingRule("inner rule")); 

@Test
public void example() {
assertTrue(true);
}
} 

测试结果：

starting outer rule
starting middle rule
starting inner rule
finished inner rule
finished middle rule
finished outer rule

11 Custom Rules

扩展 ExternalResource 规则可以实现大部分需要个性化定制的规则。如果想要获取更过测试类的信息，则需要实现 TestRule接口。

import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement; 

public class IdentityRule implements TestRule {
@Override
public Statement apply(final Statement base, final Description description) {
return base;
}
} 

上面只是一个简单的实现。我们还可以在实现TestRule接口的时候建立自己的构造器、添加测试方法、将提供的Statemetn包装成一个新的Statement。

TestRule的一个实现：

import java.util.logging.Logger;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement; 

public class TestLogger implements TestRule {
private Logger logger; 

public Logger getLogger() {
return this.logger;
} 

@Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
logger = Logger.getLogger(description.getTestClass().getName() + '.' + description.getDisplayName());
try {
base.evaluate();
} finally {
logger = null;
}
}
};
}
} 

测试中使用：

import java.util.logging.Logger;
import com.junit.org.TestLogger;
import org.junit.Rule;
import org.junit.Test; 

public class MyLoggerTest { 

@Rule
public TestLogger logger = new TestLogger(); 

@Test
public void checkOutMyLogger() {
final Logger log = logger.getLogger();
log.warning("Your test is showing!");
}
} 

测试结果：

二月 03, 2015 4:59:34 下午 com.junit.org.MyLoggerTest checkOutMyLogger
警告: Your test is showing!