如何测试 Spring Data 存储库？

小开

最佳答案

博士

简而言之——没有办法对 Spring Data JPA 存储库进行合理的单元测试，原因很简单: 模仿我们调用来引导存储库的 JPA API 的所有部分是一种很麻烦的方法。无论如何，单元测试在这里没有太大意义，因为您通常不会自己编写任何实现代码(请参阅下面关于自定义实现的段落) ，因此集成测试是最合理的方法。

细节

我们做了相当多的前期验证和设置，以确保您只能引导一个应用程序，没有无效的派生查询等。

我们为派生查询创建和缓存 CriteriaQuery实例，以确保查询方法不包含任何输入错误。这需要使用 Criteria API 和 met.model。
我们通过要求 EntityManager为这些查询创建一个 Query实例来验证手动定义的查询(这有效地触发了查询语法验证)。
我们检查 Metamodel是否有关于准备 is-new 检查所处理的域类型的元数据。

所有您可能会推迟到手写存储库中的内容，这些内容可能会导致应用程序在运行时中断(由于无效查询等原因)。

如果您仔细想想，您不需要为存储库编写任何代码，因此不需要编写任何单位测试。根本没有必要，因为您可以依赖我们的测试基础来捕获基本的 bug (如果您仍然碰巧遇到一个 bug，请随意提高罚单)。但是，确实需要集成测试来测试持久层的两个方面，因为它们是与您的领域相关的方面:

实体映射
查询语义(每次引导尝试都会验证语法)。

集成测试

这通常是通过使用一个内存数据库和测试用例来完成的，这些用例通常通过测试上下文框架来引导 Spring ApplicationContext(就像你已经做的那样) ，预先填充数据库(通过 EntityManager或 repo 插入对象实例，或者通过一个普通的 SQL 文件) ，然后执行查询方法来验证它们的结果。

测试自定义实现

存储库的自定义实现部分是以某种方式书写，它们不必知道 Spring Data JPA。它们是普通的春豆，可以注射 EntityManager。当然，你可能想尝试用它来模拟交互，但是老实说，单元测试 JPA 对我们来说并不是一个愉快的经历，因为它可以处理相当多的间接操作(EntityManager-> CriteriaBuilder，CriteriaQuery等等) ，所以你最终得到的是模拟返回的模拟等等。

小开

这可能来得有点晚，但我已经写了一些东西，正是为了这个目的。我的库将为您模拟出基本的粗糙存储库方法，并解释您的查询方法的大多数功能。您将不得不为自己的本机查询注入功能，但其余的工作已经为您完成。

看看吧:

Https://github.com/mmnaseri/spring-data-mock

更新

现在在 Maven 中心，状况良好。

小开

如果您正在使用 Spring Boot，那么您可以简单地使用 @SpringBootTest来加载您的 ApplicationContext(这就是您的堆栈跟踪对您发出的咆哮)。这允许您自动连接到您的 Spring-data 存储库中。一定要添加 @RunWith(SpringRunner.class)，这样就可以看到特定于春天的注释:

@RunWith(SpringRunner.class)
@SpringBootTest
public class OrphanManagementTest {


@Autowired
private UserRepository userRepository;


@Test
public void saveTest() {
User user = new User("Tom");
userRepository.save(user);
Assert.assertNotNull(userRepository.findOne("Tom"));
}
}

你可以在他们的医生中阅读更多关于弹簧启动测试的内容。

小开

有了 Spring Boot + Spring Data，它变得非常简单:

@RunWith(SpringRunner.class)
@DataJpaTest
public class MyRepositoryTest {


@Autowired
MyRepository subject;


@Test
public void myTest() throws Exception {
subject.save(new MyEntity());
}
}

@ hez 的解决方案显示了完整的上下文，这只显示了 JPA + T 事务工作所需的内容。注意，上面的解决方案将提供一个内存测试数据库，因为可以在类路径中找到这个数据库。

小开

使用 JUnit5和 @DataJpaTest测试将看起来像(kotlin 代码) :

@DataJpaTest
@ExtendWith(value = [SpringExtension::class])
class ActivityJpaTest {


@Autowired
lateinit var entityManager: TestEntityManager


@Autowired
lateinit var myEntityRepository: MyEntityRepository


@Test
fun shouldSaveEntity() {
// when
val savedEntity = myEntityRepository.save(MyEntity(1, "test")


// then
Assertions.assertNotNull(entityManager.find(MyEntity::class.java, savedEntity.id))
}
}

您可以使用 org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager包中的 TestEntityManager来验证实体状态。

小开

我用这种方法解决了这个问题

    @RunWith(SpringRunner.class)
@EnableJpaRepositories(basePackages={"com.path.repositories"})
@EntityScan(basePackages={"com.model"})
@TestPropertySource("classpath:application.properties")
@ContextConfiguration(classes = {ApiTestConfig.class,SaveActionsServiceImpl.class})
public class SaveCriticalProcedureTest {


@Autowired
private SaveActionsService saveActionsService;
.......
.......
}

小开

当您真正想为 Spring 数据存储库编写 i-test 时，您可以这样做:

@RunWith(SpringRunner.class)
@DataJpaTest
@EnableJpaRepositories(basePackageClasses = WebBookingRepository.class)
@EntityScan(basePackageClasses = WebBooking.class)
public class WebBookingRepositoryIntegrationTest {


@Autowired
private WebBookingRepository repository;


@Test
public void testSaveAndFindAll() {
WebBooking webBooking = new WebBooking();
webBooking.setUuid("some uuid");
webBooking.setItems(Arrays.asList(new WebBookingItem()));
repository.save(webBooking);


Iterable<WebBooking> findAll = repository.findAll();


assertThat(findAll).hasSize(1);
webBooking.setId(1L);
assertThat(findAll).containsOnly(webBooking);
}
}

为了遵循这个例子，你必须使用这些依赖项:

<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.197</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.9.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

小开

在弹簧启动 2.1.1. 释放的最后一个版本中，它简单如下:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SampleApplication.class)
public class CustomerRepositoryIntegrationTest {


@Autowired
CustomerRepository repository;


@Test
public void myTest() throws Exception {


Customer customer = new Customer();
customer.setId(100l);
customer.setFirstName("John");
customer.setLastName("Wick");


repository.save(customer);


List<?> queryResult = repository.findByLastName("Wick");


assertFalse(queryResult.isEmpty());
assertNotNull(queryResult.get(0));
}
}

完整代码:

Https://github.com/jrichardsz/spring-boot-templates/blob/master/003-hql-database-with-integration-test/src/test/java/test/customerrepositoryintegrationtest.java

小开

springboot 2.4.5




import javax.persistence.EntityManager;
import javax.persistence.ParameterMode;
import javax.persistence.PersistenceContext;
import javax.persistence.StoredProcedureQuery;


@Repository
public class MyRepositoryImpl implements MyRepository {
@Autowired
@PersistenceContext(unitName = "MY_JPA_UNIT")
private EntityManager entityManager;
    

    

@Transactional("MY_TRANSACTION_MANAGER")
@Override
public MyEntity getSomething(Long id) {
    

StoredProcedureQuery query = entityManager.createStoredProcedureQuery(
"MyStoredProcedure", MyEntity.class);
query.registerStoredProcedureParameter("id", Long.class, ParameterMode.IN);
query.setParameter("id", id);


query.execute();
        

@SuppressWarnings("unchecked")
MyEntity myEntity = (MyEntity) query.getResultList().stream().findFirst().orElse(null);
return myEntity;
}
}


import org.junit.jupiter.api.*;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;


import javax.persistence.EntityManager;
import javax.persistence.StoredProcedureQuery;
import java.util.List;


import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;


@RunWith(MockitoJUnitRunner.Silent.class)
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class MyRepositoryTest {


@InjectMocks
MyRepositoryImpl myRepository;


@Mock
private EntityManager entityManager;


@Mock
private StoredProcedureQuery storedProcedureQuery;
    

@BeforeAll
public void init() {
MockitoAnnotations.openMocks(this);
Mockito.when(entityManager.createStoredProcedureQuery(Mockito.any(), Mockito.any(Class.class)))
.thenReturn(storedProcedureQuery);
}


@AfterAll
public void tearDown() {
// something
}
    

@Test
void testMethod() throws Exception {
Mockito.when(storedProcedureQuery.getResultList()).thenReturn(List.of(myEntityMock));


MyEntity resultMyEntityList = myRepository.getSomething(1l);


assertThat(resultMyEntityList,
allOf(hasProperty("id", org.hamcrest.Matchers.is("1"))
. . .
);
}
}

小开

2021年，在一个新的初始化的 springboot 2.5.1项目中，我是这样做的:

...
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;




@ExtendWith(MockitoExtension.class)
@DataJpaTest
public class SomeTest {


@Autowired
MyRepository repo;


@Test
public void myTest() throws Exception {
repo.save(new MyRepoEntity());
/*...
/ Actual Test. For Example: Will my queries work? ... etc.
/ ...
*/
}
}

小开

您可以使用仅关注 JPA 组件的 @ DataJpaTest注释。默认情况下，它扫描 @ 实体类并配置带有 @ Repository注释的 Spring Data JPA 存储库。

默认情况下，用@DataJpaTest 注释的测试在每个测试结束时是 transactional and roll back。

//in Junit 5 @RunWith(SpringRunner.class) annotation is not required


@DataJpaTest
public class EmployeeRepoTest {


@Autowired
EmployeeRepo repository;
 

@Test
public void testRepository()
{
EmployeeEntity employee = new EmployeeEntity();
employee.setFirstName("Anand");
employee.setProject("Max Account");
     

repository.save(employee);
     

Assert.assertNotNull(employee.getId());
}
}

Junit4语法将与 SpringRunner 类一起使用。

//Junit 4
@RunWith(SpringRunner.class)
@DataJpaTest
public class DataRepositoryTest{
//
}