SpringBoot+TestNG+service层单元测试-参数化DataProvider
首先把被测试的service放在这里,每个方法是干什么的其实通过方法名是可以猜出来的
package com.newcrud.service.impl;
import com.newcrud.entity.Blog;
import com.newcrud.mapper.BlogMapper;
import com.newcrud.service.BlogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
//实现service层的对应接口
public class BlogServiceImpl implements BlogService {
//引入对应的mapper层，因为其实在mapper层完成了xml文件的编写的时候，对应的接口已经实现了其增删改查的功能。
@Autowired
BlogMapper blogMapper;
@Autowired
@Override
public List<Blog> getBlogs() {
return blogMapper.getBlogs();
}
@Override
public List<Blog> getBlogByUserId(Integer userid) {
return blogMapper.getBlogByUserId(userid);
}
@Override
public boolean insertBlog(Blog blog) {
return blogMapper.insertBlog(blog);
}
@Override
public boolean updateBlog(Blog blog) {
return blogMapper.updateBlog(blog);
}
@Override
public boolean deleteBlogById(Integer id) {
return blogMapper.deleteBlogById(id);
}
}
简单使用：一对一+多次执行
package com.newcrud.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.Assert;
import org.testng.annotations.*;
import static org.testng.Assert.*;
@SpringBootTest
public class BlogServiceImplTest extends AbstractTestNGSpringContextTests {
@Autowired
BlogServiceImpl blogService;
//数据提供者
@DataProvider(name = "zhangsan")
public Object[][] getData(){
return new Object[][]{
//如果有多个参数，则对应的数据消费者就执行几次，这里是只有一个参数，如果有多个参数的话则是,比如testGetBlogByUserId的参数为(int id,String name)
//{1,"zhangsan"},{2,"lisi"},{3,"wangwu"},testGetBlogByUserId会自动根据{1,"zhangsan"}的顺序去获取对应参数的值
{1},{2},{3}
};
}
//数据消费者，通过dataProvider的name来确定提供者是谁
@Test(dataProvider = "zhangsan")
public void testGetBlogByUserId(int id) {
System.out.println(id);
System.out.println(blogService.getBlogByUserId(id));
assertEquals(1,id);
}
}
结果
根据方法名提供不同的参数
package com.newcrud.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.lang.reflect.Method;
import static org.testng.Assert.*;
@SpringBootTest
public class BlogServiceImplTest extends AbstractTestNGSpringContextTests {
@Autowired
BlogServiceImpl blogService;
@DataProvider(name = "zhangsan")
//入参为方法
public Object[][] getData(Method method){
Object[][] data = null;
//根据反射原理，获取到方法的名字
String name = method.getName();
//根据不通的方法名字返回不通的数据
if (name.equals("testGetBlogByUserId")){
data = new Object[][]{
{1},{2},{3}
};
}else if (name.equals("testGetBlogByUserId2")){
data = new Object[][]{
{77},{88},{99}
};
}
return data;
}
@Test(dataProvider = "zhangsan")
public void testGetBlogByUserId(int id) {
System.out.println(id);
System.out.println(blogService.getBlogByUserId(id));
}
@Test(dataProvider = "zhangsan")
public void testGetBlogByUserId2(int id) {
System.out.println(id);
System.out.println(blogService.getBlogByUserId(id));
}
}
结果
提供者和消费者不在同一个类
数据提供者
package com.newcrud.dataProvider;
import org.testng.annotations.DataProvider;
public class MyDataProvider {
//通过注解来表明这是一个TestNG的数据提供者
@DataProvider(name = "lisi")
//这里可以是静态方法，也可以去掉
public static Object[][] getData(){
Object[][] data = new Object[][]{
{33},{44},{55}
};
return data;
}
}
数据消费者
package com.newcrud.service.impl;
import com.newcrud.dataProvider.MyDataProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.lang.reflect.Method;
import static org.testng.Assert.*;
@SpringBootTest
public class BlogServiceImplTest extends AbstractTestNGSpringContextTests {
@Autowired
BlogServiceImpl blogService;
@DataProvider(name = "zhangsan")
//入参为方法
public Object[][] getData(Method method){
Object[][] data = null;
//根据反射原理，获取到方法的名字
String name = method.getName();
//根据不通的方法名字返回不通的数据
if (name.equals("testGetBlogByUserId")){
data = new Object[][]{
{1},{2},{3}
};
}else if (name.equals("testGetBlogByUserId2")){
data = new Object[][]{
{77},{88},{99}
};
}
return data;
}
@Test(dataProvider = "zhangsan")
public void testGetBlogByUserId(int id) {
System.out.println(id);
System.out.println(blogService.getBlogByUserId(id));
}
//切换数据提供者为lisi，由于不在一个类里，还需要指定对应类的class，并在类中import
@Test(dataProvider = "lisi",dataProviderClass = MyDataProvider.class)
public void testGetBlogByUserId2(int id) {
System.out.println(id);
System.out.println(blogService.getBlogByUserId(id));
}
}
结果
做完上面的，是不是想象空间更大了，因为你可以单独写一个专门的数据提供类，再根据method去针对性的提供数据，这样也做到了数据和逻辑的分离。
还原数据
比如说我们测试新增或者删除功能的时候，我们测试完成后还想还原数据怎么办
这是我原来的数据
package com.newcrud.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;
import org.springframework.transaction.annotation.Transactional;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
@SpringBootTest
//AbstractTransactionalTestNGSpringContextTests就是回滚的秘密
public class BlogServiceImplTest extends AbstractTransactionalTestNGSpringContextTests {
@Autowired
BlogServiceImpl blogService;
@Test
public void testDeleteBlogById() {
blogService.deleteBlogById(9);
}
@Test
public void testDeleteBlogById2() {
blogService.deleteBlogById(10);
}
}
结果：测试用例执行成功了，数据还没被删除，而且日志里有这么一段
o.s.t.c.transaction.TransactionContext : Rolled back transaction for test: [DefaultTestContext@22e357dc testClass = BlogServiceImplTest, testInstance = com.newcrud.service.impl.BlogServiceImplTest@40cb8df7, testMethod = testDeleteBlogById2@BlogServiceImplTest。。。。。。
说明操作完成后被回滚了
