Junit+Mock

base project

<parent>
    <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.6.11</version>
     <relativePath/>
 </parent>
 
<dependencies>
   <!--添加mysql依赖-->
    <dependency>
        <groupId>org.mariadb.jdbc</groupId>
        <artifactId>mariadb-java-client</artifactId>
        <version>2.7.2</version>
    </dependency>

    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.2</version>
    </dependency>

    <!--单元测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <!--junit4-->
    <dependency>
        <groupId>org.junit.vintage</groupId>
        <artifactId>junit-vintage-engine</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

application.yaml

server:
  port: 8896

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mariadb://local_IP_replace:3306/junit?serverTimezone=GMT%2B8&useSSL=false&allowPublicKeyRetrieval=true
    driver-class-name: org.mariadb.jdbc.Driver

controller

@RestController
@RequestMapping("/ele")
public class EleController {

    private final IEleService eleService;


    @Autowired
    public EleController(IEleService eleService) {
        this.eleService = eleService;
    }

    @GetMapping(value = "/selectEleById")
    public Result<Object> selectEleById(@RequestParam(value = "orderId") int orderId) {
        Object object = eleService.selectEleById(orderId);
        return Result.success(object);
    }

    @GetMapping(value = "/selectEleByIdAndName")
    public Result<Object> selectEleByIdAndName(
            @RequestParam(value = "id") int id, @RequestParam(value = "name") String name) {
        Object object = eleService.selectEleByIdAndName(id,name);
        return Result.success(object);
    }
}

service

public interface IEleService {
    Object selectEleById(int orderId);
    Object selectEleByIdAndName(int id, String name);
}

@Service
public class EleService implements IEleService {
    @Autowired
    private IElementsMapper elementsMapper;
    @Override
    public Object selectEleById(int orderId) {
        ElementsDO elementsDO = elementsMapper.selectById(orderId);
        return elementsDO;
    }

    @Override
    public Object selectEleByIdAndName(int id, String name) {
        LambdaQueryWrapper<ElementsDO> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ElementsDO::getId, id);
        queryWrapper.eq(ElementsDO::getElementName, name);
        ElementsDO elementsDO = elementsMapper.selectOne(queryWrapper);
        return elementsDO;
    }
}

mapper

@Mapper
public interface IElementsMapper extends BaseMapper<ElementsDO> {
}

entity

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@TableName("ELEMENTS")
public class ElementsDO implements Serializable {
    /**
     * id
     */
    @TableId(value = "ID", type = IdType.AUTO)
    private Integer id;
    /**
     * 要素代码
     */
    @TableField(value = "ELEMENT_CODE")
    private String elementCode;
    /**
     * 要素名称
     */
    @TableField(value = "ELEMENT_NAME")
    private String elementName;
    /**
     * 单位
     */
    @TableField(value = "UNIT")
    private String unit;
}

controller返回封装对象

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Result<T> {
    private int code;
    private String msg="success";
    private T data;

    /**
     *  成功时候的调用
     * */

    public static <T> Result<T> success() {
        Result<T> result = new Result<T>();
        result.code = 1;
        return result;
    }

    public static<T> Result<T> success(T data){
        return new Result<T>(data);
    }

    /**
     *  失败时候的调用
     * */
    public static  <T> Result<T> error(CodeMsg codeMsg){
        return new Result<T>(codeMsg);
    }

    private Result(T data) {
        this.data = data;
    }

    private Result(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    private Result() {
    }

    private Result(CodeMsg codeMsg) {
        if(codeMsg != null) {
            this.code = codeMsg.getCode();
            this.msg = codeMsg.getMsg();
        }
    }


    /**
     * BindingResult统一处理
     */
    public static Result resolveBindResult(BindingResult bindingResult){
        StringBuilder stringBuilder = new StringBuilder();
        for (String s : bindingResult.getFieldErrors().stream().map(FieldError::getDefaultMessage).collect(Collectors.toList())) {
            stringBuilder.append(",").append(s);
        }
        return Result.error(new CodeMsg(502,stringBuilder.toString().substring(1)));
    }

    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Result [code=" + code + ", msg=" + msg + ", data=" + data + "]";
    }

}

Mock初始化

方式1

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
public class Init1 {
    //初始化模拟对象
    @Mock
    private EleService eleService;
    //初始化真实对象
    @Spy
    private EleService eleService2;

    @Test
    public void test1(){
        boolean mock = Mockito.mockingDetails(eleService).isMock();
        System.out.println(mock);

        boolean mock1 = Mockito.mockingDetails(eleService2).isSpy();
        System.out.println(mock1);
    }
}

方式2

import org.junit.jupiter.api.BeforeEach;
@ExtendWith(MockitoExtension.class)
public class Init2 {
    private EleService eleService;
    //初始化
    @BeforeEach
    public void init() {
        eleService = Mockito.mock(EleService.class);
    }

    @Test
    public void test1(){
        //判断对象是否为muck对象
        boolean mock = Mockito.mockingDetails(eleService).isMock();
        System.out.println(mock);
    }
}

方式3

import org.junit.jupiter.api.BeforeEach;
@ExtendWith(MockitoExtension.class)
public class Init3 {
    //初始化模拟对象
    @Mock
    private EleService eleService;
    //初始化真实对象
    @Spy
    private EleService eleService2;

    //初始化
    @BeforeEach
    public void init() {
        //初始化当前类对象下的相关mock
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void test1(){
        boolean mock = Mockito.mockingDetails(eleService).isMock();
        System.out.println(mock);

        boolean mock1 = Mockito.mockingDetails(eleService2).isSpy();
        System.out.println(mock1);
    }
}

Mock默认返回值

int默认返回0，对象默认返回null，集合默认返回空集合（空的ArrayList、空的HashSet、空的HashMap）

@ExtendWith(MockitoExtension.class)
public class MockMethod1 {
    //初始化模拟对象
    @Mock
    private EleService eleService;

    @Test
    public void test1(){
        //Mock对象返回默认值,不会调用真正方法
        Object o1 = eleService.selectEleById(1);//null
        System.out.println(o1);
    }
}

Mock参数设置

@ExtendWith(MockitoExtension.class)
public class MockMethod1 {
    //初始化模拟对象
    @Mock
    private EleService eleService;

    @Test
    public void test1(){
        /**
         * 插桩,只拦截参数为1
         */
        //指定参数为1时,selectEleById方法时返回new Object()
        Mockito.doReturn(new Object()).when(eleService).selectEleById(1);
        Object o2 = eleService.selectEleById(1);
        System.out.println(o2);//java.lang.Object@16b2bb0c
    }

    @Test
    public void test2(){
        /**
         * 插桩,拦截selectEleById()的任意参数值
         */
        Mockito.doReturn(new Object()).when(eleService).selectEleById(ArgumentMatchers.any(Integer.class));
        Object o2 = eleService.selectEleById(2);
        System.out.println(o2);//java.lang.Object@c7045b9
    }
}