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

一、什么是单元测试？（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. 转发至 朋友圈 ，是对我最大的支持。
点个   在看  喜欢是一种感觉 在看是一种支持 ↘↘↘