SpringMock测试总结

最新推荐文章于 2024-10-12 20:40:55 发布
最新推荐文章于 2024-10-12 20:40:55 发布
阅读量6.9k 收藏 31
点赞数 18
分类专栏： 工作纪实 Spring 文章标签： Spring 单元测试 MVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013553309/article/details/89680632
版权

1.常用注解

@Before：初始化方法，在任何一个测试方法执行之前，必须执行的代码。

@After： 释放资源，在任何一个测试方法执行之后，需要进行的收尾工作。

@Ignore：忽略的测试方法，标注的含义就是“某些方法尚未完成，咱不参与此次测试”；这样的话测试结果就会提示你有几个测试被忽略，而不是失败

@BeforeClass：针对所有测试，也就是整个测试类中，在所有测试方法执行前，都会先执行由它注解的方法，而且只执行一次。当然，需要注意的是，修饰符必须是public static void xxxx ；此 Annotation 是 JUnit 4 新增的功能。

@AfterClass：针对所有测试，也就是整个测试类中，在所有测试方法都执行完之后，才会执行由它注解的方法，而且只执行一次。需要注意的是，修饰符也必须是 public static void xxxx ； JUnit 4 新增的功能，与 @BeforeClass 是一对。

执行顺序：
在这里插入图片描述

2.示例

2.1 Controller层

import org.springframework.web.context.WebApplicationContext;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ArticleControllerTest extends AbstractTransactionalJUnit4SpringContextTests {

    private MockMvc mockMvc;

    @Value("${api.secret-token}")
    private String secretToken;

    @Autowired
    private WebApplicationContext webApplicationContext;

    @Before
    public void setUp() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).alwaysDo(print()).build();
    }
    
    // 1.模拟上传Excel
	@Test
    @Sql("/db/test/test_import_loan_data.sql")
    public void testImportLoanData() throws Exception {
        URL resource = this.getClass().getResource("/file/upload_excel.xls");
        Path path = Paths.get(resource.toURI());
        byte[] data = Files.readAllBytes(path);
        MockMultipartFile file = new MockMultipartFile("excel", "upload_excel.xls",
                MediaType.IMAGE_JPEG_VALUE, data);
        ResultActions perform = mockMvc.perform(
                MockMvcRequestBuilders.fileUpload("/admin/import_loan").file(file)
        );
        perform.andExpect(status().isOk());
        perform.andExpect(jsonPath("status").value("200"));
    }
    
    /**
     *  2. 测试翻页
     * @throws Exception 异常
     */
    @Test
    @Sql(scripts = {"/db/test/admin_init.sql", "/db/test/exchange_rest_controller_test.sql", "/db/180411_dictionary_init.sql"})
    public void testGetExchangeList1() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/admin/exchange/get_exchange_list")   // 构建请求
                .param("page_size", "10")    // 构建传参
                .param("page_num", "1")
                .param("status", "2")
                .accept(MediaType.APPLICATION_JSON_UTF8))   // 设置请求类型
                .andExpect(status().isOk())   // 期望借口调用状态断言
                .andExpect(jsonPath("status").value(200))   // 期望借口返回值断言
                .andExpect(jsonPath("data.total_record").value(261))
                .andExpect(jsonPath("data.data").isNotEmpty())
                .andReturn();
    }
}

2.2 Service层

import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.rule.OutputCapture;
import org.springframework.test.annotation.Commit;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.transaction.AfterTransaction;
import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assert.assertThat;

@RunWith(MockitoJUnitRunner.class)
public class IfcertAccessCoreServiceImplTest {

	 @Mock
    private AccountCheckConfig config;

    @Mock
    private IfcertAccessDataService accessDataService;
    @Mock
    private IfcertAccessClientService accessClientService;
    @Mock
    private QueryTaskService queryTaskService;
    @Mock
    private PushTaskService pushTaskService;
    @Mock
    private IfcertDailyCheckHistoryMapper dailyCheckHistoryMapper;
    @Mock
    private IfcertDailyFailRepushHistoryMapper failRepushHistoryMapper;
    @Mock
    private MailService mailService;

    private IfcertAccessCoreServiceImpl service;
	
	// 此处必须要求service实现类要有构造方法
    @Before
    public void setup() {
        service = new IfcertAccessCoreServiceImpl(config, accessDataService, accessClientService, queryTaskService,
                pushTaskService, dailyCheckHistoryMapper, failRepushHistoryMapper, mailService);
    }

    /**
     * 对账接口1：对账入库流程测试
     */
    @Test
    public void getBatchMessage() {

        String[] params = new String[]{"123", "456"};
        AccountCheckToDbRequest request = new AccountCheckToDbRequest();
        request.setApiKey("apikey");
        request.setEndPoint("endpoint");
        request.setSourceCode("sourcecode");
        request.setVersion("version");
        request.setDataType("0");
        request.setInfType("81");
        request.setBatchNum("323223");
        when(accessDataService.fillCheckRequestData(AccountCheckTypeEnum.DATA_TO_DB.getCode(), params))
                .thenReturn(request);

        BatchMessageResponseWrapper response = new BatchMessageResponseWrapper();
        List<BatchMessageResponse> result = Lists.newArrayList();
        BatchMessageResponse batchResponse = new BatchMessageResponse();
        batchResponse.setBatchNum("23232332");
        batchResponse.setDataType("0");
        batchResponse.setErrorMsg("errormsg");
        result.add(batchResponse);
        response.setResult(result);
        response.setCode("0000");
        response.setMessage("查询成功");
        when(accessClientService.getBatchMessage(request)).thenReturn(response);

        service.getBatchMessage("123", "456");

        verify(accessDataService, times(1))
                .fillCheckRequestData(AccountCheckTypeEnum.DATA_TO_DB.getCode(), params);
        verify(accessClientService, times(1)).getBatchMessage(request);

    }
    
	// 解决方法反复时void的处理
	@Test 
    public void updateReading() throws Exception { 
        doNothing().when(taskModificationService).changeReadingStatus(anyList(),anyByte());
    }

}
/**
 * @author lei.liu 
 * @version 1.0.0
 * @date 2017年12月29日 下午3:45:23
 */
@Service
public class IfcertAccessCoreServiceImpl implements IfcertAccessCoreService {
    private static final Logger LOGGER = LoggerFactory.getLogger(IfcertAccessCoreServiceImpl.class);

    /**
     * 对账接口2接口返回的数据分页显示数
     */
    private static final int PAGE_SIZE = 3000;

    private AccountCheckConfig config;
    private IfcertAccessDataService accessDataService;
    private IfcertAccessClientService ifcertAccessClientService;
    private QueryTaskService queryTaskService;
    private PushTaskService pushTaskService;
    private IfcertDailyCheckHistoryMapper dailyCheckHistoryMapper;
    private IfcertDailyFailRepushHistoryMapper failRepushHistoryMapper;
    private MailService mailService;

    /**
     * 构造注入，避免测试案例mock调用关联bean为null
     *
     * @param config
     * @param accessDataService
     * @param ifcertAccessClientService
     * @param queryTaskService
     * @param pushTaskService
     * @param dailyCheckHistoryMapper
     * @param failRepushHistoryMapper
     * @param mailService
     */
    @Autowired
    public IfcertAccessCoreServiceImpl(AccountCheckConfig config, IfcertAccessDataService accessDataService,
                                       IfcertAccessClientService ifcertAccessClientService, QueryTaskService queryTaskService,
                                       PushTaskService pushTaskService, IfcertDailyCheckHistoryMapper dailyCheckHistoryMapper,
                                       IfcertDailyFailRepushHistoryMapper failRepushHistoryMapper, MailService mailService) {
        this.config = config;
        this.accessDataService = accessDataService;
        this.ifcertAccessClientService = ifcertAccessClientService;
        this.queryTaskService = queryTaskService;
        this.pushTaskService = pushTaskService;
        this.dailyCheckHistoryMapper = dailyCheckHistoryMapper;
        this.failRepushHistoryMapper = failRepushHistoryMapper;
        this.mailService = mailService;
    }
    ...
    ...
}

2.3 Mapper层

import com.htouhui.bonus.coupon.entity.Account;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringRunner;
import java.math.BigDecimal;

@RunWith(SpringRunner.class)
@SpringBootTest
public class AccountMapperTest extends AbstractTransactionalJUnit4SpringContextTests {

    @Autowired
    private AccountMapper accountMapper;

    @Test
    @Sql("/db/test/account_mapper_test.sql") // 调用方法前执行sql脚本
    public void testGetByUserId() {
        Account account = accountMapper.getByUserId("h5602154779");
        Assert.assertNotNull(account);
        Assert.assertEquals(new BigDecimal("888.00"), account.getGrantMoney());
    }

    @Test
    @Sql("/db/test/account_mapper_test.sql")
    public void testUpdate() {
        Account account = Account.builder()
                .id(370941)
                .grantMoney(new BigDecimal("444.00"))
                .build();

        int num = accountMapper.update(account);

        Assert.assertEquals(1, num);

        Account byId = accountMapper.findById(370941L);

        Assert.assertNotNull(byId);
        Assert.assertEquals(new BigDecimal("444.00"), byId.getGrantMoney());
    }

}

3.对特殊框架的测试mock

3.1 针对shiro模拟用户登录进行mock

在某些场景下，对于shiro用户登录后产生的用户信息，需要用到

shiro官方文档提供了一个测试工具类AbstractShiroTest，需要用到

public abstract class AbstractShiroTest {

    private static ThreadState subjectThreadState;

    public AbstractShiroTest() {
    }

    /**
     * Allows subclasses to set the currently executing {@link Subject} instance.
     *
     * @param subject the Subject instance
     */
    protected void setSubject(Subject subject) {
        clearSubject();
        subjectThreadState = createThreadState(subject);
        subjectThreadState.bind();
    }

    protected Subject getSubject() {
        return SecurityUtils.getSubject();
    }

    protected ThreadState createThreadState(Subject subject) {
        return new SubjectThreadState(subject);
    }

    /**
     * Clears Shiro's thread state, ensuring the thread remains clean for future test execution.
     */
    protected void clearSubject() {
        doClearSubject();
    }

    private static void doClearSubject() {
        if (subjectThreadState != null) {
            subjectThreadState.clear();
            subjectThreadState = null;
        }
    }

    protected static void setSecurityManager(SecurityManager securityManager) {
        SecurityUtils.setSecurityManager(securityManager);
    }

    protected static SecurityManager getSecurityManager() {
        return SecurityUtils.getSecurityManager();
    }

    @AfterClass
    public static void tearDownShiro() {
        doClearSubject();
        try {
            SecurityManager securityManager = getSecurityManager();
            LifecycleUtils.destroy(securityManager);
        } catch (UnavailableSecurityManagerException e) {
            //we don't care about this when cleaning up the test environment
            //(for example, maybe the subclass is a unit test and it didn't
            // need a SecurityManager instance because it was using only
            // mock Subject instances)
        }
        setSecurityManager(null);
    }
}

模拟shiro测试

package com.micecs.erp.group.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.google.common.collect.Lists;
import com.micecs.erp.module.admin.Admin;
import com.micecs.erp.module.approval.entity.GroupAudit;
import com.micecs.erp.module.approval.exception.GroupAuditException;
import com.micecs.erp.module.approval.mapper.GroupAuditMapper;
import com.micecs.erp.module.common.CommonException;
import com.micecs.erp.module.enums.*;
import com.micecs.erp.module.meeting.dto.ReserveFundDto;
import com.micecs.erp.module.meeting.entity.AuditRequire;
import com.micecs.erp.module.meeting.entity.GroupBaseInfo;
import com.micecs.erp.module.meeting.entity.ReserveFund;
import com.micecs.erp.module.meeting.exception.DataInitException;
import com.micecs.erp.module.meeting.exception.RfpException;
import com.micecs.erp.module.meeting.mapper.AuditRequireMapper;
import com.micecs.erp.module.meeting.mapper.GroupBaseInfoMapper;
import com.micecs.erp.module.meeting.mapper.ReserveFundMapper;
import com.micecs.erp.module.meeting.service.ReserveManagerService;
import com.micecs.erp.module.meeting.service.impl.ReserveManagerServiceImpl;
import org.apache.shiro.UnavailableSecurityManagerException;
import org.apache.shiro.subject.Subject;
import org.junit.*;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import static com.micecs.erp.admin.ShiroTestUtils.setSubject;
import static org.mockito.Mockito.*;

/**
 * @author liulei, lei.liu@htouhui.com
 * @version 1.0
 */
@RunWith(MockitoJUnitRunner.class)
public class ReserveManagerServiceTest {

    @Mock
    private ReserveFundMapper reserveFundMapper;
    @Mock
    private GroupBaseInfoMapper groupBaseInfoMapper;
    @Mock
    private GroupAuditMapper groupAuditMapper;
    @Mock
    private AuditRequireMapper auditRequireMapper;

    private ReserveManagerService service;

    @Before
    public void init() {
        // 模拟shiro登录
        Subject subjectUnderTest = mock(Subject.class);
        setSubject(subjectUnderTest);
        Admin admin = new Admin();
        admin.setId(1L);
        admin.setAdministrator(true);
        when(subjectUnderTest.getPrincipal()).thenReturn(admin);
        service = new ReserveManagerServiceImpl(reserveFundMapper, groupBaseInfoMapper, groupAuditMapper, auditRequireMapper);
    }
	
    //该测试案例，有用到shiro登录后的一些用户信息取值静态方法
    @Test
    public void testGetReserveFundListByGroupId() {
        Long groupId = 1L;
        List<ReserveFund> list = Lists.newArrayList();
        ReserveFund fund = new ReserveFund();
        fund.setId(1L);
        fund.setGroupId(groupId);
        fund.setMoney(new BigDecimal(1000));
        fund.setFundType(CostDetailEnum.TRAVEL);
        fund.setDataType(DataTypeEnum.BUDGET.getValue());
        fund.setCreateTime(LocalDateTime.now());
        ReserveFund fund2 = new ReserveFund();
        fund2.setId(1L);
        fund2.setGroupId(groupId);
        fund2.setMoney(new BigDecimal(1000));
        fund2.setFundType(CostDetailEnum.TRAVEL);
        fund2.setDataType(DataTypeEnum.BUDGET.getValue());
        fund2.setCreateTime(LocalDateTime.now());
        list.add(fund);
        list.add(fund2);
        when(reserveFundMapper.selectListByGroupId(isA(LambdaQueryWrapper.class))).thenReturn(list);

        try {
            service.getReserveFundListByGroupId(groupId, DataTypeEnum.BUDGET);
        } catch (UnavailableSecurityManagerException e) {
            System.out.println("用户未登录");
        }

        verify(reserveFundMapper, times(1)).selectListByGroupId(isA(LambdaQueryWrapper.class));
    }
}

3.2 针对redisTemplate进行mock

package com.micecs.erp.group.service;

import com.google.common.collect.Lists;
import com.micecs.erp.common.Settings;
import com.micecs.erp.module.approval.entity.AuditArchive;
import com.micecs.erp.module.enums.*;
import com.micecs.erp.module.meeting.entity.GroupBaseInfo;
import com.micecs.erp.module.meeting.entity.InvoiceInfo;
import com.micecs.erp.module.meeting.entity.RequireDetail;
import com.micecs.erp.module.meeting.exception.CustomerBaseException;
import com.micecs.erp.module.meeting.mapper.GroupBaseInfoMapper;
import com.micecs.erp.module.meeting.mapper.InvoiceInfoMapper;
import com.micecs.erp.module.meeting.service.InvoiceInfoService;
import com.micecs.erp.module.meeting.service.impl.InvoiceInfoServiceImpl;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.TimeUnit;

import static org.mockito.Mockito.*;

/**
 * @author liulei, lei.liu@htouhui.com
 * @version 1.0
 */
@RunWith(MockitoJUnitRunner.class)
public class InvoiceInfoServiceTest {

    @Mock
    private InvoiceInfoMapper invoiceInfoMapper;
    @Mock
    private GroupBaseInfoMapper groupBaseInfoMapper;
    @Mock
    private RedisTemplate<String, Object> collectionRedisTemplate;
    @Mock
    private ValueOperations valueOperations;

    private InvoiceInfoService service;

    @Before
    public void init() {
        when(collectionRedisTemplate.opsForValue()).thenReturn(valueOperations);
        service = new InvoiceInfoServiceImpl(invoiceInfoMapper, groupBaseInfoMapper, collectionRedisTemplate);
    }

    @Test
    public void testGetInvoiceOfDefined() {

        when(invoiceInfoMapper.getInvoiceByTypes(anyList())).thenReturn(Lists.newArrayList());

        service.getInvoiceOfDefined(InvoiceInfoEnum.MEETING);

        verify(invoiceInfoMapper, times(1)).getInvoiceByTypes(anyList());
    }

    @Test
    public void testGetInvoiceInfoByType() {
        InvoiceInfoEnum type = InvoiceInfoEnum.TRAVEL;
        List<InvoiceInfo> itemLists = Lists.newArrayList();
        InvoiceInfo item1 = new InvoiceInfo();
        item1.setName("款项1");
        item1.setValue(1);
        InvoiceInfo item2 = new InvoiceInfo();
        item2.setName("款项2");
        item2.setValue(1);
        itemLists.add(item1);
        itemLists.add(item2);
        List<InvoiceInfo> taxLists = Lists.newArrayList();
        InvoiceInfo iv1 = new InvoiceInfo();
        iv1.setName("发票1");
        iv1.setValue(1);
        InvoiceInfo iv2 = new InvoiceInfo();
        iv2.setName("发票2");
        iv2.setValue(2);
        InvoiceInfo iv3 = new InvoiceInfo();
        iv3.setName("发票3");
        iv3.setValue(3);
        InvoiceInfo iv4 = new InvoiceInfo();
        iv4.setName("发票4");
        iv4.setValue(4);
        taxLists.add(iv1);
        taxLists.add(iv2);
        taxLists.add(iv3);
        taxLists.add(iv4);
        TeamNatureEnum teamType = TeamNatureEnum.TRAVEL;
        String redisKey = Settings.ENV + ":INVOICE:DEFINE:" + type.getValue() + "-" + teamType.getValue() + "-";

        when(valueOperations.get(redisKey)).thenReturn(null);
        when(invoiceInfoMapper.getInvoiceByTypes(anyList())).thenReturn(itemLists).thenReturn(taxLists);
        doNothing().when(valueOperations).set(isA(String.class), anyList(), anyLong(), isA(TimeUnit.class));

        List<InvoiceInfo> info = service.getInvoiceInfoByType(type, teamType, null);

        verify(valueOperations, times(1)).get(argThat(argument -> {
            Assert.assertEquals(redisKey, argument);
            return true;
        }));

        verify(invoiceInfoMapper, times(2)).getInvoiceByTypes(anyList());
        info.forEach(vo -> {
            // 断言发票税率
            Assert.assertTrue(new BigDecimal("0").compareTo(vo.getChildren().get(0).getTaxRate()) == 0);
            Assert.assertEquals(4, vo.getChildren().size());
        });
    }
}
告诉你如何在spring上使用mock进行测试
weixin_39098944的博客
08-09 2070
前言 在真实的测试当中，并不能所有的逻辑都可以自己控制，因此有了mock测试。今天就结合场景来讲一下怎么做mock测试。 适合对象：初次尝试集成和使用mockito进行单元测试的开发同学 Mock框架的集成 这里选择的是Mockito + PowerMockito。为什么会集成PowerMockito，是因为有个想要mock的方法是static方法。这个需要PowerMockito，假如都只是普通类，就可以不用了。 集成关键点如下 1、版本对应： 这两个mockito的版本是有一个对应关系，假如不
SPRING-Mock方式进行单元测试
ignorewho的博客
05-24 3816
编写测试Controller：package com.wartao.test.mock.controller;import java.util.ArrayList;import java.util.Collections;import java.util.List;import org.springframework.web.bind.annotation.PathVariable;import ...
spring mock
zangzh的博客
04-01 460
spring mock 引入jar <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-all</artifactId> <version>1.10.19</version> <scope>tes...
超详细 springboot 整合 Mock 进行单元测试！本文带你搞清楚！
最新发布
NHB234567的博客
10-12 1347
在写测试单元时它可以Mock（Mock的中文释义是模拟，所以Mockito从名字上可以看出是要模拟一种场景）。它可以模拟任何 Spring 管理的 Bean、模拟方法的返回值、模拟抛出异常等，避免为了测试一个方法，却要自行构建整个bean的依赖链。
利用Spring的mock进行单元测试
lhlaugh的专栏
05-09 4057
   与测试独立的Java对象相比，测试J2EE Web组件是一项更困难的任务，因为Web组件必须运行在Web容器里，并且必须与HTTP请求交互才有意义。mock对象是一个术语，主要流行于eXtreme程序员和JUnit小组中。在单元测试中，mock对象以简单方式模仿某个组件的行为和结果，从而保证单元测试专注于组件本身，而不用担心其他依赖性问题。1.      Spring的mock类
今天使用了spring-mock来进行单元测试
xxxatt的专栏
04-12 1102
今天用了一下spring-mock来测试系统中的dao.感觉真的不错。这个很简单，记下来得原因是怕自己会忘。你的测试用例必须从AbstractDependencyInjectionSpringContextTests继承。他会帮你创建beanfactory以及beans.但是你必须告诉他到那去找配置文件。这个工作就是通过getConfigLocations方法来完成。一般情况下，这个方法都很简单。
详解Spring MVC如何测试Controller(使用springmvc mock测试)
08-28
在Spring MVC中，测试...总结来说，Spring MVC的Mock测试允许开发者高效、准确地测试Controller，而无需依赖完整的Web服务环境。通过模拟请求和响应，我们可以专注于Controller逻辑的验证，提高了测试的效率和可靠性。
Spring Boot 2 实战：mock测试你的web应用
V539413949的博客
04-09 536
1. 概要 软件测试是一个应用软件质量的保证。java开发者开发接口往往忽视接口单元测试。作为java开发如果会Mock单元测试，那么你的bug量将会大大降低。spring提供test测试模块，所以现在来玩下springboot下的Mock单元测试，我们将对controller，service 的单元测试进行实战操作。 2. 依赖引入 ​​ <dependency> <groupId>org.springframework.boot</g.
Mock测试你的Spring MVC接口
m0_68064743的博客
04-16 459
前言 在Java开发中接触的开发者大多数不太注重对接口的测试，结果在联调对接中出现各种问题。也有的使用Postman等工具进行测试，虽然在使用上没有什么问题，如果接口增加了权限测试起来就比较恶心了。所以建议在单元测试中测试接口，保证在交付前先自测接口的健壮性。今天就来分享一下胖哥在开发中是如何对Spring MVC接口进行测试的。 在开始前请务必确认添加了Spring Boot Test相关的组件，在最新的版本中应该包含以下依赖： <dependency> <groupId&..
spring-mock.jar
01-31
而Spring Mock作为Spring框架的一个重要组成部分，为测试提供了强大的模拟（mocking）能力，帮助开发者在不依赖真实环境的情况下进行单元测试。本文将详细探讨Spring Mock的核心概念、使用方法以及它在实际开发中的...
程序员必知必会的Mock技能-结合spring的mock静态方法
战斗小火鸡
12-27 3361
一、痛点问题 1.1、如何mock静态方法 1.2、mock很容易造成代码覆盖率的下降，如何提升代码覆盖率 二、准备工作 2.1、技术选型：powerMock 为何常见的Mockito不能mock静态方法？ 因为Mockito使用继承的方式实现mock的，用CGLIB生成mock对象代替真实的对象进行执行，为了mock实例的方法，你可以在subclass中覆盖它，而static方法是不...
java单元测试 spring mock的使用
09-02
在java web应用中,通过mock技术可以模拟spring容器，从而进行单元测试，详细可以参见本文
spring-mock-2.0.8.jar
01-09
spring-mock-2.0.8.jar
spring单元测试
11-06
总结起来，通过Java配置的Spring Web项目，我们可以利用JUnit、Mockito以及H2数据库轻松地进行单元测试。对于Controller层，我们使用`@WebMvcTest`注解；对于Service层，我们结合`@MockBean`和`@Autowired`创建mock...
spring进行mock测试
逍遥壮士
10-17 1445
什么是mock？ mock指的是通过模拟数据来使程序完成流程的运行，简单说一句就是自己造数据模拟流程。 mock有哪些工具？ JUnit 参考：https://junit.org/junit5/ TestNG 参考：https://testng.org/doc/ AssertJ 参考：https://joel-costigliola.github.io/assertj/ MockObjects.com 参考：http://www.mockobjects.com/ Mockito 参考
Spring-Mock--用于Spring 的单元测试
xcwll314的专栏
11-30 1036
Spring 的 mock 组建主要分3部分： 1. JNDI The org.springframework.mock.jndi package contains animplementation of the JNDI SPI, which is useful for setting up asimple JNDI environment for test suites or stand-
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值