这是Project Student的一部分。 其他职位包括带有Jersey的 Web服务 客户端，带有Jersey的 Web服务服务器 ， 业务层和带有Spring Data的持久性 。
到目前为止，所有集成测试都使用了内存嵌入式数据库，该数据库无法一次又一次地保留信息。 当我们将REST服务器与“真实”数据库服务器完全集成时，这种情况会发生变化-剩余的测试数据将污染我们的开发或测试数据库。 一旦我们进行了运行集成测试代码的连续集成，这将是一个非常头疼的事情。
一种解决方案是以一种允许我们的测试使用共享开发数据库而不污染它或其他测试的方式“分片”我们的集成测试数据。 最简单的方法是将TestRun字段添加到所有对象。 “测试”数据将具有指示特定测试运行的值，“实时”数据将具有空值。
确切的时间表是
- 创建并持久保存一个TestRun对象
- 创建具有适当TestRun值的测试对象
- 执行集成测试
- 删除测试对象
- 删除TestRun对象
TestRun表中的任何条目将是1）主动集成测试或2）引发未处理异常的集成测试失败（当然，这取决于事务管理器）。 重要的是要注意，即使事务管理器执行了回滚，我们也可以在引发意外异常后捕获数据库状态-这是对junit测试运行程序的简单扩展。
时间戳记和用户字段使您可以轻松地根据其年龄（例如，超过7天的任何测试）或运行测试的人员删除陈旧的测试数据。
TestablePersistentObject抽象基类
此更改从持久性级别开始，因此我们应该从持久性级别开始并逐步进行扩展。
我们首先用测试运行值扩展PersistentObject抽象基类。
@MappedSuperclass
public abstract class TestablePersistentObject extends PersistentObject {
private static final long serialVersionUID = 1L;
private TestRun testRun;
/**
* Fetch testRun object. We use lazy fetching since we rarely care about the
* contents of this object - we just want to ensure referential integrity to
* an existing testRun object when persisting a TPO.
*
* @return
*/
@ManyToOne(fetch = FetchType.LAZY, optional = true)
public TestRun getTestRun() {
return testRun;
}
public void setTestRun(TestRun testRun) {
this.testRun = testRun;
}
@Transient
public boolean isTestData() {
return testRun != null;
}
}TestRun类
TestRun类包含有关单个集成测试运行的标识信息。 它包含一个名称（默认情况下，该集成测试为classname＃methodname（）） ，测试的日期和时间以及运行该测试的用户的名称。 捕获其他信息将很容易。
测试对象列表为我们带来了两个重大胜利。 首先，如果需要（例如，在意外的异常之后），可以轻松捕获数据库的状态。 其次，级联删除使删除所有测试对象变得容易。
@XmlRootElement
@Entity
@Table(name = "test_run")
@AttributeOverride(name = "id", column = @Column(name = "test_run_pkey"))
public class TestRun extends PersistentObject {
private static final long serialVersionUID = 1L;
private String name;
private Date testDate;
private String user;
private List<TestablePersistentObject> objects = Collections.emptyList();
@Column(length = 80, unique = false, updatable = true)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "test_date", nullable = false, updatable = false)
@Temporal(TemporalType.TIMESTAMP)
public Date getTestDate() {
return testDate;
}
public void setTestDate(Date testDate) {
this.testDate = testDate;
}
@Column(length = 40, unique = false, updatable = false)
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
@OneToMany(cascade = CascadeType.ALL)
public List<TestablePersistentObject> getObjects() {
return objects;
}
public void setObjects(List<TestablePersistentObject> objects) {
this.objects = objects;
}
/**
* This is similar to standard prepersist method but we also set default
* values for everything else.
*/
@PrePersist
public void prepersist() {
if (getCreationDate() == null) {
setCreationDate(new Date());
}
if (getTestDate() == null) {
setTestDate(new Date());
}
if (getUuid() == null) {
setUuid(UUID.randomUUID().toString());
}
if (getUser() == null) {
setUser(System.getProperty("user.name"));
}
if (name == null) {
setName("test run " + getUuid());
}
}
}TestRun类扩展了PersistentObject，而不是TestablePersistentObject，因为我们的其他集成测试将充分利用它。
Spring数据仓库
我们必须向每个存储库添加一种其他方法。
@Repository
public interface CourseRepository extends JpaRepository {
List<Course> findCoursesByTestRun(TestRun testRun);
....
}服务介面
同样，我们必须为每个服务添加两个其他方法。
public interface CourseService {
List<Course> findAllCourses();
Course findCourseById(Integer id);
Course findCourseByUuid(String uuid);
Course createCourse(String name);
Course updateCourse(Course course, String name);
void deleteCourse(String uuid);
// new method for testing
Course createCourseForTesting(String name, TestRun testRun);
// new method for testing
List<Course> findAllCoursesForTestRun(TestRun testRun);
}我不会显示TestRunRepository，TestRunService接口或TestRunService实现，因为它们与我在前几篇博客文章中所描述的相同。
服务实施
我们必须对现有Service实施进行一次小的更改，并添加两种新方法。
@Service
public class CourseServiceImpl implements CourseService {
@Resource
private TestRunService testRunService;
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findAllCourses()
*/
@Transactional(readOnly = true)
@Override
public List<Course> findAllCourses() {
List<Course> courses = null;
try {
courses = courseRepository.findCoursesByTestRun(null);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("error loading list of courses: " + e.getMessage(), e);
}
throw new PersistenceException("unable to get list of courses.", e);
}
return courses;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findAllCoursesForTestRun(com.invariantproperties.sandbox.student.common.TestRun)
*/
@Transactional(readOnly = true)
@Override
public List<Course> findAllCoursesForTestRun(TestRun testRun) {
List<Course> courses = null;
try {
courses = courseRepository.findCoursesByTestRun(testRun);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("error loading list of courses: " + e.getMessage(), e);
}
throw new PersistenceException("unable to get list of courses.", e);
}
return courses;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* createCourseForTesting(java.lang.String,
* com.invariantproperties.sandbox.student.common.TestRun)
*/
@Transactional
@Override
public Course createCourseForTesting(String name, TestRun testRun) {
final Course course = new Course();
course.setName(name);
course.setTestUuid(testRun.getTestUuid());
Course actual = null;
try {
actual = courseRepository.saveAndFlush(course);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error retrieving course: " + name, e);
}
throw new PersistenceException("unable to create course", e);
}
return actual;
}
}CourseServiceIntegrationTest
我们对集成测试进行了一些更改。 我们只需更改一种测试方法，因为它是唯一实际创建测试对象的方法。 其余方法是不需要测试数据的查询。
请注意，我们更改名称值以确保其唯一性。 这是解决唯一性约束（例如，电子邮件地址）的一种方法。
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {
@Resource
private CourseService dao;
@Resource
private TestRunService testService;
@Test
public void testCourseLifecycle() throws Exception {
final TestRun testRun = testService.createTestRun();
final String name = "Calculus 101 : " + testRun.getUuid();
final Course expected = new Course();
expected.setName(name);
assertNull(expected.getId());
// create course
Course actual = dao.createCourseForTesting(name, testRun);
expected.setId(actual.getId());
expected.setUuid(actual.getUuid());
expected.setCreationDate(actual.getCreationDate());
assertThat(expected, equalTo(actual));
assertNotNull(actual.getUuid());
assertNotNull(actual.getCreationDate());
// get course by id
actual = dao.findCourseById(expected.getId());
assertThat(expected, equalTo(actual));
// get course by uuid
actual = dao.findCourseByUuid(expected.getUuid());
assertThat(expected, equalTo(actual));
// get all courses
final List<Course> courses = dao.findCoursesByTestRun(testRun);
assertTrue(courses.contains(actual));
// update course
expected.setName("Calculus 102 : " + testRun.getUuid());
actual = dao.updateCourse(actual, expected.getName());
assertThat(expected, equalTo(actual));
// verify testRun.getObjects
final List<TestablePersistentObject> objects = testRun.getObjects();
assertTrue(objects.contains(actual));
// delete Course
dao.deleteCourse(expected.getUuid());
try {
dao.findCourseByUuid(expected.getUuid());
fail("exception expected");
} catch (ObjectNotFoundException e) {
// expected
}
testService.deleteTestRun(testRun.getUuid());
}
....
}我们可以使用@Before和@After透明地包装所有测试方法，但是许多测试不需要测试数据，而许多需要测试数据的测试则需要唯一的测试数据，例如，电子邮件地址。 在后一种情况下，我们按照上述方法折叠测试UUID。
REST Web服务服务器
REST Web服务需要在请求类中添加测试uuid，并在创建对象时添加一些逻辑以正确处理它。
REST Web服务不支持获取所有测试对象的列表。 “正确”的方法将是创建TestRun服务并响应/ get / {id}查询提供关联的对象。
@XmlRootElement
public class Name {
private String name;
private String testUuid;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTestUuid() {
return testUuid;
}
public void setTestUuid(String testUuid) {
this.testUuid = testUuid;
}
}现在，我们可以检查可选的testUuid字段并调用适当的create方法。
@Service
@Path("/course")
public class CourseResource extends AbstractResource {
@Resource
private CourseService service;
@Resource
private TestRunService testRunService;
/**
* Create a Course.
*
* @param req
* @return
*/
@POST
@Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
@Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
public Response createCourse(Name req) {
log.debug("CourseResource: createCourse()");
final String name = req.getName();
if ((name == null) || name.isEmpty()) {
return Response.status(Status.BAD_REQUEST).entity("'name' is required'").build();
}
Response response = null;
try {
Course course = null;
if (req.getTestUuid() != null) {
TestRun testRun = testRunService.findTestRunByUuid(req.getTestUuid());
if (testRun != null) {
course = service.createCourseForTesting(name, testRun);
} else {
response = Response.status(Status.BAD_REQUEST).entity("unknown test UUID").build();
}
} else {
course = service.createCourse(name);
}
if (course == null) {
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
} else {
response = Response.created(URI.create(course.getUuid())).entity(scrubCourse(course)).build();
}
} catch (Exception e) {
if (!(e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
....
}REST Web服务客户端
最后，REST服务器必须添加一种其他方法。 客户端尚不支持获取所有测试对象的列表。
public interface CourseRestClient {
/**
* Create specific course for testing.
*
* @param name
* @param testRun
*/
Course createCourseForTesting(String name, TestRun testRun);
....
}和
public class CourseRestClientImpl extends AbstractRestClientImpl implements CourseRestClient {
/**
* Create JSON string.
*
* @param name
* @return
*/
String createJson(final String name, final TestRun testRun) {
return String.format("{ \"name\": \"%s\", \"testUuid\": \"%s\" }", name, testRun.getTestUuid());
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#createCourse(java.lang.String)
*/
@Override
public Course createCourseForTesting(final String name, final TestRun testRun) {
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("'name' is required");
}
if (testRun == null || testRun.getTestUuid() == null || testRun.getTestUuid().isEmpty()) {
throw new IllegalArgumentException("'testRun' is required");
}
return createObject(createJson(name, testRun));
}
....
}源代码
可从http://code.google.com/p/invariant-properties-blog/source/browse/student获取源代码。
澄清度
我认为在TestRun中不可能有@OneToMany到TestablePersistentObject，但是使用H2的集成测试成功了。 不幸的是，当我使用PostgreSQL数据库启动完全集成的Web服务时，这会引起问题。 我将代码留在上面，因为即使我们没有通用集合，也总是可以有一个教室列表，一个课程列表等。 但是，代码已从源代码控制的版本中删除。
更正
接口方法应该是findCourseByTestRun_Uuid（） ，而不是findCourseByTestRun（） 。 另一种方法是使用JPA标准查询–请参阅“ 项目学生：JPA标准查询” 。
翻译自: https://www.javacodegeeks.com/2014/01/project-student-sharding-integration-test-data.html
扫一扫
2755
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
