如何更好的做单元测试（上）

作者: weipeng2k | 来源:发表于2018-12-23 20:23 被阅读0次

前言

引言

"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完美的统一到了一起。

现代化的spring-test使用方式

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

在classic-spring-test中演示的单元测试，还是用配置文件的方式，但是从Spring4之后，官方就鼓励使用Java的方式对spring进行配置，而不是用以前那样的xml配置形式了，因此我们基于注解可以来简化单元测试的编写，我们称之为现代化的spring-test方式。

修改单元测试

测试不用继承AbstractJUnit4SpringContextTests，通过注解即可，然后对于bean的配置，可以通过Java配置风格完成

注解

使用RunWith和ContextConfiguration配置即可将一个类声明为支持Spring容器的测试用例。

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = MemberJavaConfigTest.MemberServiceConfig.class)
public class MemberJavaConfigTest {
}

注解	说明
`RunWith`	该注解是`junit`提供的，表示用那种方式来执行这个测试，这里是`SpringRunner`，由`spring-test`提供
`ContextConfiguration`	对测试的Spring容器的配置，比如：配置的位置等

配置与示例

通过注解可以声明按照何种方式去执行测试，以及测试的Spring容器如何组装，但是还或缺在Spring容器中如何配置Bean，以前这是通过xml来进行配置的。

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = MemberJavaConfigTest.MemberServiceConfig.class)
public class MemberJavaConfigTest {

    @Autowired
    private MemberService memberService;

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

    @Configuration
    static class MemberServiceConfig {

        @Bean
        public MemberService memberService(UserDAO userDAO) {
            MemberServiceImpl memberService =  new MemberServiceImpl();
            memberService.setUserDAO(userDAO);
            return memberService;
        }

        @Bean
        public UserDAO userDAO() {
            UserDAO mock = Mockito.mock(UserDAO.class);
            Mockito.when(mock.insertMember(Mockito.any())).thenReturn(System.currentTimeMillis());
            return mock;
        }
    }
}

可以看到只需要有一个类，被注解了Configuration，该类就是一个配置类型，而这种Java Config Style已经是Spring官方推荐的方式了。

Bean注解类似xml中的bean标签，这里配置了两个Bean一个MemberService的实现，另外一个是mock的UserDAO。其中对MemberService的配置需要依赖UserDAO。

剩下的测试过程就和之前classic-spring-test完全一致了，可以看到新的方式没有了恼人的xml配置，变得更加直接和高效。

如何更好的做单元测试（上）

前言

引言

存在的问题

解决方案

使用Mockito进行单元测试

使用Mockito进行mock

构造Mock

构造一个复杂的Mock

断言选择

真实案例

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

引入spring-test

加入依赖

配置

构造Mock

现代化的spring-test使用方式

修改单元测试

注解

配置与示例

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

程序员