阿里是如何进行单元测试培训的?

一、什么是单元测试？（10 min）

维基百科中是这样描述的：在计算机编程中，单元测试又称为模块测试，是针对程序模块来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。在过程化编程中，一个单元就是单个程序、函数、过程等；对于面向对象编程，最小单元就是方法，包括基类、抽象类、或者派生类中的方法。

单元测试和集成测试的区别

回到测试的本质来看，测试工作就是模拟真实环境，在代码正式上线前进行验证的工作，即使没有任何工具和方法，这项工作也能够通过人工操作来手动完成。但这种方式显然不符合软件从业者的习惯，于是开始出现了各种各样的自动化测试方法，框架和工具。单元测试和集成测试使用的测试框架和工具大部分是相同的，而社区中对集成测试的介绍不尽相同，导致很多看过不同文章的同学对这两种测试的认知存在争议。首先需要达成一致的是，无论是单元测试还是集成测试，它们都是自动化测试。为了更好地区分，我们可以这样理解：和生产代码以及单元测试代码在同一个代码仓库中，由开发同学自己编写的，对外部环境（数据库、文件系统、外部系统、消息队列等）有真实调用的测试就是集成测试。下表中也从各种角度来对比了单元测试、集成测试和系统级别测试（包括端到端测试、链路测试、自动化回归测试、UI测试等）的区别。

	单元测试	集成测试	系统级别测试
编写人员	开发	开发	开发 / 测试
编写场地	生产代码仓库内	生产代码仓库内	生产代码仓库内 / 生产代码仓库外
编写时间	代码发布前	代码发布前	代码发布前 / 代码发布后
编写成本	低	中	高
编写难度	低	中	高
反馈速度	极快，秒级	较慢，分钟级	慢，天级别
覆盖面积	代码行覆盖60-80% 分支覆盖40-60%	功能级别覆盖HappyPath	核心保障链路
环境依赖	代码级别，不依赖环境	依赖日常或本地环境	依赖预发或生产环境
外部依赖模拟	全部模拟	部分模拟	不模拟，完全使用真实环境

小互动（10 min）

上手题 - 用于查看目前大家的单测理解和技能水平

以下是一个简单的服务代码，请认真观看后写下你认为应该写的单元测试。

        

          @Service

        

        

          public class UserService {

        

        

              /** 定义依赖对象 */

        

        

              /** 用户DAO */

        

        

              @Autowired

        

        

              private UserDAO userDAO;

        

        

          

            


        

        

              /**

        

        

          

                 * 查询用户

          

        

        

          

                 * 

          

        

        

          

                 * @param companyId 公司标识

          

        

        

          

                 * @param startIndex 开始序号

          

        

        

          

                 * @param pageSize 分页大小

          

        

        

          

                 * @return 用户分页数据

          

        

        

          

                 */

          

        

        

              public PageDataVO<UserVO> queryUser(Long companyId, Long startIndex, Integer pageSize) {

        

        

                  //入参校验

        

        

                  if(ValidationUtil.validate(companyId)){

        

        

                      throw new InvalidRequestException(companyId, "Invalid company Id");

        

        

                  }

        

        

        

                  // 查询用户数据

        

        

                  // 查询用户数据: 总共数量

        

        

                  Long totalSize = userDAO.countByCompany(companyId);

        

        

                  // 查询接口数据: 数据列表

        

        

                  List<UserVO> dataList = null;

        

        

                  if (NumberHelper.isPositive(totalSize)) {

        

        

                      dataList = userDAO.queryByCompany(companyId, startIndex, pageSize);

        

        

                  }

        

        

          

            


        

        

                  // 返回分页数据

        

        

                  return new PageDataVO<>(totalSize, dataList);

        

        

              }

        

        

          }

        

      

随机问题：

1. 
   

   
   你觉得针对这段代码，应该需要写几个单元测试？
   
   

   
   


2. 
   

   
   你觉得这个单元测试的行覆盖率理论值可以达到多少？我们一般需要达到多少？如果要达到你的目标，投入的工作量是多少？
   

   
   


3. 
   

   
   单测的代码量和原业务代码量的比值应该是多少比较合适？
   

   
   

答案（仅供参考）：

        

          @RunWith(MockitoJUnitRunner.class)

        

        

          public class UserServiceTest {

        

        

              /** 定义静态常量 */

        

        

              /** 资源路径 */

        

        

              private static final String RESOURCE_PATH = "testUserService/";

        

        

          

            


        

        

              /** 模拟依赖对象 */

        

        

              /** 用户DAO */

        

        

              @Mock

        

        

              private UserDAO userDAO;

        

        

          

            


        

        

              /** 定义测试对象 */

        

        

              /** 用户服务 */

        

        

              @InjectMocks

        

        

              private UserService userService;

        

        

          

            


        

        

              /**

        

        

          

                 * 测试: 查询用户-无数据

          

        

        

          

                 */

          

        

        

              @Test

        

        

              public void testQueryUser_Succeed_NoData() {

        

        

                  // 模拟依赖方法

        

        

                  // 模拟依赖方法: userDAO.countByCompany

        

        

                  Long companyId = 123L;

        

        

                  Long startIndex = 90L;

        

        

                  Integer pageSize = 10;

        

        

                  Mockito.doReturn(0L).when(userDAO).countByCompany(companyId);

        

        

          

            


        

        

                  // 调用测试方法

        

        

                  String path = RESOURCE_PATH + "testQueryUserWithoutData/";

        

        

                  PageDataVO<UserVO> pageData = userService.queryUser(companyId, startIndex, pageSize);

        

        

                  String text = ResourceHelper.getResourceAsString(getClass(), path + "pageData.json");

        

        

                  Assert.assertEquals("分页数据不一致", text, JSON.toJSONString(pageData));

        

        

          

            


        

        

                  // 验证依赖方法

        

        

                  // 验证依赖方法: userDAO.countByCompany

        

        

                  Mockito.verify(userDAO).countByCompany(companyId);

        

        

          

            


        

        

                  // 验证依赖对象

        

        

                  Mockito.verifyNoMoreInteractions(userDAO);

        

        

              }

        

        

          

            


        

        

              /**

        

        

          

                 * 测试: 查询用户-有数据

          

        

        

          

                 */

          

        

        

              @Test

        

        

              public void testQueryUser_Succeed_WithData() {

        

        

                  // 模拟依赖方法

        

        

                  String path = RESOURCE_PATH + "testQueryUserWithData/";

        

        

                  // 模拟依赖方法: userDAO.countByCompany

        

        

                  Long companyId = 123L;

        

        

                  Mockito.doReturn(91L).when(userDAO).countByCompany(companyId);

        

        

                  // 模拟依赖方法: userDAO.queryByCompany

        

        

                  Long startIndex = 90L;

        

        

                  Integer pageSize = 10;

        

        

                  String text = ResourceHelper.getResourceAsString(getClass(), path + "dataList.json");

        

        

                  List<UserVO> dataList = JSON.parseArray(text, UserVO.class);

        

        

                  Mockito.doReturn(dataList).when(userDAO).queryByCompany(companyId, startIndex, pageSize);

        

        

          

            


        

        

                  // 调用测试方法

        

        

                  PageDataVO<UserVO> pageData = userService.queryUser(companyId, startIndex, pageSize);

        

        

                  text = ResourceHelper.getResourceAsString(getClass(), path + "pageData.json");

        

        

                  Assert.assertEquals("分页数据不一致", text, JSON.toJSONString(pageData));

        

        

          

            


        

        

                  // 验证依赖方法

        

        

                  // 验证依赖方法: userDAO.countByCompany

        

        

                  Mockito.verify(userDAO).countByCompany(companyId);

        

        

                  // 验证依赖方法: userDAO.queryByCompany

        

        

                  Mockito.verify(userDAO).queryByCompany(companyId, startIndex, pageSize);

        

        

          

            


        

        

                  // 验证依赖对象

        

        

                  Mockito.verifyNoMoreInteractions(userDAO);

        

        

              }

        

        

        

              @Test

        

        

              public void testQueryUser_Fail_WithBadInput() {}

        

        

          

            


        

        

          }

        

      

抢答题：

1. 
   请问这个是单元测试吗？
   
   

        

          @RunWith(MockitoJUnitRunner.class)

        

        

          public class SpringDalTest{

        

        

              @Resource

        

        

              DBClient dbClient;

        

        

        

              @Test

        

        

              public void testGetDate_success_getFromDB(){

        

        

                String result = dbClient.getDate("Request");

        

        

                Assert.equals(result,"ExpectedResults");

        

        

              }    

        

        

          }

        

      

1. 
   请问这个是单元测试吗？
   
   

        

          @RunWith(MockitoJUnitRunner.class)

        

        

          public class DemoControllerTest {

        

        

              @Mock

        

        

              DemoTairClient tairClient;

        

        

              @Mock

        

        

              DemoDBMapper dbMapper;

        

        

              @InjectMocks

        

        

              DemoController demoController;

        

        

          

            


        

        

              @Test

        

        

              public void testGetResult_succeed_getFromCache() throws Exception {

        

        

                  when(tairClient.getCache(anyString())).thenReturn("getCacheResponse");

        

        

                  when(dbMapper.queryData(anyString())).thenReturn("queryDataResponse");

        

        

          

            


        

        

                  String result = demoController.getResult("request");

        

        

                  Assert.assertEquals("getCacheResponse", result);

        

        

              }

        

        

          }

        

      

1. 
   请问这个是单元测试吗？
   
   

      

        

          @RunWith(PandoraBootRunner.class)

        

      

      

        

          @DelegateTo(SpringJUnit4ClassRunner.class)

        

      

      

        

          @PropertySource(value = {"classpath:test.properties", "classpath:landlord.properties"})

        

      

      

        

          @SpringBootTest(classes = Application.class)

        

      

      

        public class SanityTest{

      

      

              @Resource

      

      

              InfoService infoService1;

      

      

      

              @Mock

      

      

              InfoService infoService2;

      

      

      

              public void testGetInfo_succeed_giveValidRequest(){

      

      

                  String result1 = infoService1.getInfo("Request");

      

      

                  String result2 = infoService2.getInfo("Request");

      

      

                  Assert.equals(result1,result2);

      

      

              }

      

      

      

        }

      

    

二、为什么要写单元测试？（10 min）

反例：

现在，领导要响应集团提高代码质量的号召，需要提升单元测试的代码覆盖率。当然，我们不能让领导失望，那就加班加点地补充单元测试用例，努力提高单元测试的代码覆盖率。至于单元测试用例的有效性，我们大抵是不用关心的，因为我们只是面向指标编程。1230 提升到 LV3，331 提升团队成为卓越工程 LV4， FY23 KPI 完成了，岂不是___，___，____?

正例：

因为我是一名专业的计算机工程师。

理论上单元测试带来的好处有：

1. 
   

   
   单测成本低，速度快。
   

   
   


2. 
   

   
   单测是最佳的、自动化的、可执行的文档。
   

   
   


3. 
   

   
   测试的要诀是：测试你最担心出错的部分，这样你就能从测试工作中得到最大的利益，100%覆盖率的单测会逐渐消磨开发人员对测试的耐心和好感。
   

   
   


4. 
   

   
   单测驱动设计，提升代码简洁度，确保安全重构，代码修改后，单测仍然能通过，能够增强开发者的信心。
   

   
   


5. 
   

   
   快速反馈，更快的发现问题。
   

   
   


6. 
   定位缺陷比集成测试更快更准确，降低修复成本。
   

实际上通过 2 个公司内部的例子来证明：

例子 1

菜鸟 GOC 提供的一个外部 BU 的例子，仅供参考（对照组数据不够严谨，数据还待完善，结论进一步佐证中）

外BU：采销供应链--网络&权限&商家&采购&物流协同（后面简称伍道团队)单测缩短了变更的开发和测试总时长
1、变更开发测试时长领先
从阿里大脑获取到 FY22 5月-10月采购供应链-伍道团队，和供应链BU变更开发测试时长对比趋势的客观数据，如下图所示。对比6个月平均数来看，伍道团队变更开发测试时长平均领先供应链BU 3.1天。

2、交付质量高

：变更折返修改代码再部署次数更低
采购供应链的有变更发布的全应用和BU内非采购供应链全应用，将变更平均从预发环境折返修改代码重部署次数做对比——5-10月份采购供应链“变更平均从预发环境折返修改代码重部署”次数为X次，同BU其他部门平均次数Y次，相比低40%。
从Aone中应用，针对5-10月供应链BU在预发环境有发布成功的变更的核心应用，我们将非采购供应链所有核心应用49个(Aone未观察有UT覆盖率)，和采购供应链主版本应用中，单测行覆盖率超60%的7个核心应用做参照对比。说明进行单测并没有使得变更的开发和测试时长变长，反而因为提升了代码内建质量，缩短了变更的开发和测试总时长。

例子 2

菜鸟&企业智能：企业智能单测减少了变更从预发环境平均折返修改代码重部署次数
菜鸟整体（单测一般）、企业智能（单测好）、A&B团队（单测差），对比7-10月变更从预发环境平均折返修改代码重部署次数。—— 企业智能返工次数明显低于菜鸟整体，低于菜鸟整体35%，低于单测建设薄弱团队整体45%。
7-10月，企业智能5个BU核心应用平均全量行覆盖≥60% 以及 菜鸟其他团队 5个 无单测建设的BU核心应用对比变更从预发环境平均折返修改代码重部署次数。——变更平均从预发环境折返修改代码重部署次数为X，低于5个无单测应用对照组的Y，说明经过充分的单测的变更的内建质量更好，因而在预发环境折返修改代码重部署次数比对照组低52%

三、怎么写单元测试？（50 min）

基础单测套餐：

JUnit4 - 
https://github.com/junit-team/junit4/wiki

Mockito2/3 - 
https://site.mockito.org/

1. 定义对象阶段

定义对象阶段主要包括：定义被测对象、模拟依赖对象（类成员）、注入依赖对象（类成员）。

2. 模拟方法阶段

模拟方法阶段主要包括：模拟依赖对象（参数、返回值和异常）、模拟依赖方法。

3. 调用方法阶段

调用方法阶段主要包括：模拟依赖对象（参数）、调用被测方法、验证参数对象（返回值和异常）。

4. 验证方法阶段

验证方法阶段主要包括：验证依赖方法、验证数据对象（参数）、验证依赖对象 。

大互动


看了这个理论知识，下面我们开始时间实操：

Before

需要 Maven 如何配置，要引入什么？

        

          

            <dependency>

          

        

        

            <groupId>junit</groupId>

        

        

            <artifactId>junit</artifactId>

        

        

            <version>4.13.1</version>

        

        

            <scope>test</scope>

        

        

          

            </dependency>

          

        

        

          

            <dependency>

          

        

        

            <groupId>org.mockito</groupId>

        

        

            <artifactId>mockito-core</artifactId>

        

        

            <version>3.3.3</version>

        

        

            <scope>test</scope>

        

        

          

            </dependency>

          

        

        

          

            <dependency>

          

        

        

            <groupId>org.powermock</groupId>

        

        

            <artifactId>powermock-module-junit4</artifactId>

        

        

            <version>2.0.9</version>

        

        

            <scope>test</scope>

        

        

          

            </dependency>

          

        

        

          

            <dependency>

          

        

        

            <groupId>org.powermock</groupId>

        

        

            <artifactId>powermock-api-mockito2</artifactId>

        

        

            <version>2.0.9</version>

        

        

            <scope>test</scope>

        

        

          

            </dependency>

          

        

      

Test

（现场指导和实操环节，附带提问和一对一指导，内容都在代码里）
请下载：
https://github.com/Lukegogogo/unit-test-training-demo/tree/mainline

现场演示怎么写单元测试，9 种通用场景。

1. 
   【无依赖 难度：🌟🌟】最简单的 Helper/Util/Validation 层 
   


2. 
   【有些许依赖 难度：🌟🌟🌟】稍复杂 Service/Controller 层
   


3. 
   【有很多依赖 难度：🌟🌟🌟🌟】更复杂的 Biz 逻辑层
   


4. 
   【难度：🌟🌟】如何测试 Exception
   


5. 
   【难度：🌟】AssertJ 的使用
   


6. 
   【难度：🌟🌟】Verify 的使用
   


7. 
   【难度：🌟🌟🌟】Argument Captor 的使用
   


8. 
   【难度：🌟】 静态类的 mock
   


9. 
   

   
   【难度：🌟🌟🌟🌟】依赖里面的 Lambda 表达式内的逻辑怎么执行？
   

   
   

四、单测开发规范 （15 min）

单测代码规范要求

1. 
   

   
   【强制】好的单元测试必须遵守AIR原则。说明：单元测试在线上运行时，感觉像空气（AIR）一样感觉不到，但在测试质量的保障上，却是非常关键的。好的单元测试宏观上来说，具有自动化、独立性、可重复执行的特点。
   

   
   

• • 
    A
    ：Automatic（自动化）
    
  
  
  • 
    I
    ：Independent（独立性）
    
  
  
  • 
    R
    ：Repeatable（可重复）
    
  
  

1. 
   

   
   【强制】单元测试应该是全自动执行的，并且非交互式的。测试用例通常是被定期执行的，执行过程必须完全自动化才有意义。输出结果需要人工检查的测试不是一个好的单元测试。单元测试中不准使用System.out来进行人肉验证，必须使用assert来验证。
   

   
   


2. 
   

   
   【强制】保持单元测试的独立性。为了保证单元测试稳定可靠且便于维护，单元测试用例之间决不能互相调用，也不能依赖执行的先后次序。反例：method2需要依赖method1的执行，将执行结果做为method2的参数输入。
   

   
   


3. 
   

   
   【强制】单元测试是可以重复执行的，不能受到外界环境的影响。说明：单元测试通常会被放到持续集成中，每次有代码check in时单元测试都会被执行。如果单测对外部环境(网络、服务、中间件等)有依赖，容易导致持续集成机制的不可用。正例：为了不受外界环境影响，要求设计代码时就把SUT的依赖改成注入，在测试时用spring 这样的DI框架注入一个本地（内存）实现或者Mock实现。
   

   
   


4. 
   

   
   【强制】对于单元测试，要保证测试粒度足够小，有助于精确定位问题。单测粒度至多是类级别，一般是方法级别。说明：只有测试粒度小才能在出错时尽快定位到出错位置。单测不负责检查跨类或者跨系统的交互逻辑，那是集成测试的领域。
   

   
   


5. 
   

   
   【强制】核心业务、核心应用、核心模块的增量代码确保单元测试通过。说明：新增代码及时补充单元测试，如果新增代码影响了原有单元测试，请及时修正。
   

   
   


6. 
   

   
   【强制】单元测试代码必须写在如下工程目录：src/test/java，不允许写在业务代码目录下。说明：源码编译时会跳过此目录，而单元测试框架默认是扫描此目录。
   

   
   


7. 
   

   
   【推荐】单元测试的基本目标：语句覆盖率达到70%；核心模块的语句覆盖率和分支覆盖率都要达到100%。说明：在工程规约>应用分层中提到的DAO层，Manager层，可重用度高的Service，都应该进行单元测试。
   

   
   


8. 
   

   
   【推荐】编写单元测试代码遵守BCDE原则，以保证被测试模块的交付质量。
   

   
   

• • 
    

    
    B
    ：Border，边界值测试，包括循环边界、特殊取值、特殊时间点、数据顺序等。
    

    
    
  
  
  • 
    

    
    C
    ：Correct，正确的输入，并得到预期的结果。
    

    
    
  
  
  • 
    

    
    D
    ：Design，与设计文档相结合，来编写单元测试。
    

    
    
  
  
  • 
    E
    ：Error，强制错误信息输入（如：非法数据、异常流程、非业务允许输入等），并得到预期的结果。
    
  
  

1. 
   

   
   【推荐】对于数据库相关的查询，更新，删除等操作，不能假设数据库里的数据是存在的，或者直接操作数据库把数据插入进去，请使用程序插入或者导入数据的方式来准备数据。反例：删除某一行数据的单元测试，在数据库中，先直接手动增加一行作为删除目标，但是这一行新增数据并不符合业务插入规则，导致测试结果异常。
   

   
   


2. 
   

   
   【推荐】和数据库相关的单元测试，可以设定自动回滚机制，不给数据库造成脏数据。或者对单元测试产生的数据有明确的前后缀标识。正例：在企业智能事业部的内部单元测试中，使用ENTERPRISE_INTELLIGENCE_UNIT_TEST_的前缀来标识单元测试相关代码。
   

   
   


3. 
   

   
   【推荐】对于不可测的代码在适当时机做必要的重构，使代码变得可测，避免为了达到测试要求而书写不规范测试代码。
   

   
   


4. 
   

   
   【推荐】在设计评审阶段，开发人员需要和测试人员一起确定单元测试范围，单元测试最好覆盖所有测试用例（UC）。
   

   
   


5. 
   

   
   【推荐】单元测试作为一种质量保障手段，在项目提测前完成单元测试，不建议项目发布后补充单元测试用例。
   

   
   


6. 
   

   
   【参考】为了更方便地进行单元测试，业务代码应避免以下情况：
   

   
   

• • 
    构造方法中做的事情过多。
    
  
  
  • 
    存在过多的全局变量和静态方法。
    
  
  
  • 
    存在过多的外部依赖。
    
  
  
  • 
    

    
    存在过多的条件语句。说明：多层条件语句建议使用卫语句、策略模式、状态模式等方式重构。
    

    
    
  
  

1. 
   

   
   【参考】不要对单元测试存在如下误解：
   

   
   

• • 
    

    
    那是测试同学干的事情。本文是开发规约，凡是本文出现的内容都是与开发同学强相关的。
    

    
    
  
  
  • 
    

    
    单元测试代码是多余的。软件系统的整体功能是否正常，与各单元部件的测试正常与否是强相关的。
    

    
    
  
  
  • 
    

    
    单元测试代码不需要维护。一年半载后，那么单元测试几乎处于废弃状态。
    

    
    
  
  
  • 
    单元测试与线上故障没有辩证关系。好的单元测试能够最大限度地规避线上故障。
    
    
  
  

研发流程规划

1. 
   

   
   技术方案编写: 无论日需还是项目，无论改动大小 ，一定要进行技术方案编写，按照技术方案模板对照本次改动是否涉及，如有则填写详情设计；如无，则表明不涉及；技术方案是你对需求的理解和分析，是对本次需求转变成技术设计的思考过程，请尽量详细编写技术方案，进行必要的代码设计，做到技术方案可直接coding的程度。在技术方案中，包含单测范围和工时评估。
   

   
   


2. 
   本地写单测UT
   ： 提交增量UT扫描任务，确保增量单测覆盖率80%(不要仅数字，重点关注单测有效性和质量)，测试用例须全部通过。
   
   

1. 
   提交CodeReview
   ：日需和中小项目，在CR前必须完成步骤1&2，检查入口：CR->质量扫描
   
   

1. 
   

   
   研发提测：
   

   
   


2. 
   

   
   pipeline增加单测通过率和增量行覆盖率展示
   

   
   


3. 
   Aone提测
   
   

五、有没有什么神器？（5 min）

有一款好用的插件(TestMe)，能够自动生成单元测试代码，且智能分析当前被测服务所需的依赖，并分析注入mock依赖，可以大大提高单元测试的效率。
装好之后在你要测试的类里面按⌘+N，再选testme，就直接帮你生成好了

六、Q & A（10 min）

现场有同学在问：随着单测覆盖增加，单测性能怎么提升？
目前已有完善的方案分享给大家： 

1.将配置升级至更好性能的机器（包括编译升级一起） 

2.测试分组并发运行。 
两者加起来，预计一般都可以降低到10分钟内。

七、课后作业

1. 
   

   
   分析团队核心应用的核心链路，整理出单元测试作战计划
   

   
   


2. 
   

   
   针对应用的核心链路：
   

   
   

1. 1. 
      

      
      业务逻辑层，写一个类的单元测试，测试 case > 5, 覆盖率达到 80%；
      

      
      
   
   
   2. 
      

      
      中间件层，写一个类的单元测试，覆盖率达到 90%；
      

      
      
   
   
   3. 
      针对自动生成的代码，学会使用 exclude；
      
      
   
   

如果你喜欢本文,

请长按二维码，关注
 

Hollis.



转发至
朋友圈
，是对我最大的支持。



点个


 
在看 



喜欢是一种感觉
在看是一种支持
↘↘↘