乐趣区

走进JavaWeb技术世界11单元测试框架Junit

微信公众号【黄小斜】大厂程序员,互联网行业新知,终身学习践行者。关注后回复「Java」、「Python」、「C++」、「大数据」、「机器学习」、「算法」、「AI」、「Android」、「前端」、「iOS」、「考研」、「BAT」、「校招」、「笔试」、「面试」、「面经」、「计算机基础」、「LeetCode」等关键字可以获取对应的免费学习资料。

                     

JUnit 你不知道的那些事儿

转自 老刘 码农翻身 2016-02-24

话说有一次 Eric Gamma 坐飞机的时候偶遇 Kent Beck(对,就是极限编程和 TDD 的发起人),两位大牛见面寒暄过以后就觉得很无聊了。

旅途漫漫,干点啥好呢。

Kent Beck 当时力推测试驱动开发,  但是没有一个工具或者框架能让大家轻松愉快的写测试,并且自动的运行测试。

两人勾兑了一下:不如自己挽起袖子写一个,于是两人就在飞机上结对编程,等到飞机的时候,一个划时代的单元测试工具就新鲜出炉了,这就是 JUnit:

JUnit 当然是用 Java 写的,其他语言一看,这东西好,咱也搞一套,于是就有了一大批工具,统称 xUnit

NUnit (针对.Net 平台) ,  CUnit (针对 C 语言) , CppUnit(针对 C ++ 语言),PyUnit (针对 Python),PHPUnit, OCUnit, DUnit, JSUnit ……

超级大牛出马,亲自敲出来的代码自然非同凡响,它的设计简直就是使用设计模式的典范:

更牛的是,他们是以一种叫做“模式生成架构”的方法来创建 JUnit 的,换句话说,就是从零应用模式,然后一个接一个,直到你获取最终的系统架构:

我第一次看到这种方式,真是惊为天人,我知道代码要向模式进行重构,还从来没听过由模式来构建系统!

但一想到 Eric Gamma 的背景,就没有什么可惊讶的了,因为 Eric Gamma 实际上是划时代的书籍《设计模式:可复用面向对象软件基础》四位合著者(称为 GoF,Gang of Four)之一

这本书的经典地位就不用说了,像 JUnit 繁衍出来的 xUnit 一样,这本书也有很多的“繁衍品”,例如

《Head First Degisn Pattern》,《设计模式解析》,《大话设计模式》。。。。

JUnit 超级流行,几乎是事实上的 Java 单元测试和 TDD 的工具标准,有人选择了 GitHub 上最热的三门语言 Java,Ruby 和 Javascript,对每个语言分析了 1000 个项目,找出了最常用的组件,可以看到 JUnit 以 30.7% 并列第一

所以 JUnit 已经变成了程序员必备的技能,不会 JUnit 就太 Out 了。

Junit 入门

1、什么是 Junit4

JUnit4 是一个易学易用的 Java 单元测试框架,一般我们在写完一段代码或一个方的时候,都要测试一下这段代码和这个方法的逻辑是不是正确,输入一定的数据,返回的数据是不是我们想要的结果,即我们在写单个业务代码针对结果进行测试。这时 Junit 就派上了大用场了。

2、为何使用 Junit4

也许有的初学者会说,项目完成之后测试不行吗?如果你要这么想的话,那就了,因为随着你代码的增加,你牵扯到的模块和项目中的逻辑就会越来越多,这样测试起来就会非常的麻烦,而且容易出错。Junit 看起来是增加了代码量,可是它可以大大的减少后期的测试时间,提升代码的质量,让代码更易于维护。

3、Junit4 的快速入门

下载并导入 Junitjar 包:

首先得需要去网上下载一个 Junit4 的一个 jar 包,保存到自己本地电脑里面打开 myEclipse 新建一个 Java 项目,通过右击项目 –>Build Path —>Configure Build Path –>Add External JARs—> 找到自己刚保存的 jar 路径,点击 OK 就可以啦

创建测试目录:

接下来就要为我们的测试建立特殊的路径,这个特殊特殊在哪里呢,因为我们的测试代码要单独保存不能与源代码进行混淆,到项目结束后可以直接把它删除,而且不会对项目造成影响。怎么创建呢:右击项目名称 —>new—->suorce folder—> 输入你想要的测试文件名点击 OK 就可以啦。

接下来我们得在项目中的 src 目录下创建一个包,注意这儿的包名和 test 里面的包名要保持一致,在我们 src 的包下写我们项目的逻辑方法,在 test 的报下写我们的测试方法,结构如图所示,

image.png

下面我们来写一段简单的逻辑代码进行测试演练


package com.junit;

public class method_junti {public int add(int a, int b) {return a + b;}

    public int subtract(int a, int b) {return a - b;}

    public int multiply(int a, int b) {return a * b;}

    public int division(int a, int b) {return a / b;}
}

方法很简单,就是一般的加减乘除,下面我们就可以进行测试了,怎么测试呢:在我们的测试目录下新建测试类 junit_test,然后定义测试方法。代码如下:


package com.junit;
import static org.junit.Assert.*;
import org.junit.Test;
public class junit_test {

    // 测试方法必须有 @test;// 该测试方法必须由 public void 修饰,没有返回值;// 该方法不带任何参数;// 新建一个源代码测试文件单独存放测试代码;// 测试类的包和被测试类的包保持一致;// 测试方法间互相独立没有任何依赖;@Test
    public void testAdd(){assertEquals(4, new method_junti().add(3, 0));
    }

    @Test
    public void testSubtract(){assertEquals(3, new method_junti().subtract(6, 3));
    }

    @Test
    public void testMultiply(){assertEquals(6, new method_junti().multiply(6, 1));
    }

    @Test
    public void testDivision(){assertEquals(6, new method_junti().division(6, 1));
    }
}

下面来讲解一下 assertEquals()这个函数,它的第一个参数是你预期的一个结果,第二个参数使我们想测试的函数,这个函数我们要通过先 new 出函数所在的类,然后通过类来调用方法,方法里面的参数就是你在写该方法是传进来的参数。在这里最好在你需要测试的方法的前面加上 test,这样的话就会比较规范一些

写完之后你可以点击测试类,然后在点击 run as,再点击 Junit test,你就能在弹出的窗口中看到你的测试结果,它会提示你失败的个数和错误的个数。如果你只想测试一个方法怎么办呢,在你创建的测试类的下面还有目录,列表里面的会列出你所有的测试方法,你就可以右击你想测试的方法,然后 run as —> junit test,测试成功后就会看到一个绿色的条,结果如图:

image.png

在这里如果我们每一个方法都要自己手动的敲出它的测试方法,在这里我们只是简单的测试了几个方法,在项目中如果我们有很多的方法需要测试,一个一个的敲的话会有些浪费时间了,这里给大家介绍一个快速生成测试方法的一个方法:
点击 src 下的 method_junit.java—> 右击 new—> 看看后面的提示框中有么有 Junit test case,如果没有的话点击 other,在提示框中输入 Junit 就会出现 —> 在弹出的对话框中找到 Source folder, 点击后面的 Browse 将其改为含有 test 的那个目录,这里有些可能会提示名字重复,把下面的 Name 改改就行 —> 点击 next—> 你会看到 method_junit 里面的所有法,这时候你就可以选中它们,成成测试方法如下:


package com.junit;
import static org.junit.Assert.*;
import org.junit.Test;
public class method_juntiTest2 {

    @Test
    public void testAdd() {fail("Not yet implemented");
    }

    @Test
    public void testSubtract() {fail("Not yet implemented");
    }

    @Test
    public void testMultiply() {fail("Not yet implemented");
    }

    @Test
    public void testDivision() {fail("Not yet implemented");
    }
}

再把里面 fail 后面的语句删了就可以写你想测试的东西呢!

4、junit 测试失败的两种情况:

在前面的情况中我们都是测试的是成功的例子,但是 Junit 的作用只是测试的方法里的返回数据是不是正确的,但是在数据返回正确的情况下我们未必是正确的,就比如如果你要求的是长方形的面积,但是你用的是周长公式,当你在测试的时候他也会给你测试成功,得到预期的结果,也就是说我们的测试用例对于逻辑错误是无能为力的

测试失败的情况一
当我们预期值和程序执行的结果不一样的时候就会测试失败:
比如我们上面的测试加法函数的方法:


@Test
public void testAdd(){assertEquals(3, new method_junti().add(3, 0));
}

如果把预期结果 3,改为 4,就会测试失败,failure 的后面就会出现一个 1,提示一个测试失败,运行时就能看到,这个应该不难理解。如果你仔细观察的话,下面还会有相关的提示,如图所示:

image.png

测试失败情况二:
下面我们在来测试除法:


@Test
public void testDivision(){assertEquals(6, new method_junti().division(6, 1));
}

如果在这里把除数改为 0,会出现什么情况呢:后面的提示框中的 error 数就会变 1;提示有一个错误。于是我们得出下面的两种情况:

1、failure 一般由单元测试使用的断言方法判断失败所引起的,这表示测试点发现了问题,也就是说程序输出的结果和预期的不一样
2、error 是由代码异常引起的,他可能是由于测试代码本身的错误,也可能是被测试代码中隐藏的一个 bug

5、Junit 的运行流程:

首先我们先在 test 包下的 com.junit 新建一个 junit case,和并且直接命名 junit_case。在创建的时候把 setUpBeforeClass(),tearDownAfterClass(),setUp(),tearDown() 选上就会得到下面的代码:


package com.junit;

import org.junit.After;
import org.junit.AfterClass;
import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class Junit_case {
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {}

    @AfterClass
    public static void tearDownAfterClass() throws Exception {}

    @Before
    public void setUp() throws Exception {}

    @After
    public void tearDown() throws Exception {}

    @Test
    public void test() {fail("Not yet implemented");
    }
}

下面我们在每个方法中输入一句简单的输出语句,看看他们的运行状态,如下:


package com.junit;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class Junit_test1 {

    /* 1、BeforeClass 修饰的方法会在所有方法被调用前执行
     * 而且该方法是静态的,所以当测试类被加载后接着就执行它
     * 在内存中它只会存在一份,适合加载配置文件
     * 2、AfterClass 修饰的方法用来对资源的清理,如关闭数据库的连接
     * befoer 和 after 修饰的方法在每个 test 修饰的方法执行前会被各执行一次,假如有两个
     * test 文件,before 和 after 会被各执行两次;* */
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {System.out.println("this is beforeclass");
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {System.out.println("this is afterclass");
    }

    @Before
    public void setUp() throws Exception {System.out.println("this is before");
    }

    @After
    public void tearDown() throws Exception {System.out.println("this is after");
    }

    @Test
    public void test1() {System.out.println("this is test1");
    }

}

如果运行上面的代码,就会得到下面的结果

6、junit 的常用注解:

上面我已经讲解了 @test,@BeforeClass,@AfterClass,@Before,@After 这些注解的详解可见这位仁兄的博客,下面提供相关地址:http://blog.csdn.net/zixiao217/article/details/52951679
对于 @test,他除了将一个普通的方法修饰为测试方法外,还可以处理异常,设置超时。下面来对 test 的异常处理做讲解 test 有两个参数:expected 和 timeout,即异常处理和设置超时如果对我们上面的除数为 0 的那个方法进行异常处理,那么我们就可以看到代码能够正常,测试通过, 代码如下:


@Test(expected=ArithmeticException.class)
public void testDivision(){assertEquals(6, new method_junti().division(6, 0));
}

在测试一些对性能有要求的方法中设置超时是很有必要的,它可以检测你的代码能否在这个
时间段内运行出结果,设置方法如下:


@Test(timeout=2000)// 单位是毫秒
 public void testWhile(){while(true){System.out.println("run forever");
    }
}

@Ignore: 在 test 方法上加上该修饰,测试的时候就会不执行该测试方法;
@RunWith 可以更改测试运行器;我们除了使用 junit 提供的测试运行器之外,还可以自定义
我们的运行器,只要继承 org.junit.runner.Runner
代码如下:


import static org.junit.Assert.*;

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

@RunWith(Suite.class)
@Suite.SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class})
public class SuitTest {public void test(){
        /*
         * 由于在开发的项目中,测试的类很多,一个一个运行很浪费时间,于是可以写一个测试
         * 套件把所有需要测试的类组合在一起测试运行
         * 1、写一个测试入口,这个类不含其它的方法;* 2、更改测试运行器 @RunWith(Suite.class)
         * 3、将要测试的类作为数组放在 @Suite.SuiteClasses({})中;*/

    }
}

7、junit 的参数设置

在上面的测试中,我们对一个方法都是只测试了一组数据,可是在真正的项目中,一组数据往往是不够的,我们需要很多组数据,如果每一组数组写一个测试方法的话那可把我们的工作人员累死了!这时我们可以使用参数设置来解决这个问题。
代码如下:


package com.junit;
import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class ParameterTest {
    // 声明变量存放预期值和测试数据;int expected=0;
    int input1=0;
    int input2=0;

    @Parameters
    public static Collection<Object[]> test(){return Arrays.asList(new Object[][]{{3,1,2},
                {4,2,2}
            });     
    }

    public ParameterTest(int expected,int input1,int input2){
        this.expected=expected;
        this.input1=input1;
        this.input2=input2;
    }
    @Test
    public void testAdd(){assertEquals(expected, new method_junti().add(input1, input2));
    }   
}

我们需要测试多组数据,那么我们就需要用到数组来存放多组数据, 这里用 Arrays.asList 来接收。

聊聊单元测试在 SpringMVC 中的运用

转自 杜琪 

遇到问题多思考、多查阅、多验证,方能有所得,再勤快点乐于分享,才能写出好文章。

一、单元测试

1. 定义与特点

单元测试(unit testing):是指对软件中的最小可测试单元进行检查和验证。

这个定义有点抽象,这里举几个单元测试的特性,大家感受一下:一般是一个函数配几个单元测试、单元测试不应该依赖外部系统、单元测试运行速度很快、单元测试不应该造成测试环境的脏数据、单元测试可以重复运行。

2. 优点

单元测试使得我们可以放心修改、重构业务代码,而不用担心修改某处代码后带来的副作用。

单元测试可以帮助我们反思模块划分的合理性,如果一个单元测试写得逻辑非常复杂、或者说一个函数复杂到无法写单测,那就说明模块的抽象有问题。

单元测试使得系统具备更好的可维护性、具备更好的可读性;对于团队的新人来说,阅读系统代码可以从单元测试入手,一点点开始后熟悉系统的逻辑。

3. 本文要解决的痛点

  1. 单测何时写?
    如果你的团队在坚持 TDD 的风格,那就是在编码之前写;如果没有,也不建议在全部业务代码编写完成之后再开始补单元测试。单元测试比较(最)合适的时机是:一块业务逻辑写完后,跟着写几个单元测试验证下。
  2. 单测怎么写?
    分层单测:数据库操作层、中间件依赖层、业务逻辑层,各自的单元测试各自写,互相不要有依赖。
  3. 单测运行太慢?
  • dao 层测试,使用 H2 进行测试,做独立的 BaseH2Test、独立的 test-h2-applicationContext.xml,只对 dao 的测试
  • service 层测试,依赖 mockito 框架,使用 @RunWith(MockitoJUnitRunner.class)注解,就无需加载其他 spring bean,具体用法
  • 对于依赖外部的中间件(例如 redis、diamond、mq),在处理单测的时候要注意分开加载和测试,尤其是与 dao 的测试分开

二、Spring 项目中的单元测试实践

我们基于 unit-test-demo 这个项目进行单元测试的实践。

1. dao 层单元测试

最开始写单测的时候,要连着 DEV 的数据库,这时候会有两个烦恼:网络有问题的时候单测运行不通过、数据库里造成脏数据的时候会导致应用程序异常。这里我们选择 H2 进行 DAO 层的单元测试。有如下几个步骤:

  • 在 resources 下新建目录 h2,存放 schema.sql 和 data-prepare-user.sql 文件,前者用于保存建表语句,后者用于准备初始数据
  • test-data-source.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/jdbc
       http://www.springframework.org/schema/jdbc/spring-jdbc.xsd">

    <!-- 初始化数据表结构 -->
    <jdbc:initialize-database data-source="dataSource">
        <jdbc:script location="classpath:h2/schema.sql" encoding="UTF-8"/>
        <jdbc:script location="classpath:h2/data-prepare-*.sql" encoding="UTF-8"/>
    </jdbc:initialize-database>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${user.jdbc.url}"/>
        <property name="username" value="${user.jdbc.username}"/>
        <property name="password" value="${user.jdbc.password}"/>
        <!-- 连接池初始连接数 -->
        <property name="initialSize" value="3"/>
        <!-- 允许的最大同时使用中(在被业务线程持有,还没有归还给 druid) 的连接数 -->
        <property name="maxActive" value="30"/>
        <!-- 允许的最小空闲连接数,空闲连接超时踢除过程会最少保留的连接数 -->
        <property name="minIdle" value="3"/>
        <!-- 从连接池获取连接的最大等待时间 5 秒 -->
        <property name="maxWait" value="5000"/>

        <!-- 强行关闭从连接池获取而长时间未归还给 druid 的连接(认为异常连接)-->
        <property name="removeAbandoned" value="true"/>
        <!-- 异常连接判断条件,超过 180 秒 则认为是异常的,需要强行关闭 -->
        <property name="removeAbandonedTimeout" value="180"/>

        <!-- 从连接池获取到连接后,如果超过被空闲剔除周期,是否做一次连接有效性检查 -->
        <property name="testWhileIdle" value="true"/>
        <!-- 从连接池获取连接后,是否马上执行一次检查 -->
        <property name="testOnBorrow" value="false"/>
        <!-- 归还连接到连接池时是否马上做一次检查 -->
        <property name="testOnReturn" value="false"/>
        <!-- 连接有效性检查的 SQL -->
        <property name="validationQuery" value="SELECT 1"/>
        <!-- 连接有效性检查的超时时间 1 秒 -->
        <property name="validationQueryTimeout" value="1"/>

        <!-- 周期性剔除长时间呆在池子里未被使用的空闲连接, 10 秒一次 -->
        <property name="timeBetweenEvictionRunsMillis" value="10000"/>
        <!-- 空闲多久可以认为是空闲太长而需要剔除 30 秒 -->
        <property name="minEvictableIdleTimeMillis" value="30000"/>

        <!-- 是否缓存 prepareStatement, 也就是 PSCache,MySQL 建议关闭 -->
        <property name="poolPreparedStatements" value="false"/>
        <property name="maxOpenPreparedStatements" value="-1"/>

        <!-- 是否设置自动提交,相当于每个语句一个事务 -->
        <property name="defaultAutoCommit" value="true"/>
        <!-- 记录被判定为异常的连接 -->
        <property name="logAbandoned" value="true"/>
        <!-- 网络读取超时,网络连接超时 -->
        <property name="connectionProperties" value="connectTimeout=1000;socketTimeout=3000"/>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:mybatis/mapper/*Mapper.xml"/>
        <property name="typeAliasesPackage" value="org.learnjava.dq.core.dal.bean"/>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="org.learnjava.dq.core.dal.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
</beans>
  • test-h2-applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 激活自动代理功能 -->
    
    <!-- spring 容器启动时,静态配置替换 -->
    <context:property-placeholder location="classpath*:*.properties" ignore-unresolvable="true"/>

    <context:component-scan base-package="org.learnjava.dq.core.dal.dao"/>

    <import resource="test-data-sources.xml"/>
</beans>
  • UserInfoDAOTest
    这个文件是 DAO 层单元测试的主要内容,我只写了一个,读者朋友可以下载代码自己练习,把剩余的几个写了。

PS:这里我们只有一个 DAO,所以 spring 容器加载就放在这个文件里了,如果 DAO 多的话,建议抽出一个 BaseH2Test 文件,这样所有的 DAO 单元测试只需要加载一次 spring 容器。


package org.learnjava.dq.core.dal.dao;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.learnjava.dq.core.dal.bean.UserInfoBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Date;
import javax.annotation.Resource;
import static org.junit.Assert.*;

/**
 * 作用:
 * User: duqi
 * Date: 2017/6/24
 * Time: 09:33
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:test-h2-applicationContext.xml")
public class UserInfoDAOTest {

    @Resource
    private UserInfoDAO userInfoDAO;

    @Test
    public void saveUserInfoBean() throws Exception {UserInfoBean userInfoBean = new UserInfoBean();
        userInfoBean.setUserId(1003L);
        userInfoBean.setNickname("wangwu");
        userInfoBean.setMobile("18890987675");
        userInfoBean.setSex(1);
        userInfoBean.setUpdateTime(new Date());
        userInfoBean.setCreateTime(new Date());

        int rows = userInfoDAO.saveUserInfoBean(userInfoBean);

        assertEquals(1, rows);
    }

    @Test
    public void updateUserInfoBean() throws Exception {}

    @Test
    public void getUserInfoBeanByUserId() throws Exception {}

    @Test
    public void getUserInfoBeanByMobile() throws Exception {}

    @Test
    public void listUserInfoBeanByUserIds() throws Exception {}

    @Test
    public void removeUserInfoBeanByUserId() throws Exception {}

}

2. service 层单元测试

  • Mockito
    Mocktio 是一个非常易用的 mock 框架。开发者可以依靠 Mockito 提供的简洁的 API 写出漂亮的单元测试。

Mockito is a mocking framework that tastes really good. It lets you write beautiful tests with a clean & simple API. Mockito doesn’t give you hangover because the tests are very readable and they produce clean verification errors.

  • UserInfoManagerImplTest
    单元测试,不应该依赖于 DAO 层的执行逻辑是否正确【否则就是集成测试】,需要假设 DAO 的行为是什么样子,然后再看本层的逻辑是否正确。
    这里使用 @RunWith(MockitoJUnitRunner.class)修饰当前的单元测试类,如果有多个单元测试类的话,可以考虑抽出一个基础的 BaseBizTest 类。

package org.learnjava.dq.biz.manager.impl;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.learnjava.dq.biz.domain.UserInfo;
import org.learnjava.dq.biz.manager.UserInfoManager;
import org.learnjava.dq.core.dal.bean.UserInfoBean;
import org.learnjava.dq.core.dal.dao.UserInfoDAO;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;

import static org.junit.Assert.*;

import static org.mockito.Mockito.*;

/**
 * 作用:
 * User: duqi
 * Date: 2017/6/24
 * Time: 09:55
 */
@RunWith(MockitoJUnitRunner.class)
public class UserInfoManagerImplTest {

    @Mock // 用于定义被 Mock 的组件
    private UserInfoDAO userInfoDAO;

    @InjectMocks // 用于定义待测试的组件
    private UserInfoManager userInfoManager = new UserInfoManagerImpl();

    private UserInfo userInfoToSave;

    @Before
    public void setUp() throws Exception {
        // 用于初始化 @Mock 注解修饰的组件
        MockitoAnnotations.initMocks(this);

        userInfoToSave = new UserInfo();
        userInfoToSave.setMobile("18978760099");
        userInfoToSave.setUserId(7777L);
        userInfoToSave.setSex(1);
    }

    @Test
    public void saveUserInfo_case1() throws Exception {
        //step1 准备数据和动作
        doReturn(1).when(userInfoDAO).saveUserInfoBean(any(UserInfoBean.class));

        //step2 运行待测试模块
        Boolean res = userInfoManager.saveUserInfo(userInfoToSave);

        //step3 验证测试结果
        assertTrue(res);
    }

    @Test
    public void saveUserInfo_case2() throws Exception {
        //step1 准备数据和动作
        doReturn(0).when(userInfoDAO).saveUserInfoBean(any(UserInfoBean.class));

        //step2 运行待测试模块
        Boolean res = userInfoManager.saveUserInfo(userInfoToSave);

        //step3 验证测试结果
        assertFalse(res);
    }

    @Test
    public void updateUserInfo() throws Exception {}

    @Test
    public void getUserInfoByUserId() throws Exception {}

    @Test
    public void getUserInfoByMobile() throws Exception {}

    @Test
    public void listUserInfoByUserIds() throws Exception {}

    @Test
    public void removeUserInfoByUserId() throws Exception {}

}
  • Mockito 要点

    • MockitoJUnitRunner:用于提供单元测试运行的容器环境
    • Mock:用于模拟待测试模块中依赖的外部组件
    • InjectMock:用于标识待测试组件
    • org.mockito.Mockito.*:这个类里的方法可以用于指定 Mock 组件的预期行为,包括异常处理。

三、总结

  1. 单元测试的三个步骤
  • 准备数据、行为
  • 测试目标模块
  • 验证测试结果
  1. 除了本文中提到的 Junit、Mockito、H2,还有很多其他的单元测试框架,例如 TestNG、spock 等。
  2. 在 Java Web 项目中,controller 层一般不写业务逻辑,也就没有必要写单元测试,但是如果要写,也有办法,可以参考我之前的文章:在 Spring Boot 项目中使用 Spock 框架。
  3. 单元测试代码也是线上代码,要和业务代码一样认真对待,也需要注意代码和测试数据的复用。

一位阿里 Java 工程师的技术小站。作者黄小斜,专注 Java 相关技术:SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程,偶尔讲点 Docker、ELK,同时也分享技术干货和学习经验,致力于 Java 全栈开发!(关注公众号后回复”Java“即可领取 Java 基础、进阶、项目和架构师等免费学习资料,更有数据库、分布式、微服务等热门技术学习视频,内容丰富,兼顾原理和实践,另外也将赠送作者原创的 Java 学习指南、Java 程序员面试指南等干货资源)

退出移动版