springboot编写单元测试

最新推荐文章于 2024-06-28 08:00:00 发布

张晶新

最新推荐文章于 2024-06-28 08:00:00 发布

阅读量3.2k

点赞数

分类专栏：架构设计

本文链接：https://blog.csdn.net/qq_23489303/article/details/89244097

版权

架构设计专栏收录该内容

2 篇文章 0 订阅

订阅专栏

pom：需要引入的依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

ideal添加插件：Junit Generator，使用快捷键：打开代码，选择要创建test的类，ctrl+shift+t，自动生成的代码默认在test.java下（路径可改，在Junit Generator下修改）
添加测试配置，1中注解中的application-test.yml，找的resource，新建
配置内容：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/my_sys?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false&allowMultiQueries=true
    username: root
    password: root
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
server:
  port: 8183

根据需要添加，比如redis等

首先在test.java下创建BaseTest，测试基类，目的在于省去每个test写注解，和相同的方法

package com.xxkj.passport;

import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@TestPropertySource(locations = {"classpath:application-test.yml"})
@SpringBootTest
public abstract class BaseTest {
}

可以根据情况添加默认查询方法，比如：权限查询，用户查询等

5、选中要test的类（code中的），ctrl+shift+t，填入基类，勾选需要测试的方法。如：

package com.xxkj.passport.controller;

import com.xxkj.passport.BaseTest;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.WebApplicationContext;

import static org.hamcrest.core.Is.is;
import static org.junit.Assert.*;

public class AuthControllerTest extends BaseTest {
    @Autowired
    private WebApplicationContext context;

    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void register() {
        System.out.println("!!!!");
        Assert.assertThat("aaa", is("aab"));
    }
}

右键运行即可。断言语句 is() 需要alt+enter引入import static org.hamcrest.core.Is.is;，关于断言语句见附录1，关于注解见附录2。

control层测试，使用MockMVC

使用mockmvc测试控制层代码

package com.xxkj.passport.controller;

import com.xxkj.passport.BaseTest;
import com.xxkj.passport.dto.UserDetails;
import com.xxkj.passport.entity.User;
import org.hamcrest.Matchers;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.util.List;

import static org.hamcrest.core.Is.is;
import static org.junit.Assert.*;

public class AuthControllerTest extends BaseTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Autowired
    private WebApplicationContext context;

    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        mvc = MockMvcBuilders.webAppContextSetup(context).build();// 使用WebApplicationContext初始化mockMVC
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void register() throws Exception {
        String json = "{'admin'：'admin'}";
        Assert.assertThat(json, is("{'admin'：'admin'}"));// 可作为数据检查
        //发送post请求
        mvc.perform(MockMvcRequestBuilders.post("register")
                .accept(MediaType.APPLICATION_JSON_UTF8)
                .content(json.getBytes())
                /*.session(new MockHttpSession())*/
        ).andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print());

        //Spring Boot Web 测试 带返回结果
        ParameterizedTypeReference<List<UserDetails>> type = new ParameterizedTypeReference<List<UserDetails>>() {};
        ResponseEntity<List<UserDetails>> result = restTemplate.exchange("/get", HttpMethod.GET, null, type);
        Assert.assertThat(result.getBody().get(0).getUsername(), Matchers.notNullValue());
    }
}

关于Mock详情见http://www.importnew.com/21540.html

参数化测试

//1.更改默认的测试运行器为RunWith(Parameterized.class)
@RunWith(Parameterized.class)
public class ParameterTest {
    // 2.声明变量存放预期值和测试数据
    private String firstName;
    private String lastName;

    //3.声明一个返回值 为Collection的公共静态方法，并使用@Parameters进行修饰
    @Parameterized.Parameters //
    public static List<Object[]> param() {
        // 这里我给出两个测试用例
        return Arrays.asList(new Object[][]{{"Mike", "Black"}, {"Cilcln", "Smith"}});
    }

    //4.为测试类声明一个带有参数的公共构造函数，并在其中为之声明变量赋值
    public ParameterTest(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    // 5. 进行测试，发现它会将所有的测试用例测试一遍
    @Test
    public void test() {
        String name = firstName + " " + lastName;
        assertThat("Mike Black", is(name));
    }
}

超时测试

方法前加注解@Test(timeout = 1000)

异常测试

方法前加注解@Test(expected = NullPointerException.class)

套件测试

public class TaskOneTest {
    @Test
    public void test() {
        System.out.println("Task one do.");
    }
}

public class TaskTwoTest {
    @Test
    public void test() {
        System.out.println("Task two do.");
    }
}

public class TaskThreeTest {
    @Test
    public void test() {
        System.out.println("Task Three.");
    }
}

@RunWith(Suite.class) // 1. 更改测试运行方式为 Suite
// 2. 将测试类传入进来
@Suite.SuiteClasses({TaskOneTest.class, TaskTwoTest.class, TaskThreeTest.class})
public class SuitTest {
    /**
     * 测试套件的入口类只是组织测试类一起进行测试，无任何测试方法，
     */
}

事务控制

在@Test注解下添加@Transactional
使用的数据库要支持事务（如：mysql的innodb）
关闭回滚加注解@Rollback(false)

附录：

1、 Hamcrest 下断言语句

字符相关匹配符
/**equalTo匹配符断言被测的testedValue等于expectedValue，
* equalTo可以断言数值之间，字符串之间和对象之间是否相等，相当于Object的equals方法
*/
assertThat(testedValue, equalTo(expectedValue));
/**equalToIgnoringCase匹配符断言被测的字符串testedString
*在忽略大小写的情况下等于expectedString
*/
assertThat(testedString, equalToIgnoringCase(expectedString));
/**equalToIgnoringWhiteSpace匹配符断言被测的字符串testedString
*在忽略头尾的任意个空格的情况下等于expectedString，
*注意：字符串中的空格不能被忽略
*/
assertThat(testedString, equalToIgnoringWhiteSpace(expectedString);
/**containsString匹配符断言被测的字符串testedString包含子字符串subString**/
assertThat(testedString, containsString(subString) );
/**endsWith匹配符断言被测的字符串testedString以子字符串suffix结尾*/
assertThat(testedString, endsWith(suffix));
/**startsWith匹配符断言被测的字符串testedString以子字符串prefix开始*/
assertThat(testedString, startsWith(prefix));
一般匹配符
/**nullValue()匹配符断言被测object的值为null*/
assertThat(object,nullValue());
/**notNullValue()匹配符断言被测object的值不为null*/
assertThat(object,notNullValue());
/**is匹配符断言被测的object等于后面给出匹配表达式*/
assertThat(testedString, is(equalTo(expectedValue)));
/**is匹配符简写应用之一，is(equalTo(x))的简写，断言testedValue等于expectedValue*/
assertThat(testedValue, is(expectedValue));
/**is匹配符简写应用之二，is(instanceOf(SomeClass.class))的简写，
*断言testedObject为Cheddar的实例
*/
assertThat(testedObject, is(Cheddar.class));
/**not匹配符和is匹配符正好相反，断言被测的object不等于后面给出的object*/
assertThat(testedString, not(expectedString));
/**allOf匹配符断言符合所有条件，相当于“与”（&&）*/
assertThat(testedNumber, allOf( greaterThan(8), lessThan(16) ) );
/**anyOf匹配符断言符合条件之一，相当于“或”（||）*/
assertThat(testedNumber, anyOf( greaterThan(16), lessThan(8) ) );
数值相关匹配符
/**closeTo匹配符断言被测的浮点型数testedDouble在20.0¡À0.5范围之内*/
assertThat(testedDouble, closeTo( 20.0, 0.5 ));
/**greaterThan匹配符断言被测的数值testedNumber大于16.0*/
assertThat(testedNumber, greaterThan(16.0));
/** lessThan匹配符断言被测的数值testedNumber小于16.0*/
assertThat(testedNumber, lessThan (16.0));
/** greaterThanOrEqualTo匹配符断言被测的数值testedNumber大于等于16.0*/
assertThat(testedNumber, greaterThanOrEqualTo (16.0));
/** lessThanOrEqualTo匹配符断言被测的testedNumber小于等于16.0*/
assertThat(testedNumber, lessThanOrEqualTo (16.0));
集合相关匹配符
/**hasEntry匹配符断言被测的Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项*/
assertThat(mapObject, hasEntry("key", "value" ) );
/**hasItem匹配符表明被测的迭代对象iterableObject含有元素element项则测试通过*/
assertThat(iterableObject, hasItem (element));
/** hasKey匹配符断言被测的Map对象mapObject含有键值“key”*/
assertThat(mapObject, hasKey ("key"));
/** hasValue匹配符断言被测的Map对象mapObject含有元素值value*/
assertThat(mapObject, hasValue(value));

2、注解说明

/**
 * @Before：初始化方法
 * @After：释放资源
 * @Test：测试方法（包括：期望异常和超时时间）
 *
 * @Test(timeout = 1000)，超时会失败。
 *
 * @Test(expected = NullPointerException.class) 希望抛出空指针异常
 *
 *
 * @Ignore：忽略的测试方法
 * @BeforeClass：针对所有测试，只执行一次，且必须为static void
 * @AfterClass：针对所有测试，只执行一次，且必须为static void
 * @RunWith：可以更改测试运行器
 * 执行顺序：
 *
 * @BeforeClass ==> @Before ==> @Test ==> @After ==> @AfterClass 
 *
 *  
 *
 * @SpringBootTest会加载spring的上下文，这样可以使用@Autowired注入Bean
 */

张晶新

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
springboot编写单元测试

pom：需要引入的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope&g...
复制链接

扫一扫