The DAO tests and their test base are for testing the JPA entities & Spring Data JPA repositories against an in memory database.
The DAO test config is very simple and just loads all of the DB Spring configuration files. All Spring XML configuration files end in -context.xml and test ones end in -test-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<import resource="classpath*:/META-INF/spring/db/**/*-context.xml"/>
</beans>
Most of the test configuration was already configured in the parent
test classes. All that is left is to configure the test
Spring configuration to use by setting the @ContextConfiguration.
As each test extending this class runs, it will automatically use this
shared Spring test context.
Example 3. AbstractRepositoryTest
@ContextConfiguration({ "classpath:/dao-test-context.xml" })
public abstract class AbstractRepositoryTest extends AbstractTransactionalProfileTest {
}
The person repository test is for the
Spring Data JPA PersonRepository.
There is in progress work for having Person subclasses work through the entire stack.
Example 4. PersonRepositoryTest
public class PersonRepositoryTest extends AbstractRepositoryTest {
final Logger logger = LoggerFactory.getLogger(PersonRepositoryTest.class);
@Autowired
private PersonRepository personRepository;
@Autowired
private ProfessionalRepository professionalRepository;
@Test
public void testFindOne() {
Person person = personRepository.findOne(FIRST_ID);
testPersonOne(person);
}
@Test
public void testFindAll() {
Collection<Person> persons = personRepository.findAll();
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + EXPECTED_COUNT + ".", EXPECTED_COUNT, persons.size());
for (Person person : persons) {
logger.debug(person.toString());
if (FIRST_ID.equals(person.getId())) {
testPersonOne(person);
} else if (SECOND_ID.equals(person.getId())) {
testPersonTwo(person);
}
}
}
@Test
public void testFindByFirstNameLike() {
List<Person> persons = personRepository.findByFirstNameLike("J%");
int expectedCount = 2;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
Person person = persons.get(0);
testPersonOne(person);
}
@Test
public void testFindByLastName() {
List<Person> persons = personRepository.findByLastName(LAST_NAME);
int expectedCount = 1;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
Person person = persons.get(0);
testPersonOne(person);
}
@Test
public void testFindByAddress() {
List<Person> persons = personRepository.findByAddress(ADDR);
int expectedCount = 1;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
Person person = persons.get(0);
testPersonOne(person);
}
@Test
public void testFindByAddressPage() {
String firstName = "Jack";
String lastName = "Johnson";
String companyName = "Spring Pizza";
int page = 0;
int size = 10;
for (int i = 0; i < 35; i++) {
createProfessional(firstName, lastName, companyName, ADDR);
}
Page<Person> pageResult = personRepository.findByAddress(ADDR, new PageRequest(page, size));
List<Person> persons = pageResult.getContent();
int expectedCount = size;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
// query last page
page = pageResult.getTotalPages() - 1;
pageResult = personRepository.findByAddress(ADDR, new PageRequest(page, size));
persons = pageResult.getContent();
// created 35 records with the same address, one existing
expectedCount = 6;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
}
@Test
public void testFindByName() {
List<Person> persons = personRepository.findByName(FIRST_NAME, LAST_NAME);
int expectedCount = 1;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
Person person = persons.get(0);
testPersonOne(person);
}
@Test
public void testSave() {
String firstName = "Jack";
String lastName = "Johnson";
String companyName = "Spring Pizza";
Person person = createProfessional(firstName, lastName, companyName, ADDR);
// get PK of first address
Integer addressId = person.getAddresses().iterator().next().getId();
// test saved person
testPerson(person,
firstName, lastName,
EXPECTED_ADDRESS_COUNT, addressId, ADDR, CITY, STATE, ZIP_POSTAL,
true, companyName);
person = professionalRepository.findOne(person.getId());
// test retrieved person just saved
testPerson(person,
firstName, lastName,
EXPECTED_ADDRESS_COUNT, addressId, ADDR, CITY, STATE, ZIP_POSTAL,
true, companyName);
Collection<Person> persons = personRepository.findAll();
int expectedCount = EXPECTED_COUNT + 1;
assertNotNull("Person list is null.", persons);
assertEquals("Number of persons should be " + expectedCount + ".", expectedCount, persons.size());
}
@Test
public void testUpdate() {
Person person = personRepository.findOne(FIRST_ID);
testPersonOne(person);
String lastName = "Jones";
person.setLastName(lastName);
personRepository.saveAndFlush(person);
person = personRepository.findOne(FIRST_ID);
testPersonOne(person, lastName);
}
@Test
public void testDelete() {
personRepository.delete(FIRST_ID);
// person should be null after delete
Person person = personRepository.findOne(FIRST_ID);
assertNull("Person is not null.", person);
}
/**
* Create professional.
*/
private Person createProfessional(String firstName, String lastName, String companyName,
String addr) {
Professional person = new Professional();
Set<Address> addresses = new HashSet<Address>();
Address address = new Address();
addresses.add(address);
address.setAddress(addr);
address.setCity(CITY);
address.setState(STATE);
address.setZipPostal(ZIP_POSTAL);
address.setCountry(COUNTRY);
person.setFirstName(firstName);
person.setLastName(lastName);
person.setCompanyName(companyName);
person.setAddresses(addresses);
Person result = personRepository.saveAndFlush(person);
return result;
}
/**
* Tests person with a PK of one.
*/
private void testPersonOne(Person person) {
testPersonOne(person, LAST_NAME);
}
/**
* Tests person with a PK of one.
*/
private void testPersonOne(Person person, String lastName) {
String schoolName = "NYU";
Integer addressId = new Integer(1);
testPerson(person,
FIRST_NAME, lastName,
EXPECTED_ADDRESS_COUNT, addressId, ADDR, CITY, STATE, ZIP_POSTAL,
false, schoolName);
}
/**
* Tests person with a PK of two.
*/
private void testPersonTwo(Person person) {
String firstName = "John";
String lastName = "Wilson";
String companyName = "Spring Pizza";
int expectedAddresses = 2;
Integer addressId = new Integer(3);
String addr = "47 Howard St.";
String city = "San Francisco";
String state = "CA";
String zipPostal = "94103";
testPerson(person,
firstName, lastName,
expectedAddresses, addressId, addr, city, state, zipPostal,
true, companyName);
}
/**
* Tests person.
*/
private void testPerson(Person person,
String firstName, String lastName,
int expectedAddresses, Integer addressId,
String addr, String city, String state, String zipPostal,
boolean professional, String professionName) {
assertNotNull("Person is null.", person);
assertEquals("firstName", firstName, person.getFirstName());
assertEquals("lastName", lastName, person.getLastName());
assertNotNull("Person's address list is null.", person.getAddresses());
assertEquals("addresses", expectedAddresses, person.getAddresses().size());
// if (professional) {
// assertTrue("Person should be an instance of professional.", (person instanceof Professional));
// assertEquals("companyName", professionName, ((Professional)person).getCompanyName());
// } else {
// assertTrue("Person should be an instance of student.", (person instanceof Student));
// assertEquals("schoolName", professionName, ((Student)person).getSchoolName());
// }
for (Address address : person.getAddresses()) {
assertNotNull("Address is null.", address);
if (addressId.equals(address.getId())) {
assertEquals("address.id", addressId, address.getId());
assertEquals("address.addr", addr, address.getAddress());
assertEquals("address.city", city, address.getCity());
assertEquals("address.state", state, address.getState());
assertEquals("address.zipPostal" + zipPostal + "'.", zipPostal, address.getZipPostal());
assertEquals("address.country", COUNTRY, address.getCountry());
testAuditable(address);
}
}
testAuditable(person);
}
/**
* Tests auditable entity.
*/
private void testAuditable(AbstractAuditableEntity auditRecord) {
assertNotNull("lastUpdated", auditRecord.getLastModifiedDate());
assertNotNull("lastUpdatedBy", auditRecord.getLastModifiedBy());
assertNotNull("created", auditRecord.getCreatedDate());
assertNotNull("createdBy", auditRecord.getCreatedBy());
}
}