spring boot 单元测试JUnit5使用断言Assertions和假定Assumptions、嵌套、参数测试
本文基于spirng boot 2.7.11, 大家注意自己的版本
Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库
SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖
源码地址:https://gitcode.net/qq_39339588/springboot.git
文章目录
- spring boot 单元测试JUnit5使用断言Assertions和假定Assumptions、嵌套、参数测试
- 1. 标记单元测试类和方法
- 2. 断言的简单使用
- 1)基本类型和对象的断言
- 2)数组断言
- 3)组合断言
- 4)异常断言
- 5)超时断言
- 6)快速失败断言
- 3. 前置条件断言,假设假定
- 4. 嵌套@Nested
- 5. 参数化测试
- 1)@ValueSource注解,基本类型入参
- 2)@NullSource注解,null入参
- 3)@EnumSource注解,枚举入参
- 4)@CsvSource注解,多参数入参
- 5)@CsvFileSource,参数文件入参
- 6)@MethodSource注解,方法返回值入参
- 7) @ArgumentsSource注解,自定义参数入参
1. 标记单元测试类和方法
@SpringBootTest注解,可以标记为测试类
@Test注解标记是测试方法
@DisplayName注解是标记个名称
@SpringBootTest
public class HelloWorldTest {/*** 断言基础*/@Test@DisplayName("简单断言")public void simple() {}
}
2. 断言的简单使用
1)基本类型和对象的断言
/**
* 基本类型和对象的断言
*/
@Test
@DisplayName("简单断言")
public void simple() {Assertions.assertEquals(3, 1 + 2, "不相等");Assertions.assertNotEquals(3, 1 + 1, "相等了");//断言对象Assertions.assertNotSame(new Object(), new Object(), "对象相同");Object o = new Object();Assertions.assertSame(o, o, "断言不相等了");Assertions.assertFalse(1 > 2);Assertions.assertTrue(1 < 2);Assertions.assertNull(null);Assertions.assertNotNull(new Object());
}
2)数组断言
@DisplayName("数组断言")
@Test
public void array() {// 断言两个数组对象不相等Assertions.assertNotEquals(new int[]{1, 2}, new int[]{1, 2});
}
3)组合断言
@DisplayName("组合断言")
@Test
public void all() {// 断言所多个断言方法都正确Assertions.assertAll("组合断言",() -> Assertions.assertEquals(2, 1 + 1),() -> Assertions.assertTrue(1 > 0));
}
4)异常断言
@DisplayName("异常断言")
@Test
public void exception() {// 断言方法 会出现异常ArithmeticException arithmeticException = Assertions.assertThrows(ArithmeticException.class, () -> System.out.println(1 % 0));arithmeticException.printStackTrace();
}
5)超时断言
@DisplayName("超时断言")
@Test
public void timeOut() {// 断言方法执行不会超过1秒Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
}
6)快速失败断言
@DisplayName("快速失败")
@Test
public void failFast() {// 触发快速失败后AssertionFailedError ex = Assertions.assertThrows(AssertionFailedError.class, () -> {Assertions.fail("触发快速失败");});ex.printStackTrace();
}
3. 前置条件断言,假设假定
执行断言的前提条件,如果假定成功true,才会去执行
/*** 前置条件,假设假定*/
@DisplayName("前置条件")
@Test
public void assuming() {String evn = "dev";// 执行断言的前提条件,如果假定成功true,才会去执行下一行,如果假定失败,下边的就不执行了Assumptions.assumeTrue(Objects.equals(evn, "dev"));Assumptions.assumeFalse(Objects.equals(evn, "prod"));System.out.println("dev和不是prod,执行了");Assumptions.assumeTrue(Objects.equals(evn, "dev1"));System.out.println("dev1,这句会忽略,不会执行输出");
}/*** 假定成功true,才会去执行 执行器方法*/
@DisplayName("前置条件That")
@Test
public void assumingThat() {// 假定成功,才会去执行 执行器方法Assumptions.assumingThat(Objects.equals("dev", "dev"), () -> {System.out.println("in dev");});
}
4. 嵌套@Nested
内部嵌套,每次会先走外层的beforeEach,在走内部的beforeEach;支持嵌套的嵌套
@DisplayName("单元测试示例")
@SpringBootTest
public class HelloWorldTest {Stack<Object> stack;/*** 内部嵌套,每次会先走外层的beforeEach,在走内部的beforeEach*/@DisplayName("内部嵌套测试")@Nestedclass InnerTest {@BeforeEachvoid newStack() {// 创建一个栈对象stack = new Stack<>();}@DisplayName("检查是否为空")@Testvoid isEmpty() {Assertions.assertTrue(stack.isEmpty());}@DisplayName("抛出一个栈pop异常")@Testvoid throwExceptionWhenPop() {Assertions.assertThrows(EmptyStackException.class, stack::pop);}@DisplayName("抛出一个栈peek异常")@Testvoid throwExceptionWhenPeek() {Assertions.assertThrows(EmptyStackException.class, stack::peek);}@Nested@DisplayName("内部的内部嵌套测试")class InnerInnerTest {String item = "item";@BeforeEachvoid pushAnItem() {// 放入一个元素stack.push(item);}@DisplayName("不为空了")@Testvoid isNotEmpty() {Assertions.assertFalse(stack.isEmpty());}@DisplayName("取出一个来,用pop")@Testvoid returnItemByPop() {Assertions.assertEquals(item, stack.pop());Assertions.assertTrue(stack.isEmpty());}@DisplayName("取出一个来,用peek")@Testvoid returnItemByPeek() {Assertions.assertEquals(item, stack.peek());Assertions.assertFalse(stack.isEmpty());}}}
5. 参数化测试
参数化测试,让单元测试的方法支持接收传入的参数
将可以使用不同的参数进行多次单元测试,有多少套参数,就执行多少次单元测试
而不需要每新增一个参数就新增一个单元测试,省去了很多冗余代码
1)@ValueSource注解,基本类型入参
/*** @ValueSource:为参数化测试指定入参来源,支持八大基础类以及String类型,Class类型* @param params*/
@DisplayName("参数化测试,值来源")
@ParameterizedTest
@ValueSource(strings = {"a", "b", "c"})
public void parameterizedTest(String params) {// 会执行3次,分别执行a,b,cSystem.out.println(params);Assertions.assertTrue(StringUtils.isNotBlank(params));
}
2)@NullSource注解,null入参
/*** null入参** @param params*/
@DisplayName("null的入参")
@ParameterizedTest
@NullSource
public void testNull(String params) {Assertions.assertNull(params);
}
3)@EnumSource注解,枚举入参
/*** 枚举入参,会把枚举遍历一遍,分别执行一次方法*/
@DisplayName("枚举的入参")
@ParameterizedTest
@EnumSource(TestEnum.class)
public void testEnumSource(TestEnum params) {System.out.println("state:" + params.state + ",msg:" + params.msg);// state:1,msg:好// state:2,msg:不好Assertions.assertNotNull(params);
}/*** 枚举类*/
@Getter
@AllArgsConstructor
public enum TestEnum {GOOD(1, "好"),BAD(2, "不好");int state;String msg;
}
4)@CsvSource注解,多参数入参
@DisplayName("参数化测试,@CsvSource")
@ParameterizedTest
@CsvSource({"a,b,c"})
void parameterizedTestCsvSource(String a, String b, String c) {// 默认使用逗号分隔System.out.println(a + b + c);Assertions.assertNotNull(a);
}@DisplayName("参数化测试,@CsvSource2")
@ParameterizedTest
@CsvSource(value = {"a,b,c-D"}, delimiterString = "-")
void parameterizedTestCsvSource2(String abc, String d) {// 默认使用逗号分隔,指定分隔符"-"System.out.println(abc);System.out.println(d);Assertions.assertNotNull(abc);// a,b,c// D
}
5)@CsvFileSource,参数文件入参
可以把文件中的内容当做参数,批量来执行,下边附带了my.csv和my2.csv文件内容
注意,要在测试目录下,新建resources目录,再放入my.csv和my2.csv文件
/*** 参数文件** @param methodName*/
@DisplayName("参数化测试,@CsvFileSource")
@ParameterizedTest
@CsvFileSource(resources = "/my.csv")
void parameterizedTestWithCsvFileSource(String methodName) {// 测试目录下,新建resources目录System.out.println(methodName);Assertions.assertNotNull(methodName);
}@DisplayName("参数化测试,@CsvFileSource")
@ParameterizedTest
@CsvFileSource(resources = "/my2.csv", delimiterString = "|")
void parameterizedTestWithCsvFileSource2(String name, Integer age) {// 测试目录下,新建resources目录System.out.println(name + ":" + age);Assertions.assertNotNull(name);// a:18// b:17// c:20
}
my.csv文件
1
2
3
4
my2.csv
a|18
b|17
c|20
6)@MethodSource注解,方法返回值入参
把一个方法的返回值,作为测试用例方法的参数
/*** 动态参数*/
@DisplayName("参数化测试,方法来源")
@ParameterizedTest
@MethodSource("method1") // 如果不指定方法名称,会去找与自己相同名称的静态方法
public void parameterizedTestWithMethodParam(String params) {// MethodSource("method1") 接收这个方法的返回值,之后会执行2次,a,bSystem.out.println(params);Assertions.assertNotNull(params);
}static Stream<String> method1() {return Stream.of("a", "b");
}@DisplayName("参数化测试,方法来源,多参数")
@ParameterizedTest
@MethodSource // 如果不指定方法名称,会去找相同名称的静态方法
public void parameterizedTestWithMethodMultipleParams(String name, Integer age) {System.out.println(name + ":" + age);// a:18// b:17// c:20Assertions.assertNotNull(name);
}static Stream<Arguments> parameterizedTestWithMethodMultipleParams() {return Stream.of(Arguments.arguments("a", 18),Arguments.arguments("b", 17),Arguments.arguments("c", 20));
}
7) @ArgumentsSource注解,自定义参数入参
/*** 实现ArgumentsProvider接口,并在测试方法上使用@ArgumentsSource注解。*/
@DisplayName("@ArgumentsSource注解")
@ParameterizedTest
@ArgumentsSource(MyArgumentsProvider.class)
public void testArgumentsSource(String name, int age) {System.out.println(name + ":" + age);// aa:18// bb:20// cc:30Assertions.assertNotNull(name);
}