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

28次阅读

共计 16589 个字符，预计需要花费 42 分钟才能阅读完成。

微信公众号【黄小斜】大厂程序员，互联网行业新知，终身学习践行者。关注后回复「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 程序员面试指南等干货资源）

正文完
发表至： java
2019-08-16
 0
关于java:正则表达式的总结
关于java:透传接口的意义
Spring-BootCAS-默认登录页面太丑了怎么办
10-人2-个月-虾mi音乐的监控体系升级之路