什么是无效的单元测试

  这里仅仅从代码层面来说明无效的单元测试。

不验证结果

   待测试的类

public class BaseService {
  public String getId(String key) {
    if (key == null) {
      return null;
    }
    return "value";
  }
}

  对应的单元测试

import org.junit.Test;
public class BaseServiceTest {
  private BaseService baseService = new BaseService();
  @Test
  public void testGetId() {
    baseService.getId("123");
  }
}

  参数为null跟非null的测试结果没有区别，等于白写。
  正确的姿势应该为：

Assert.assertEquals("value123", baseService.getId("123"));

测试总是通过

  待测试的类

public class BaseService {
  public String getId(String key) {
    if (key == null) {
      throw new RuntimeException("无效的参数");
    }
    return "value"+key;
  }
}

  对应的单元测试

import org.junit.Assert;
import org.junit.Test;

public class BaseServiceTest {
  private BaseService baseService = new BaseService();
  @Test
  public void testGetId() {
    try {
      Assert.assertEquals("value123", baseService.getId("123"));
    } catch (Exception e) {
    }
  }
}

  这次虽然验证了结果，但传参为null时抛出的异常都被try catch了，单元测试总是绿的，总是通过。抛出异常时应该保证测试是红的。

  try {
      Assert.assertEquals("value123", baseService.getId(null));
    } catch (Exception e) {
      // 若抛出不期望的异常报错
      Assert.fail(e.getMessage());
    }

不可重复

  待测试的类

 public class BaseService {

  @Autowired
  private BaseDao dao;

  public String getId(String key) {
    if (key == null) {
      throw new RuntimeException("无效的参数");
    }
    return dao.queryByValueByKey(key);
  }
}

  对应的单元测试

import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.junit.Assert;
import org.junit.Test;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
public class BaseServiceTest {
  private BaseService baseService = new BaseService();
  @Test
  public void testGetId() {
    try {
      Assert.assertEquals("value123", baseService.getId("123"));
    } catch (Exception e) {
      // 产生异常
      Assert.fail(e.getMessage());
    }
  }
}

  验证了结果，对产生的异常报错。但该测试基于Spring test，基于真实的数据库来初始化BaseDao，根据主键从数据库中查询对应的值。换个环境数据库的值不一样测试就挂了。

测试永远不会结束

  待测试的类

import org.springframework.beans.factory.annotation.Autowired;
/**
 * 当数据库中待处理的交易小于10条继续其他逻辑
 */
public class BaseService {
  @Autowired
  private BaseDao dao;
  public void tradeProcessing( ) throws Exception {
    while (true) {
      if (dao.queryPendingTradeSize() <= 10) {
        // 交易小于10条跳出循环
        break;
      }
      // 每10秒检查一次
      Thread.sleep(10000);
    }
    // 交易小于十条，继续处理其他业务逻辑
  }
}

  对应的单元测试
  通过Mockito解耦，并且成功通过测试。

import org.junit.Assert;
import org.junit.Test;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import com.haier.hairy.p2p.db.dao.bid.BaseDao;

/**
 * 采用Mockito启动器启动Junit
 */
@RunWith(MockitoJUnitRunner.class)
public class BaseServiceTest {

  /**
   * 模拟dao，从数据库解耦
   */
  @Mock
  private BaseDao dao;
  /**
   * 把mock出来的dao注入待测试的类
   */
  @InjectMocks
  private BaseService baseService = new BaseService();

  @Before
  public void setUp() {
    // 模拟待处理交易小于10的处理行为
    Mockito.when(dao.queryPendingTradeSize()).thenReturn(9);
  }

  @Test
  public void testGetId() {
    try {
      baseService.tradeProcessing( );
      //验证结果
      Mockito.verify(dao).queryPendingTradeSize();
    } catch (Exception e) {
      Assert.fail(e.getMessage());
    }
  }
}

  把跳出while循环的条件更改为小于5条。

      if (dao.queryPendingTradeSize() <= 5) {
        // 交易小于5条跳出循环
        break;
      }

  由于模拟的返回值是9，大于5，永远无法跳出while循环，测试永远不会结束。

Mockito.when(dao.queryPendingTradeSize()).thenReturn(9);

  单元测试至少应该保证业务逻辑变更的时候报错。针对包含while、线程锁等容易陷入死循环的代码（业务代码里面难免的），应该给单元测试加上超时检测，超过期望的时间结束测试。

@Test(timeout = 1000) // timeout的单位是毫秒