关于Java单元测试实践的小结

最新推荐文章于 2024-04-03 17:29:40 发布

匿名少侠

最新推荐文章于 2024-04-03 17:29:40 发布

阅读量1.2k

点赞数

分类专栏：个人总结区[--新--] 文章标签：单元测试 java 开发语言

本文链接：https://blog.csdn.net/u012605629/article/details/121645078

版权

个人总结区[--新--] 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

概念简介

TDD的三项法则：
- 在编好失败的单元测试之前，不要编写任何产品代码；
- 只要有一个单元测试失败了，就不要在写测试代码了，无法通过编译也是一种失败情况；
- 产品代码恰好能让当前的失败单元测试成功通过即可，不要多写；
优势
- 确定性，缺陷注入率，勇气，文档，设计，自动化；
测试金字塔
- 编写不同粒度的测试，层次越高，你写的测试应该越少
- 单元测试100% Xunit
- 组件测试 50% API
- 集成测试 20% API 每次只测试一个集成点。测试时应使用测试替身来替代其他的外部服务、数据库等。
- 系统测试 10% GUI
- 人工探索性测试 5%
如何写测试
- 它们应该保证你代码所有的路径都被测试到;
- 同时它们不应该和代码的实现有太紧密的耦合;
- 测试三板斧
  - 准备测试数据；调用被测方法；断言返回的是你期待的结果
  - 就是“given”，“when”，“then”三件套，given 说的是准备数据，when 指的是调用方法，then 则是断言。
阿里代码规约关于单元测试篇章

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

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

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

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

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

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

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

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

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

B：Border，边界值测试，包括循环边界、特殊取值、特殊时间点、数据顺序等。
C：Correct，正确的输入，并得到预期的结果。
D：Design，与设计文档相结合，来编写单元测试。
E：Error，强制错误信息输入（如：非法数据、异常流程、非业务允许输入等），并得到预期的结果。
【推荐】对于数据库相关的查询，更新，删除等操作，不能假设数据库里的数据是存在的，或者直接操作数据库把数据插入进去，请使用程序插入或者导入数据的方式来准备数据。
反例：删除某一行数据的单元测试，在数据库中，先直接手动增加一行作为删除目标，但是这一行新增数据并不符合业务插入规则，导致测试结果异常。

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

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

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

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

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

构造方法中做的事情过多。
存在过多的全局变量和静态方法。
存在过多的外部依赖。
存在过多的条件语句。
说明：多层条件语句建议使用卫语句、策略模式、状态模式等方式重构。
【参考】不要对单元测试存在如下误解：

那是测试同学干的事情。本文是开发规约，凡是本文出现的内容都是与开发同学强相关的。
单元测试代码是多余的。软件系统的整体功能是否正常，与各单元部件的测试正常与否是强相关的。
单元测试代码不需要维护。一年半载后，那么单元测试几乎处于废弃状态。
单元测试与线上故障没有辩证关系。好的单元测试能够最大限度地规避线上故障。

JUnit4:通过注解的方式来识别测试方法
@BeforeClass 全局只会执行一次，而且是第一个运行
@Before 在测试方法运行之前运行
@Test 测试方法
@After 在测试方法运行之后允许
@AfterClass 全局只会执行一次，而且是最后一个运行
@Ignore 忽略此方法
InjectMocks
- @Mock：创建一个Mock。具体的方法不执行，mock掉了
- @InjectMocks：创建一个实例，其余用@Mock（或@Spy）注解创建的mock将被注入到用该实例中。具体的方法执行内部，进入到方法的具体代码中。
Stub和Mock
- 相同点：Stub和Mock对象都是用来模拟外部依赖，使我们能控制。
- 不同点：而stub完全是模拟一个外部依赖，用来提供测试时所需要的测试数据。而mock对象用来判断测试是否能通过，也就是用来验证测试中依赖对象间的交互能否达到预期
mock和spy
- mock()方法对象的所有非void方法都将返回默认值：int，long类型返回0，boolean方法返回false，对象方法返回null等等，而void方法将什么都不做。
- spy()方法对象既能验证方法调用的功能，同时又能调用这个方法的默认实现(mock对象调用默认实现都将返回默认值)

实战

现在工作中常用的是mockito加powermock来单测。Mockito采用了模拟技术，模拟了一些在应用中依赖的复杂对象，从而把测试对象和依赖对象隔离开来。PowerMock通过提供定制的类加载器以及一些字节码篡改技术的应用，PowerMock实现了对静态方法、构造方法、私有方法以及final方法的模拟支持等强大的功能。
编写测试分为三板斧，主要包含流程：
- given：定义对象，包含被测对象、模拟依赖对象、注入依赖对象、模拟依赖对象（入参或者返回值）、模拟依赖方法。
- when：执行方法，包含模拟依赖对象（参数）、调用被测方法。
- then：验证方法，包含验证数据返回值、验证依赖方法、验证依赖对象。

given

定义对象阶段

在编写单元测试时，首先需要定义被测对象;
- 直接new一个
- spy：Mockito提供一个spy功能，用于拦截那些尚未实现或不期望被真实调用的方法，默认所有方法都是真实方法，除非主动去模拟对应方法。
- @InjectMocks

直接new一个
StStuvice StStuvice = new StStuvice();

利用Mockito.spy方法
StStuvice StStuvice = Mockito.spy(StStuvice.class);

@Spy注解
@RunWith(PowerMockRunner.class)
public class CompanyServiceTest {
    @Spy
    private StStuvice StStuvice = new StStuvice();
    ...
}

@InjectMocks注解

模拟依赖对象

定义对象并赋值
反序列化模型对象：
利用@Mock注解
利用Mockito.spy方法或者@Spy注解：Mockito.spy方法跟Mockito.mock方法功能相似，只是Mockito.spy方法默认所有方法都是真实方法，除非主动去模拟对应方法。

 利用@Mock注解
 @Mock
 private StuTunnel StuTunnel;

注入依赖对象

Setter方法直接设置注入
利用ReflectionTestUtils.setField方法注入
PowerMock提供Whitebox.setInternalState方法设置属性字段值。
@InjectMocks注解用来创建一个实例，并将其它对象（@Mock、@Spy或直接定义的对象）注入到该实例中。

JUnit提供ReflectionTestUtils.setField方法设置属性字段值。
ReflectionTestUtils.setField(StStuvice, "maxCount", 100);

PowerMock提供Whitebox.setInternalState方法设置属性字段值。
Whitebox.setInternalState(StStuvice, "maxCount", 100);

@InjectMocks注解需要配合@RunWith注解使用。
    @Mock
    private StuTunnel StuTunnel;
    @InjectMocks
    private StStuvice StStuvice;

模拟依赖方法

mockito两种写法
Mockito.doReturn(Stu).when(StuTunnel).get(code);
Mockito.when(StuTunnel.get(code)).thenReturn(Stu);    
    
Mockito.doReturn(deleteCount).when(StuTunnel).deleteAll();
Mockito.when(StuTunnel.deleteAll()).thenReturn(deleteCount);
一般习惯用第二种

根据返回模拟方法

无返回值方法
Mockito.doNothing().when(StuTunnel).delete(code);

方法单个返回值
Mockito.when(StuTunnel.get(code)).thenReturn(Stu);    
 
多个返回值
Mockito.when(recordReader.read()).thenReturn(record0, record1, record2, null);

模拟方法抛出异常

异常类型
Mockito.when(StuTunnel.get(Mockito.anyLong())).thenThrow(PersistenceException.class);

异常对象
Mockito.doThrow(exception).when(StuTunnel).get(Mockito.anyLong());
Mockito.when(StuTunnel.get(Mockito.anyLong())).thenThrow(exception);

指定多个异常类型：
Mockito.when(StuTunnel.get(Mockito.anyLong())).thenThrow(PersistenceException.class, RuntimeException.class);

调用真实方法

Mockito.doCallRealMethod().when(StStuvice).getStu(code);
Mockito.when(StStuvice.getStu(code)).thenCallRealMethod();

根据参数模拟方法

无参数的方法模拟：
Mockito.when(StuTunnel.deleteAll()).thenReturn(deleteCount);

指定参数的方法模拟：
Mockito.when(StuTunnel.get(code)).thenReturn(Stu);

Mockito提供了anyInt、anyLong、anyString、anyList、anySet、anyMap、any(Class<T> clazz)等方法来表示任意值。
Mockito.when(StuTunnel.get(Mockito.anyLong())).thenReturn(Stu);

必空参数方法
同样，如果要匹配null对象，可以使用isNull方法，或使用eq(null)。

模拟不同参数方法
Mockito.doReturn(Stu1).when(StuTunnel).get(1L);
Mockito.doReturn(Stu2).when(StuTunnel).get(2L);

模拟其他类型，使用PowerMock需要配合使用@PrepareForTest({StStuvice.class})

final方法
PowerMock提供对final方法的模拟，方法跟模拟普通方法一样。需要配合使用@PrepareForTest({StStuvice.class})
// 跟模拟普通方法完全一致
Mockito.doReturn(code).when(codeUtils).next();
Mockito.when(codeUtils.next()).thenReturn(code);

私有方法
PowerMockito.doReturn(true).when(StStuvice.class, "ss", code);
PowerMockito.when(StStuvice.class, "ss", code).thenReturn(true);

模拟构造方法
PowerMockito.whenNew(StuDO.class).withNoArguments().thenReturn(StuDO);
PowerMockito.whenNew(StuDO.class).withArguments(code, StuName).thenReturn(StuDO);

模拟静态方法
// 模拟对应的类
PowerMockito.mockStatic(SeessionUtils.class);
PowerMockito.spy(SeessionUtils.class);

// 模拟对应的方法
PowerMockito.when(SeessionUtils.gett(XX)).thenReturn(yy);
PowerMockito.doReturn(yy).when(SeessionUtils.class, "gett",XX);

when

在准备好参数对象后，就可以调用被测试方法了。有访问权限一般直接正常调用，无访问权限需要使用PowerMock；

构造方法
StuDO Stu = new Stu(1L, "admin");
无访问权限的构造方法，可以使用PowerMock提供的Whitebox.invokeConstructor方法。
Whitebox.invokeConstructor(Stu.class, 1L, "kitty");

方法
Stu Stu = StStuvice.getStu(code);
调用无访问权限的普通方法，可以使用PowerMock提供的Whitebox.invokeMethod方法。
Stu Stu = (Stu)Whitebox.invokeMethod(StStuvice, "isSuper", code);

静态方法
String code = SesionUtilsr.get(x);
String value = (String)Whitebox.invokeMethod(JSON.class, "toJSONString", object);

then

根据参数验证方法调用 verify

无参数方法
Mockito.verify(StuTunnel).deleteAll();

指定参数方法调用
Mockito.verify(StuTunnel).delete(code);
Mockito.verify(StuTunnel).dStuTunnelelete(Mockito.eq(code));

任意参数方法调用
Mockito.verify(StuTunnel).delete(Mockito.anyLong());

可空参数方法
Mockito.verify(StuTunnel).queryCompany(Mockito.anyLong(), Mockito.nullable(Long.class));

必空参数方法调用
Mockito.verify(StuTunnel).queryCompany(Mockito.anyLong(), Mockito.isNull());

验证方法调用次数 verify，times

默认1次
Mockito.verify(StuTunnel).delete(code);

n次
Mockito.verify(StuTunnel, Mockito.times(n)).delete(code);

其他还有很多类似的次数方法
至少1次
Mockito.atLeastOnce()
至少n次
Mockito.atLeast(n)
最多1次
Mockito.atMostOnce()
最多n次
Mockito.atMost(n)

验证方法调用并捕获参数值ArgumentCaptor
- Mockito提供ArgumentCaptor类来捕获参数值，通过调用forClass(Class clazz)方法来构建一个ArgumentCaptor对象，然后在验证方法调用时来捕获参数，最后获取到捕获的参数值并验证。如果一个方法有多个参数都要捕获并验证，那就需要创建多个ArgumentCaptor对象。
PowerMockito ：verifyPrivate

验证私有方法调用
PowerMockito.verifyPrivate(stuService, times(1)).invoke("upp", any(List.class));

verifyNew方法验证构造方法调用。
PowerMockito.verifyNew(MockClass.class).withNoArguments();
PowerMockito.verifyNew(MockClass.class).withArguments(someArgs);

verifyStatic
PowerMockito.verifyStatic(StringUtils.class);
StringUtils.isEmpty(string);

验证数据对象：通过JUnit提供的Assert.asserXXX；

Assert.assertNull
assertNotNull
assertTrue
assertFalse

验证数据对象引用
Assert.assertSame
assertNotSame

验证数据对象值
JUnit提供Assert.assertEquals、Assert.assertNotEquals、Assert.assertArrayEquals方法组，可以用来验证数据对象值是否相等。


简单数组或集合对象
Assert.assertArrayEquals
Assert.assertEquals

验证异常对象内容

通过@Test注解验证异常对象
@Test(expected = ExampleException.class)

通过@Rule注解验证异常对象
@Rule
private ExpectedException exception = ExpectedException.none();

@Test
public void testGetStu() {
    // 模拟依赖方法
    Long code = 123L;
    Mockito.doReturn(null).when(StuTunnel).get(code);
    
    // 调用被测方法
    exception.expect(ExampleException.class);
    exception.expectMessage("异常信息", code));
    StStuvice.getStu(code);
}

通过Assert.assertThrows验证异常对象

案例

mock.when

@Test
public void should_convert_channelShop_to_vo() {
    when(StStuvice.getNameBycode(any())).thenReturn(TestMocker.MODIFIER);

    ChannelShopVO channelShopVO = channelShopConverter.convertToChannelShopVO(this.generateChannelShop());

    assertThat(channelShopVO.getId()).isEqualTo(channelShopId);
    assertThat(channelShopVO.getShopId()).isEqualTo(shopId);
    assertThat(channelShopVO.getName()).isEqualTo("offline_jinqiao_test");
}

异常

 @Test
    public void should_return_invalid_bom_item_name_error_when_validateItems_if_skuName_is_null() throws ParseException {
        ComposeBom composeBom = createComposeBom();
        try {
            composeBomValidator.validate(composeBom, eventName);
        } catch (BadRequestException exception) {
            assertThat(exception.getMessage()).isEqualTo("原料必须填写名称.");
        }
    }


    @Test(expected = Exception.class)
    public void should_return_invalid_bom_item_name_error_when_validateItems_if_skuName_is_null() {
        ComposeBom composeBom = createComposeBom();

        composeBomValidator.validate(composeBom, eventName);
    }



    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Test
    public void should_return_invalid_bom_item_name_error_when_validateItems_if_skuName_is_null() throws ParseException {
        ComposeBom composeBom = createComposeBom();

        thrown.expect(BadRequestException.class);
        thrown.expectMessage(ErrorCode.INVALID_BOM_ITEM_NAME_ERROR.getMessage());
        
        composeBomValidator.validate(composeBom, eventName);
    }



    @Test
    public void should_return_invalid_bom_item_name_error_when_validateItems_if_skuName_is_null() throws ParseException {
        ComposeBom composeBom = createComposeBom();

        composeBomValidator.validate(composeBom, eventName);

        assertThatThrownBy(() -> controller.getBomByCode(skuCode))
            .isInstanceOf(BadRequestException.class)
            .hasMessage(wdkErrCode.BOM_NOT_FOUND.getDescription())
            .hasNoCause();
}

PowerMock

@RunWith(PowerMockRunner.class)
@PrepareForTest(StuUtils.class)
public class ComposeBomConverterUnitTest{

    @Before
    public void setUp() {
        mockStatic(StuUtils.class);
        when(StuUtils.getCurrentcode()).thenReturn(119550L);
        when(StStuvice.getNameBycode(anyLong(), anyString())).thenReturn("119550");
    }
}

SPY

spy
WarehouseProcessorspy=PowerMockito.spy(warehouseProcessor);
doReturn(warehouseDO).when(spy,"getWarehouseDO",warehouseCode);


@Test
public void should_get_correct_decomposeBomItemSuggestions_with_duplicate_decomposeBomItemVO() throws Exception {
    List<DecomposeBomItemVO> decomposeBomItemVOs = createDecomposeBomItemVOList(4);      

    BaseSkuInfoServiceImpl baseSkuInfoServiceImpl = spy(baseSkuInfoService);
    PowerMockito.doReturn(processItemBOList).when(baseSkuInfoServiceImpl, "getBaseProcessItemSkuList4Merchant", anyString(), anyInt());
  
    List<DecomposeBomItemVO> decomposeBomItemVOList = baseSkuInfoServiceImpl.getDecomposeBomItemSuggestions(keyword);

    assertThat(decomposeBomItemVOList.size()).isEqualTo(4);
}

InjectMocks

@Mock
private AlipayRemoteService alipayRemoteService;
@InjectMocks
@Resource
private AlipayCertifyRemoteService alipayCertifyRemoteService;

public class ExampleControllerTest {

    private ExampleController subject;

    @Mock
    private PersonRepository personRepo;

    @Before
    public void setUp() throws Exception {
        initMocks(this);
        subject = new ExampleController(personRepo);
    }

    @Test
    public void shouldReturnFullNameOfAPerson() throws Exception {
        Person peter = new Person("Peter", "Pan");
        given(personRepo.findByLastName("Pan"))
            .willReturn(Optional.of(peter));

        String greeting = subject.hello("Pan");

        assertThat(greeting, is("Hello Peter Pan!"));
    }
}

ReflectionTestUtils

如果不采用构造器注入，如何注入fileds呢？

import org.springframework.test.util.ReflectionTestUtils;
ReflectionTestUtils.setField(merchantLinkableWarehouseVOV2Converter, "merchantQueryAdapter", merchantQueryAdapter);