Java测试套件 - Junit与Mockito

作者: 阿武_Accat | 来源:发表于2018-09-12 20:55 被阅读34次

说明

在第一份工作中，我经历了我的第一个商用的项目，是一个微服务模块（后台管理模块），我所在的团队做的是南方电网的项目。不扯远了，当时我开始做的时候在想要以什么方式开发时，我的组长因担心项目到期出不了成品，所以催促我快点产出代码。之后就有了这篇文章，由于我为了赶进度而没有做单元测试，这导致了项目的后半部分bug产出数量随着代码的增加而增加，更郁闷地是修改之后为了配合前端都得去服务器部署一次，浪费的时间不比写单元测试少，也让我明白了单元测试的重要性。我的要求是让自己学会TDD测试驱动开发的开发习惯，且写下该文记录自己学习的历程。

该文将介绍单元测试框架Junit，模仿对象的框架Mockito。文章介绍核心的概念，感兴趣可以进入参考文章或者书籍进一步阅读。

参考文章以及书籍

《测试驱动开发》
Hamcrest 总结
 深入JUnit源码之Rule
JUnit4.11 理论机制 @Theory 完整解读
 Junit4.8之Category
Mockito官方文档中文版
 Junit测试Controller-RESTful接口
 IDEA代码覆盖率测试

测试驱动开发-TDD

也有人把这种流程称为极限编程。

测试驱动开发是使用测试框架的目的，能更好更快地让我们写完代码然后傲游二次元或者是出门做个现充。

碧海之蓝 -- 羞耻的生活喜剧番

测试驱动开发指的是就是字面上的意思,用测试来驱动整个开发流程,也就是在写开发代码前先提前写测试代码,然后写业务代码来让测试通过。这里只是简单地概念性介绍，主要是要避免“开发后简单地验证结果”而转为“主动编写测试用例然后编写代码使用例通过”。

整个流程以就是不断重复下面几步：

Junit

JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.

Junit是一个简单的测试框架，其官网涵盖大量的用例可以作为使用参考。/home/harry

Junit 4 官网的用例

Assertions-断言机制

断言机制是判断结果是否正确的机制，总是以“assertXXXX”格式出现，只要有一条验证结果与预想不匹配，则测试不通过。
Hamcrest提供了其他的一些断言方式，请查看Hamcrest 总结。

import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.both;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.everyItem;
import static org.hamcrest.CoreMatchers.hasItems;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;

import org.hamcrest.core.CombinableMatcher;
import org.junit.Test;

public class AssertTests {
  @Test
  public void testAssertArrayEquals() {
    byte[] expected = "trial".getBytes();
    byte[] actual = "trial".getBytes();
    assertArrayEquals("failure - byte arrays not same", expected, actual);
  }

  @Test
  public void testAssertEquals() {
    assertEquals("failure - strings are not equal", "text", "text");
  }

  @Test
  public void testAssertFalse() {
    assertFalse("failure - should be false", false);
  }

  @Test
  public void testAssertNotNull() {
    assertNotNull("should not be null", new Object());
  }

  @Test
  public void testAssertNotSame() {
    assertNotSame("should not be same Object", new Object(), new Object());
  }

  @Test
  public void testAssertNull() {
    assertNull("should be null", null);
  }

  @Test
  public void testAssertSame() {
    Integer aNumber = Integer.valueOf(768);
    assertSame("should be same", aNumber, aNumber);
  }

  // JUnit Matchers assertThat
  @Test
  public void testAssertThatBothContainsString() {
    assertThat("albumen", both(containsString("a")).and(containsString("b")));
  }

  @Test
  public void testAssertThatHasItems() {
    assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
  }

  @Test
  public void testAssertThatEveryItemContainsString() {
    assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
  }

  // Core Hamcrest Matchers with assertThat
  @Test
  public void testAssertThatHamcrestCoreMatchers() {
    assertThat("good", allOf(equalTo("good"), startsWith("good")));
    assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
    assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
    assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
    assertThat(new Object(), not(sameInstance(new Object())));
  }

  @Test
  public void testAssertTrue() {
    assertTrue("failure - should be true", true);
  }
}

Runner-测试执行器

你写的测试代码都会在这些测试执行器中运行，Junit默认的执行器为BlockJUnit4ClassRunner，当你不指定时，就会使用这个类来运行测试。可以使用注解@RunWith(xxxx)来指定运行测试的执行器。

Suite组合测试

Suite测试在Junit中是测试一组测试用例，用途比较明确，就是有些操作是需要执行多个操作才能完成的，所以可以组成一个组来进行测试。

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({
  TestFeatureLogin.class,
  TestFeatureLogout.class,
  TestFeatureNavigate.class,
  TestFeatureUpdate.class
})

public class FeatureTestSuite {
  // the class remains empty,
  // used only as a holder for the above annotations
}

指定期待异常

如果没有抛出指定异常则测试不通过。

@Test(expected = IndexOutOfBoundsException.class) 
public void empty() { 
     new ArrayList<Object>().get(0); 
}

忽略测试

可以让测试暂时失效。

@Ignore("Test is ignored as a demonstration")
@Test
public void testSame() {
    assertThat(1, is(1));
}

测试失效时间

@Test(timeout=1000)
public void testWithTimeout() {
  ...
}

Rule机制

JUnit中的Rule是对@BeforeClass、@AfterClass、@Before、@After等注解的另一种实现，其中@ClassRule实现的功能和@BeforeClass、@AfterClass类似；@Rule实现的功能和@Before、@after类似。JUnit引入@ClassRule和@Rule注解的关键是想让以前在@BeforeClass、@AfterClass、@Before、@After中的逻辑能更加方便的实现重用，因为@BeforeClass、@AfterClass、@Before、@After是将逻辑封装在一个测试类的方法中的，如果实现重用，需要自己将这些逻辑提取到一个单独的类中，再在这些方法中调用，而@ClassRule、@Rule则是将逻辑封装在一个类中，当需要使用时，直接赋值即可，对不需要重用的逻辑则可用匿名类实现，也因此，JUnit在接下来的版本中更倾向于多用@ClassRule和@Rule。

Junit @Rule和@ClassRule只能注解在字段上，且该字段必须实现TestRule接口，Junit提供了一些默认实现类。

深入JUnit源码之Rule类图 - 来源于博文《深入JUnit源码之Rule》

public class DigitalAssetManagerTest {
  @Rule
  public final TemporaryFolder tempFolder = new TemporaryFolder();

  @Rule
  public final ExpectedException exception = ExpectedException.none();

  @Test
  public void countsAssets() throws IOException {
    File icon = tempFolder.newFile("icon.png");
    File assets = tempFolder.newFolder("assets");
    createAssets(assets, 3);

    DigitalAssetManager dam = new DigitalAssetManager(icon, assets);
    assertEquals(3, dam.getAssetCount());
  }

  private void createAssets(File assets, int numberOfAssets) throws IOException {
    for (int index = 0; index < numberOfAssets; index++) {
      File asset = new File(assets, String.format("asset-%d.mpg", index));
      Assert.assertTrue("Asset couldn't be created.", asset.createNewFile());
    }
  }

  @Test
  public void throwsIllegalArgumentExceptionIfIconIsNull() {
    exception.expect(IllegalArgumentException.class);
    exception.expectMessage("Icon is null, not a file, or doesn't exist.");
    new DigitalAssetManager(null, null);
  }
}

Theory机制

Theory是一个自动化填充参数并进行多次参数测试的一个机制，可以自己实现注解来定义参数。下面的代码中，定义了两个实参，而当测试 filenameIncludesUsername 方法时，形参username会被两个实参填充并各执行一次。

@RunWith(Theories.class)
public class UserTest {
    @DataPoint
    public static String GOOD_USERNAME = "optimus";
    @DataPoint
    public static String USERNAME_WITH_SLASH = "optimus/prime";

    @Theory
    public void filenameIncludesUsername(String username) {
        assumeThat(username, not(containsString("/")));
        assertThat(new User(username).configFileName(), containsString(username));
    }
}

Test Fixture 测试固件

The test fixture is everything we need to have in place to exercise the SUT

Test Fixture(测试固件)是指一个测试运行所需的固定环境。

Fixtures 是测试中非常重要的一部分。他们的主要目的是建立一个固定/已知的环境状态以确保测试可重复并且按照预期方式运行。Junit提供了一些方法来设置fixture，可以用来设置测试方法所需的环境数据等,允许你精确的定义你的Fixtures。大致上分为三类：
Test Fixtures
规则(Rules＆RulesClass)
Theories

大致包含了如下过程

@BeforeClass setUpClass
@Before setUp
@Test test2()
@After tearDown
@Before setUp
@Test test1()
@After tearDown
@AfterClass tearDownClass

Category机制

一种级联的测试方式,
@IncludeCategory(XXX.class)可以包含@Category(XXX.class)
@ExcludeCategory(XXX.class)将会忽略@Category(XXX.class)
细节参照博文

Mock和Mockito

mock其实是一种工具的简称，他最大的功能是帮你把单元测试的耦合分解开，如果你的代码对另一个类或者接口有依赖，它能够帮你模拟这些依赖，并帮你验证所调用的依赖的行为。

对象间存在依赖关系

使用Mock来模仿对象，消除耦合关系

下面的代码来自官网示例

1. 验证某些行为

 // 静态导入会使代码更简洁
 import static org.mockito.Mockito.*;

 // mock creation 创建mock对象
 List mockedList = mock(List.class);

 //using mock object 使用mock对象
 mockedList.add("one");
 mockedList.clear();

 //verification 验证
 verify(mockedList).add("one");
 verify(mockedList).clear();

2. 制作测试桩

 //You can mock concrete classes, not only interfaces
 // 你可以mock具体的类型,不仅只是接口
 LinkedList mockedList = mock(LinkedList.class);

 //stubbing
 // 测试桩
 when(mockedList.get(0)).thenReturn("first");
 when(mockedList.get(1)).thenThrow(new RuntimeException());

 //following prints "first"
 // 输出“first”
 System.out.println(mockedList.get(0));

 //following throws runtime exception
 // 抛出异常
 System.out.println(mockedList.get(1));

 //following prints "null" because get(999) was not stubbed
 // 因为get(999) 没有打桩，因此输出null
 System.out.println(mockedList.get(999));

 //Although it is possible to verify a stubbed invocation, usually it's just redundant
 //If your code cares what get(0) returns then something else breaks (often before even verify() gets executed).
 //If your code doesn't care what get(0) returns then it should not be stubbed. Not convinced? See here.
 // 验证get(0)被调用的次数
 verify(mockedList).get(0);

默认情况下，所有的函数都有返回值。mock函数默认返回的是null，一个空的集合或者一个被对象类型包装的内置类型，例如0、false对应的对象类型为Integer、Boolean。

3. 参数匹配器(ArgumentMatchers)

//stubbing using built-in anyInt() argument matcher
 // 使用内置的anyInt()参数匹配器
 when(mockedList.get(anyInt())).thenReturn("element");

 //stubbing using custom matcher (let's say isValid() returns your own matcher implementation):
 // 使用自定义的参数匹配器( 在isValid()函数中返回你自己的匹配器实现 )
 when(mockedList.contains(argThat(isValid()))).thenReturn("element");

 //following prints "element"
 // 输出element
 System.out.println(mockedList.get(999));

 //you can also verify using an argument matcher
 // 你也可以验证参数匹配器
 verify(mockedList).get(anyInt());

verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));
//above is correct - eq() is also an argument matcher
// 上述代码是正确的,因为eq()也是一个参数匹配器
// 该示例展示了如何多次应用于测试桩函数的验证

参数匹配器使验证和测试桩变得更灵活，参考API文档。

4. 验证函数的确切、最少、从未调用次数

 //using mock
 mockedList.add("once");

 mockedList.add("twice");
 mockedList.add("twice");

 mockedList.add("three times");
 mockedList.add("three times");
 mockedList.add("three times");

 //following two verifications work exactly the same - times(1) is used by default
 // 下面的两个验证函数效果一样,因为verify默认验证的就是times(1)
 verify(mockedList).add("once");
 verify(mockedList, times(1)).add("once");

 //exact number of invocations verification
 // 验证具体的执行次数
 verify(mockedList, times(2)).add("twice");
 verify(mockedList, times(3)).add("three times");

 //verification using never(). never() is an alias to times(0)
 // 使用never()进行验证,never相当于times(0)
 verify(mockedList, never()).add("never happened");

 //verification using atLeast()/atMost()
 // 使用atLeast()/atMost()
 verify(mockedList, atLeastOnce()).add("three times");
 verify(mockedList, atLeast(2)).add("five times");
 verify(mockedList, atMost(5)).add("three times");

5. 使用stub抛出异常

doThrow(new RuntimeException()).when(mockedList).clear();

//following throws RuntimeException:
// 调用这句代码会抛出异常
mockedList.clear();

6. 验证执行顺序

 // A. Single mock whose methods must be invoked in a particular order
 // A. 验证mock一个对象的函数执行顺序
 List singleMock = mock(List.class);

 //using a single mock
 singleMock.add("was added first");
 singleMock.add("was added second");

 //create an inOrder verifier for a single mock
 // 为该mock对象创建一个inOrder对象
 InOrder inOrder = inOrder(singleMock);

 //following will make sure that add is first called with "was added first, then with "was added second"
 // 确保add函数首先执行的是add("was added first"),然后才是add("was added second")
 inOrder.verify(singleMock).add("was added first");
 inOrder.verify(singleMock).add("was added second");

 // B. Multiple mocks that must be used in a particular order
 // B .验证多个mock对象的函数执行顺序
 List firstMock = mock(List.class);
 List secondMock = mock(List.class);

 //using mocks
 firstMock.add("was called first");
 secondMock.add("was called second");

 //create inOrder object passing any mocks that need to be verified in order
 // 为这两个Mock对象创建inOrder对象
 InOrder inOrder = inOrder(firstMock, secondMock);

 //following will make sure that firstMock was called before secondMock
 // 验证它们的执行顺序
 inOrder.verify(firstMock).add("was called first");
 inOrder.verify(secondMock).add("was called second");

 // Oh, and A + B can be mixed together at will

7. 确保交互(interaction)操作不会执行在mock对象上

 //using mocks - only mockOne is interacted
 // 使用Mock对象
 mockOne.add("one");

 //ordinary verification
 // 普通验证
 verify(mockOne).add("one");

 //verify that method was never called on a mock
 // 验证某个交互是否从未被执行
 verify(mockOne, never()).add("two");

 //verify that other mocks were not interacted
 // 验证mock对象没有交互过
 verifyZeroInteractions(mockTwo, mockThree);

8. 简化mock对象的创建

public class ArticleManagerTest {

   @Mock private ArticleCalculator calculator;
   @Mock private ArticleDatabase database;
   @Mock private UserProvider userProvider;

   private ArticleManager manager;
    // 需要执行下面语句来初始化注解的使用
   @Before  
   public void initMocks() {  
    MockitoAnnotations.initMocks(this);  
   }  

    //也可以在测试类加上注解@RunWith(MockitoJUnit44Runner.class)  
    //或者使用MockitoJUnitRunner

9. 为连续的调用做测试桩

 when(mock.someMethod("some arg"))
   .thenThrow(new RuntimeException())
   .thenReturn("foo");

 //First call: throws runtime exception:
 // 第一次调用 : 抛出运行时异常
 mock.someMethod("some arg");

 //Second call: prints "foo"
 // 第二次调用 : 输出"foo"
 System.out.println(mock.someMethod("some arg"));

 //Any consecutive call: prints "foo" as well (last stubbing wins).
 // 后续调用 : 也是输出"foo"
 System.out.println(mock.someMethod("some arg"));

// 简短的写法,第一次调用时返回"one",第二次返回"two",第三次返回"three"
 when(mock.someMethod("some arg"))
   .thenReturn("one", "two", "three");

10. 为回调做测试桩

Allows stubbing with generic Answer interface. 运行为泛型接口Answer打桩。

 when(mock.someMethod(anyString())).thenAnswer(new Answer() {
     Object answer(InvocationOnMock invocation) {
         Object[] args = invocation.getArguments();
         Object mock = invocation.getMock();
         return "called with arguments: " + args;
     }
 });

 //Following prints "called with arguments: foo"
 // 输出 : "called with arguments: foo"
 System.out.println(mock.someMethod("foo"));

11. 监控真实对象

你可以为真实对象创建一个监控(spy)对象。当你使用这个spy对象时真实的对象也会也调用，除非它的函数被stub了。

List list = new LinkedList();
List spy = spy(list);

//optionally, you can stub out some methods:
// 你可以为某些函数打桩
when(spy.size()).thenReturn(100);

//using the spy calls *real* methods
// 通过spy对象调用真实对象的函数
spy.add("one");
spy.add("two");

//prints "one" - the first element of a list
// 输出第一个元素
System.out.println(spy.get(0));

//size() method was stubbed - 100 is printed
// 因为size()函数被打桩了,因此这里返回的是100
System.out.println(spy.size());

//optionally, you can verify
// 交互验证
verify(spy).add("one");
verify(spy).add("two");

12. 为下一步的断言捕获参数(ArgumentCaptor)

ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
// 参数捕获
verify(mock).doSomething(argument.capture());
// 使用equal断言
assertEquals("John", argument.getValue().getName());

13. TDD与BDD(行为驱动开发)结合使用

 import static org.mockito.BDDMockito.*;

 Seller seller = mock(Seller.class);
 Shop shop = new Shop(seller);

 public void shouldBuyBread() throws Exception {

   //given
   given(seller.askForBread()).willReturn(new Bread());

   //when
   Goods goods = shop.buyBread();

   //then
   assertThat(goods, containBread());
 }

14. @Captor,@Spy,@ InjectMocks

@Captor 简化 ArgumentCaptor 的创建 - 当需要捕获的参数是一个令人讨厌的通用类，而且你想避免编译时警告。

@Spy - 你可以用它代替 spy(Object) 方法

@InjectMocks - 自动将模拟对象或侦查域注入到被测试对象中。需要注意的是 @InjectMocks 也能与 @Spy 一起使用，这就意味着 Mockito 会注入模拟对象到测试的部分测试中。它的复杂度也是你应该使用部分测试原因。

15. 验证超时

   //passes when someMethod() is called within given time span
   verify(mock, timeout(100)).someMethod();
   //above is an alias to:
   verify(mock, timeout(100).times(1)).someMethod();

   //passes when someMethod() is called *exactly* 2 times within given time span
   verify(mock, timeout(100).times(2)).someMethod();

   //passes when someMethod() is called *at least* 2 times within given time span
   verify(mock, timeout(100).atLeast(2)).someMethod();

   //verifies someMethod() within given time span using given verification mode
   //useful only if you have your own custom verification modes.
   verify(mock, new Timeout(100, yourOwnVerificationMode)).someMethod();

以上内容，足以让我们使用Junit 4进行日常代码的单元测试

使用Junit + Mockito 对Service做单元测试


public interface RegisterUserService {  
    boolean insert(String passid,String msisdn,String email) throws SQLException;
}   

@Service("registerUserService")
public class RegisterUserServiceImpl implements RegisterUserService {
 
    private Logger loggor = Logger.getLogger(getClass());
 
    
 
    @Autowired
    private UserMapper userMapper;
 
    @Autowired
    private PassidUserMapper passidUserMapper;
 
    @Autowired
    @Qualifier("redisService")
    private CacheService redisService;
 
    
 
    @Override
    @Transactional
    public boolean insert(String passid, String msisdn, String email)
            throws SQLException {
        if (StringUtils.isEmpty(passid))
            return false;
 
        User user = new User();
        if (!StringUtils.isEmpty(msisdn))
            user.setPhoneNo(msisdn);
        if (!StringUtils.isEmpty(email))
            user.setEmail(email);
 
        PassidUser passidUser = new PassidUser();
        String serverCode = ServerCodeConfig.serverCodeMap
                .get(PayUtil.ipAddress);
        if (StringUtils.isEmpty(serverCode)) {
            serverCode = "999";
        }
        String userid = serverCode + UIDUtil.next();
        passidUser.setUserid(userid);
        passidUser.setPassid(passid);
 
        user.setPassid(passid);
        user.setUserid(userid);
        Date date = new Date();
        user.setCreateTime(date);
        user.setUpdateTime(date);
        user.setDeleteFlag(0);
 
        /*if(loggor.isInfoEnabled()){
            loggor.info("passid:" + passid + "  userid:" + userid + "  msisdn:"
                    + msisdn + "  email:" + email);
        }*/
 
        int result = passidUserMapper.insert(passidUser);
 
        if (passidUserMapper.insert(passidUser) > 0
                && userMapper.insertSelective(user) > 0)
            redisService.set("passid:" + passid + ":userid", userid);
        else
            throw new SQLException("数据插入失败，数据回滚");
 
        return true;
    }
 
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("file:src/main/resources/conf/springConfig.xml")
public class RegisterUserServiceImplTest {
 
    @InjectMocks
    private RegisterUserService registerUserService = new RegisterUserServiceImpl();
 
    @Mock
    private UserMapper userMapper;
 
    @Mock
    private PassidUserMapper passidUserMapper;
 
    @Mock
    private CacheService redisService;
 
    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        when(passidUserMapper.insert(any(PassidUser.class))).thenReturn(1);
        when(userMapper.insertSelective(any(User.class))).thenReturn(1);
    }
 
    @Test
    public void testInsert() throws Exception {
        String passid = "12344";
        String msisdn = "18867131210";
        String email = "test@test.cn";
        Assert.assertTrue(registerUserService.insert(passid, msisdn, email));
 
    }
}

使用SpringMVC，Junit， Mockito测试Controller(Restful接口)

<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>${spring.version}</version>  
</dependency>  
  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-webmvc</artifactId>  
    <version>${spring.version}</version>  
</dependency>
<dependency>  
    <groupId>junit</groupId>  
    <artifactId>junit</artifactId>  
    <version>${junit.version}</version>  
    <scope>test</scope>  
</dependency>  
  
<dependency>  
    <groupId>org.hamcrest</groupId>  
    <artifactId>hamcrest-core</artifactId>  
    <version>${hamcrest.core.version}/version>  
    <scope>test</scope>  
</dependency>  
<dependency>  
    <groupId>org.mockito</groupId>  
    <artifactId>mockito-core</artifactId>  
    <version>${mockito.core.version}</version>  
    <scope>test</scope>  
</dependency>  
  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-test</artifactId>  
    <version>${spring.version}</version>  
    <scope>test</scope>  
</dependency>

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.RequestBuilder;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

/**
* Created by zhengcanrui on 16/8/11.
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/applicationContext-*xml"})

//配置事务的回滚,对数据库的增删改都会回滚,便于测试用例的循环利用
@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = true)
@Transactional

@WebAppConfiguration
public class Test {
   //记得配置log4j.properties ,的命令行输出水平是debug
   protected Log logger= LogFactory.getLog(TestBase.class);

   protected MockMvc mockMvc;

   @Autowired
   protected WebApplicationContext wac;

   @Before()  //这个方法在每个方法执行之前都会执行一遍
   public void setup() {
       mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();  //初始化MockMvc对象
   }

   @org.junit.Test
   public void getAllCategoryTest() throws Exception {
       String responseString = mockMvc.perform(
               get("/categories/getAllCategory")    //请求的url,请求的方法是get
                       .contentType(MediaType.APPLICATION_FORM_URLENCODED)  //数据的格式
　　　　　　　　　　　　　　 .param("pcode","root")         //添加参数
       ).andExpect(status().isOk())    //返回的状态是200
               .andDo(print())         //打印出请求和相应的内容
               .andReturn().getResponse().getContentAsString();   //将相应的数据转换为字符串
       System.out.println("--------返回的json = " + responseString);
   }

}

Spring MVC的测试往往看似比较复杂。其实他的不同在于，他需要一个ServletContext来模拟我们的请求和响应。
@webappconfiguration是一级注释，用于声明一个ApplicationContext集成测试加载WebApplicationContext。作用是模拟ServletContext。

@ContextConfiguration：因为controller，component等都是使用注解，需要注解指定spring的配置文件，扫描相应的配置，将类初始化等。

perform：执行一个RequestBuilder请求，会自动执行SpringMVC的流程并映射到相应的控制器执行处理；
get:声明发送一个get请求的方法。MockHttpServletRequestBuilder get(String urlTemplate, Object... urlVariables)：根据uri模板和uri变量值得到一个GET请求方式的。另外提供了其他的请求的方法，如：post、put、delete等。
param：添加request的参数，如上面发送请求的时候带上了了pcode = root的参数。假如使用需要发送json数据格式的时将不能使用这种方式，可见后面被@ResponseBody注解参数的解决方法
andExpect：添加ResultMatcher验证规则，验证控制器执行完成后结果是否正确（对返回的数据进行的判断）；
andDo：添加ResultHandler结果处理器，比如调试时打印结果到控制台（对返回的数据进行的判断）；
andReturn：最后返回相应的MvcResult；然后进行自定义验证/进行下一步的异步处理（对返回的数据进行的判断）；

写RESTful接口测试时需要注意返回的数据格式要标注成JSON ： MediaType.APPLICATION_JSON

SoftInfo softInfo = new SoftInfo();
　　　　　　//设置值
　　　　　ObjectMapper mapper = new ObjectMapper();
        ObjectWriter ow = mapper.writer().withDefaultPrettyPrinter();
        java.lang.String requestJson = ow.writeValueAsString(softInfo);
        String responseString = mockMvc.perform( post("/softs").contentType(MediaType.APPLICATION_JSON).content(requestJson)).andDo(print())
                .andExpect(status().isOk()).andReturn().getResponse().getContentAsString();

最后关于代码覆盖率

Intellij IDEA对这方面做了集成支持，右键运行测试代码

右键测试代码选择覆盖率测试
可以在包含有单元测试的代码中看到，绿色为已经覆盖的部分，红色未覆盖。

绿已覆盖，红未覆盖