java - 使用 jUnit 进行 Spring Hibernate 存储库测试

Question

首先我是Spring+Hibernate开发的新手。遵循大量教程书籍，我已经基于标准创建了一个主要基于 Spring、Hibernate 的示例应用程序，我已经开始为 Repository (DAO) 方法编写一些测试用例，例如 find、findAll、save、delete。

当我执行测试类时，并不是所有的测试用例都为 ex 正确执行，这真的很疯狂。特别是 find 和 findAll 方法。但是当单独运行它们时，它们完美地通过了。

实体

@Entity
@Table(name = "client_master")
public class ClientMaster {

private Long id;
private Long version;
private Date dateCreated;
private Date lastUpdated;
private String clientName;

private List<ProjectMaster> projectMaster;

@Id
@GeneratedValue
public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

@Version
@Column(name = "version")
public Long getVersion() {
    return version;
}

public void setVersion(Long version) {
    this.version = version;
}

@Column(name = "client_name", nullable= false,unique= true)
public String getClientName() {
    return clientName;
}

public void setClientName(String clientName) {
    this.clientName = clientName;
}

@OneToMany(targetEntity = ProjectMaster.class, mappedBy = "lientMaster", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
public List<ProjectMaster> getProjectMaster() {
    return projectMaster;
}

public void setProjectMaster(List<ProjectMaster> ProjectMaster) {
    this.projectMaster = projectMaster;
}

@Column(name = "date_created" , nullable= false)
@Temporal(TemporalType.TIMESTAMP)
public Date getDateCreated() {
    return dateCreated;
}

public void setDateCreated(Date dateCreated) {
    this.dateCreated = dateCreated;
}

@Column(name = "last_updated")
@Temporal(TemporalType.TIMESTAMP)
public Date getLastUpdated() {
    return lastUpdated;
}

public void setLastUpdated(Date lastUpdated) {
    this.lastUpdated = lastUpdated;
}

}  

存储库

import java.util.List;
import javax.persistence.EntityNotFoundException;
import org.hibernate.Query;

@Repository("clientMasterRepo")
@Transactional
public class ClientMasterRepoHibernate implements ClientMasterRepository {

@Autowired
private SessionFactory sessionFactory;

@Override
public ClientMaster find(Long id) {     
    // Based on the Hibernate currentsession get the ClientMaster Object based on Id        
    ClientMaster clientMaster = (ClientMaster) sessionFactory.getCurrentSession().get(ClientMaster.class, id);              
    return clientMaster;
}

@Override
public List<ClientMaster> findAll() {
    // Get all the ClientMaster records.
    Query query = sessionFactory.getCurrentSession().createQuery("FROM ClientMaster");
    List<ClientMaster> clientMasterList = query.list();
    return clientMasterList;

}

@Override
public ClientMaster save(ClientMaster clientMaster) {
    // Insert or Update the ClientMaster object
    sessionFactory.getCurrentSession().saveOrUpdate(clientMaster);
    return CclientMaster;       
}

@Override
public void delete(ClientMaster clientMaster) {
    // Delete the ClientMaster object
    sessionFactory.getCurrentSession().delete(clientMaster);
}

}

JUnit 测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"file:src/main/resources/META-INF/spring/spring-master.xml"})  
public class ClientMasterRepositoryTests {

@Autowired
private ClientMasterRepository clientMasterRepository;

private List<ClientMaster> ClientMasterList;

@Before
public void setup(){
    // Initialize ClientMaster mock objects for testing     
    ClientMasterList = new ArrayList<ClientMaster>();

    ClientMaster client1 = new ClientMaster();
    client1.setClientName("Client1");
    client1.setDateCreated(new Date());
    client1.setLastUpdated(new Date());

    ClientMaster client2 = new ClientMaster();
    client2.setClientName("Client2");
    client2.setDateCreated(new Date());
    client2.setLastUpdated(new Date());

    ClientMaster client3 = new ClientMaster();
    client3.setClientName("Client3");
    client3.setDateCreated(new Date());
    client3.setLastUpdated(new Date());

    ClientMaster client4 = new ClientMaster();
    client4.setClientName("Client4");
    client4.setDateCreated(new Date());
    client4.setLastUpdated(new Date());

    ClientMasterList.add(client1);
    ClientMasterList.add(client2);
    ClientMasterList.add(client3);
    ClientMasterList.add(client4);      
}

@Test
public void testSave(){     
    for (Iterator iterator = ClientMasterList.iterator(); iterator.hasNext();) {
        ClientMaster ClientMaster = (ClientMaster) iterator.next(); 

        // insert the ClientMaster object 
        clientMasterRepository.save(ClientMaster);

        assertTrue(ClientMaster.getClientName()+" is saved - Id "+ClientMaster.getId(),ClientMaster.getId() > 0);
    }       
}

@Test
public void testUpdate(){
    // get a ClientMaster object from the repository
    ClientMaster clientMasterObj = clientMasterRepository.find(1L);

    // assert if its not null
    assertTrue(!clientMasterObj.getClientName().isEmpty());

    // change the client name 
    clientMasterObj.setClientName("Client1-Changed");

    // update the ClientMaster object
    clientMasterRepository.save(clientMasterObj);

    // assert the value changed id true
    assertEquals("Client1-Changed", clientMasterRepository.find(1L).getClientName());
}

@Test   
public void testDelete(){
    // get a CASClientMaster object from the repository
    ClientMaster clientMasterObjBeforeDel = clientMasterRepository.find(2L);

    // delete the ClientMaster object
    clientMasterRepository.delete(clientMasterObjBeforeDel);

    // get a ClientMaster object from the repository
    ClientMaster clientMasterObjAfterDel = clientMasterRepository.find(2L);

    // get the ClientMaster object ID 
    assertNull(clientMasterObjAfterDel);
}

@Test
public void testFind(){

    // get a ClientMaster object from the repository
    ClientMaster clientMasterObj = clientMasterRepository.find(3L);             

    // compare the id's of passed and retrieved objects.
    assertThat(clientMasterObj.getId(), is(3L));
    assertTrue(clientMasterObj.getId() == 3);       
}

@Test
public void testFindAll(){
    // get all ClientMaster object from the repository 
    List<ClientMaster> ClientMasterList = clientMasterRepository.findAll();             

    // check if it returns all records from DB
    assertTrue(ClientMasterList.size() > 0);
    assertThat(ClientMasterList.size(), is(4));
}

}

当我完全执行上述所有测试用例时，find 和 findAll 测试用例将失败，但当单独执行这些测试用例时通过。我是测试框架的新手。让我知道上述测试存储库层的方法是否有任何问题。

更新

即使更新测试用例在某些执行中表现异常，但在某些执行正常时，当我使用 find 方法获取 clientMaster 对象时，它会给出错误“NullPointerException”。

Answer 1

您的测试不会自动重置持久化数据。有几个替代方案可以解决或解决这个问题:

1.将 @Transactional 注释添加到测试中。

事务测试在测试完成后回滚的事务中运行，清除测试保留的任何状态。但是，添加 @Transactional 可能会隐藏一些错误。参见 this article about it .

2。创建一个 @After 方法来清除任何持久的更改

这可能维护起来很麻烦，因为您需要跟踪测试持续存在的所有内容。一种稍微复杂但可维护的方法是在运行测试之前转储数据库，然后在每次测试后从该转储中恢复它。

3。以一种即使数据库已经包含某些东西也不会中断的方式实现测试。

例子:

@Test
public void testEntityGetsPersisted() {
    int countBefore = getCurrentCountOfEntities();
    persistNewEntity();
    int countAfter = getCurrentCountOfEntities();
    assertTrue(countAfter == countBefore + 1);
}