如何更好的做单元测试并用它来提升代码质量（上）

一个使用mockito和spring-test的例子

可以在：https://github.com/weipeng2k/mockito-sample找到示例。

       Java单元测试框架在业界非常多，以JUnit为事实上的标准，而JUnit只是解决了单元测试的基本骨干，而对于Mock的支持却没有。而同样，在Mock方面，Java也有很多开源的选择，诸如JMock、EasyMock和Mockito，而Mockito也同样为其中的翘楚，二者能够很好的完成单元测试的工作。本示例就是介绍如何使用二者来完成单元测试。如果公司自己搞一个单元测试框架，维护将成为一个大问题，而使用业界成熟的解决方案，将会是一个很好的方式。因为会有一组非常专业的人替你维护，而且不断地有新的Feature可以使用，同样你熟悉这些之后你可以不断的复用这些知识，而不会由于局限在某个特定的框架下（其实这些特定的框架也只是封装了业界的开源方案）。使用JUnit做单元测试的主体框架，如果有Spring的支持，可以使用spring-test进行支持，对于层与层之间的Mock，则使用Mockito来完成。

前言

引言

"I'm not a great programmer; I'm just a good programmer with great habits."
-- Kent Beck

       Java单元测试框架在业界非常多，以JUnit为事实上的标准，而JUnit只是解决了单元测试的基本骨干，而对于Mock的支持却没有。而同样，在Mock方面，Java也有很多开源的选择，诸如JMock、EasyMock和Mockito，而Mockito也同样为其中的翘楚，二者能够很好的完成单元测试的工作。本文就是介绍如何使用二者来完成单元测试。

存在的问题

       如果公司自己搞一个单元测试框架，维护将成为一个大问题，而使用业界成熟的解决方案，将会是一个很好的方式。因为会有一组非常专业的人替你维护，而且不断地有新的Feature可以使用，同样你熟悉这些之后你可以不断的复用这些知识，而不会由于局限在某个特定的框架下（其实这些特定的框架也只是封装了业界的开源方案）。

解决方案

       使用JUnit做单元测试的主体框架，如果有Spring的支持，可以使用spring-test进行支持，对于层与层之间的Mock，则使用Mockito来完成。

使用Mockito进行单元测试

以下例子可以在mockito-test-case中找到。

使用Mockito进行mock

       先看一下怎样使用Mockito进行一个对象的Mock，首先添加依赖：

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
</dependency>

       接下来尝试对java.util.List进行Mock，Mock对于List操作的内容进行构造。

构造Mock

       先看一下最简的使用方式。

public void mock_one() {
    List<String> list = Mockito.mock(List.class);

    Mockito.when(list.get(0)).thenReturn("one");

    System.out.println(list.get(0));

    Assert.assertEquals("one", list.get(0));
}

       上面代码中Mockito.mock可以构造一个Mock对象，这个对象没有任何作用，如果调用它的方法，如果有返回值的话，它会返回null。这个时候可以向其中加入mock逻辑，比如：Mockito.when(xxx.somemethod()).thenReturn(xxx)，这段逻辑就会在当有外界调用xxx.somemethod()时，返回那个在thenReturn中的对象。

构造一个复杂的Mock

       有时我们需要针对输入来构造Mock的输出，简单的when和thenReturn无法支持，这时就需要较为复杂的Answer。

@Test(expected = RuntimeException.class)
public void mock_answer() {
    List<String> list = Mockito.mock(List.class);
    Mockito.when(list.get(Mockito.anyInt())).thenAnswer(
            invocation -> {
                Object[] args = invocation.getArguments();
                int index = Integer.parseInt(args[0].toString());
                // int index = (int) args[0];
                if (index == 0) {
                    return "0";
                } else if (index == 1) {
                    return "1";
                } else if (index == 2) {
                    throw new RuntimeException();
                } else {
                    return String.valueOf(index);
                }
            });

    Assert.assertEquals("0", list.get(0));
    Assert.assertEquals("1", list.get(1));
    list.get(2);
}

       有时候需要构造复杂的返回逻辑，比如参数为1的时候，返回一个值，为2的时候，返回另一个值。那么when和thenAnswer就可以满足要求。

       上面代码可以看到当对于List的任意的输入Mockito.anyInt()，会进行Answer回调的处理，任何针对List的输入都会经过它的处理。这可以让我完成更加柔性和定制化的Mock操作。

断言选择

       当然我们可以使用System.out.println来完成目测，但是有时候需要让JUnit插件或者maven的surefire插件能够捕获住测试的失败，这个时候就需要使用断言了。我们使用org.junit.Assert来完成断言的判断，可以看到通过简单的assertEquals就可以了，当然该类提供了一系列的assertXxx来完成断言。

       使用IDEA在进行断言判断时非常简单，比Eclipse要好很多，比如：针对一个int x判断它等于0，就可以直接写x == 0，然后代码提示生成断言。

真实案例

       下面我们看一个较为真实的例子，比如：我们有个MemberService用来insertMember。

public interface MemberService {
    /**
     * <pre>
     * 插入一个会员，返回会员的主键
     * 如果有重复，则会抛出异常
     * </pre>
     *
     * @param name     name不能超过32个字符，不能为空
     * @param password password不能全部是数字，长度不能低于6，不超过16
     * @return PK
     */
    Long insertMember(String name, String password) throws IllegalArgumentException;
}

       其对应的实现。

public class MemberServiceImpl implements MemberService {

    private UserDAO userDAO;

    @Override
    public Long insertMember(String name, String password)
            throws IllegalArgumentException {
        if (name == null || password == null) {
            throw new IllegalArgumentException();
        }

        if (name.length() > 32 || password.length() < 6
                || password.length() > 16) {
            throw new IllegalArgumentException();
        }

        boolean pass = false;
        for (Character c : password.toCharArray()) {
            if (!Character.isDigit(c)) {
                pass = true;
                break;
            }
        }
        if (!pass) {
            throw new IllegalArgumentException();
        }

        Member member = userDAO.findMember(name);
        if (member != null) {
            throw new IllegalArgumentException("duplicate member.");
        }

        member = new Member();
        member.setName(name);
        member.setPassword(password);
        Long id = userDAO.insertMember(member);

        return id;
    }

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

}

       可以看到实现通过聚合了userDAO，来完成操作，而业务层的代码的单元测试代码，就必须隔离UserDAO，也就是说要Mock这个UserDAO。

       下面我们就使用Mockito来完成Mock操作。

public class MemberWithoutSpringTest {
    private MemberService memberService = new MemberServiceImpl();

    @Before
    public void mockUserDAO() {
        UserDAO userDAO = Mockito.mock(UserDAO.class);
        Member member = new Member();
        member.setName("weipeng");
        member.setPassword("123456abcd");
        Mockito.when(userDAO.findMember("weipeng")).thenReturn(member);

        Mockito.when(userDAO.insertMember((Member) Mockito.any())).thenReturn(
                System.currentTimeMillis());

        ((MemberServiceImpl) memberService).setUserDAO(userDAO);
    }

    @Test(expected = IllegalArgumentException.class)
    public void insert_member_error() {
        memberService.insertMember(null, "123");

        memberService.insertMember(null, null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void insert_exist_member() {
        memberService.insertMember("weipeng", "1234abc");
    }

    @Test(expected = IllegalArgumentException.class)
    public void insert_illegal_argument() {
        memberService
                .insertMember(
                        "akdjflajsdlfjaasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfsadfasdfasf",
                        "abcdcsfa123");
    }

    @Test
    public void insert_member() {
        System.out.println(memberService.insertMember("windowsxp", "abc123"));
        Assert.assertNotNull(memberService.insertMember("windowsxp", "abc123"));
    }
}

       可以看到，在测试开始的时候，利用了Before来完成Mock对象的构建，也就是说在test执行之前完成了Mock对象的初始化工作。

       但仔细看上述代码中，MemberService的实现MemberServiceImpl是直接构造出来的，它依赖了实现，但是我们的测试最好不要依赖实现进行测试的。同时UserDAO也是硬塞给MemberService的实现，这是因为我们常用Spring来装配类之间的关系，而单元测试没有Spring的支持，这就使得测试代码需要硬编码的方式来进行组装。

       那么我们如何避免这样的强依赖和组装代码的出现呢？结论就是使用spring-test来完成。

使用Spring-Test来进行单元测试

以下例子可以在classic-spring-test中找到。

       spring-test是springframework中一个模块，主要也是由spring作者Juergen Hoeller来完成的，它可以方便的测试基于spring的代码。

引入spring-test

       spring-test只需要引入依赖就可以完成测试，非常简单。它能够帮助我们启动一个测试的spring容器，完成属性的装配，但是它如何同Mockito集成起来是一个问题，我们采用配置的方式进行。

加入依赖

       增加依赖：

该版本一般和你使用的spring版本一致

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <scope>test</scope>
</dependency>

配置

       由于Mockito支持mock方法构造，所以我们可以将它通过spring factory bean的形式融入到 spring 的体系中。我们针对MemberService进行测试，需要对UserDAO进行Mock，我们只需要在配置中配置即可。

配置在MemberService.xml中，这里需要说明一下 没有使用共用的配置文件， 目的就是让大家在测试的时候能够相互独立，而且在一个配置文件中配置的Bean越多，就证明你要测试的类依赖越复杂，也就是越不合理，逼迫自己做重构。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"
       default-autowire="byName">

    <bean id="memberService" class="com.murdock.tools.mockito.service.MemberServiceImpl"/>

    <bean id="userDAO" class="org.mockito.Mockito" factory-method="mock">
        <constructor-arg>
            <value>com.murdock.tools.mockito.dao.UserDAO</value>
        </constructor-arg>
    </bean>
</beans>

       在进行spring测试之前，我们必须有一个spring的配置文件，用来构造applicationContext，注意上面红色的部分，这个UserDAO就是MemberServiceImpl需要的，而它利用了spring的FactoryBean方式，通过mock工厂方法完成了Mock对象的构造，其中的构造函数表明了这个Mock是什么类型的。只用在配置文件中声明一下就可以了。

构造Mock

       先看一下使用spring-test如何写单元测试：

@ContextConfiguration(locations = {"classpath:MemberService.xml"})
public class MemberSpringTest extends AbstractJUnit4SpringContextTests {
    @Autowired
    private MemberService memberService;
    @Autowired
    private UserDAO userDAO;

    /**
     * 可以选择在测试开始的时候来进行mock的逻辑编写
     */
    @Before
    public void mockUserDAO() {
        Mockito.when(userDAO.insertMember(Mockito.any())).thenReturn(
                System.currentTimeMillis());
    }

    @Test(expected = IllegalArgumentException.class)
    public void insert_member_error() {
        memberService.insertMember(null, "123");

        memberService.insertMember(null, null);
    }

    /**
     * 也可以选择在方法中进行mock
     */
    @Test(expected = IllegalArgumentException.class)
    public void insert_exist_member() {
        Member member = new Member();
        member.setName("weipeng");
        member.setPassword("123456abcd");
        Mockito.when(userDAO.findMember("weipeng")).thenReturn(member);

        memberService.insertMember("weipeng", "1234abc");
    }

    @Test(expected = IllegalArgumentException.class)
    public void insert_illegal_argument() {
        StringBuilder sb = new StringBuilder();
        IntStream.range(0, 32).forEach(sb::append);
        
        memberService.insertMember(sb.toString(), "abcdcsfa123");
    }

    @Test
    public void insert_member() {
        System.out.println(memberService.insertMember("windowsxp", "abc123"));
        Assert.assertNotNull(memberService.insertMember("windowsxp", "abc123"));
    }
}

       可以看到，通过继承AbstractJUnit4SpringContextTests就可以完成构造applicationContext的功能。当然通过ContextConfiguration指明当前的配置文件所在地，就可以完成applicationContext的初始化，同时利用Autowired完成配置文件中的Bean的获取。

       由于在MemberService.xml中针对UserDAO的mock配置，对应的mock对象会被注入到MemberSpringTest中，而后续的测试方法就可以针对它来编排mock逻辑。

       我们在Before逻辑中以及方法中均可以自由的裁剪mock逻辑，这样JUnit、spring-test和Mockito完美的统一到了一起。