四、单元测试
【强制】好的单元测试必须遵守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）。

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

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

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

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

直接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注解
 @Mock
 private StuTunnel StuTunnel;

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);

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);

构造方法
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);

无参数方法
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());

默认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)

验证私有方法调用
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);

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验证异常对象

@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();
}

@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
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);
}

@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!"));
    }
}

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

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