use of org.eclipse.persistence.testing.models.jpa.composite.advanced.member_1.Address in project eclipselink by eclipse-ee4j.
the class EmployeePopulator method addressExample1.
public Address addressExample1() {
Address address = new Address();
address.setCity("Toronto");
address.setPostalCode("L5J2B5");
address.setProvince("ONT");
address.setStreet("1450 Acme Cr., suite 4");
address.setCountry("Canada");
return address;
}
use of org.eclipse.persistence.testing.models.jpa.composite.advanced.member_1.Address in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method internalTestChangeRecordKeepOldValue.
public void internalTestChangeRecordKeepOldValue(boolean addSecondStep) {
if (isOnServer()) {
// the test relies upon keeping attached objects between transactions.
return;
}
DatabaseSessionImpl dbs = getDatabaseSession();
ChangeRecordKeepOldValueListener listener = new ChangeRecordKeepOldValueListener();
dbs.getEventManager().addListener(listener);
EntityManager em = createEntityManager();
try {
// setup
// create original object and referenced objects
Employee emp = new Employee();
emp.setFirstName("TestChangeRecordKeepOldValue");
emp.setLastName("Manager_OriginalName");
emp.setMale();
emp.setSalary(35000);
emp.setPeriod(new EmploymentPeriod(Helper.dateFromYearMonthDate(1993, 0, 1), Helper.dateFromYearMonthDate(1996, 11, 31)));
emp.setFormerEmployment(new FormerEmployment("Original", new EmploymentPeriod(Helper.dateFromYearMonthDate(1990, 0, 1), Helper.dateFromYearMonthDate(1993, 11, 31))));
Address address = new Address();
address.setCountry("Original");
address.setProvince("Original");
address.setCity("Original");
address.setStreet("Original");
address.setPostalCode("Original");
emp.setAddress(address);
Department dep = new Department();
dep.setName("Original");
emp.setDepartment(dep);
emp.addResponsibility("Original_1");
emp.addResponsibility("Original_2");
PhoneNumber phone1 = new PhoneNumber("Original_1", "111", "1111111");
emp.addPhoneNumber(phone1);
PhoneNumber phone2 = new PhoneNumber("Original_2", "222", "2222222");
emp.addPhoneNumber(phone2);
emp.setNormalHours(new Time[] { Helper.timeFromHourMinuteSecond(9, 0, 0), Helper.timeFromHourMinuteSecond(17, 0, 0) });
Employee emp1 = new Employee();
emp1.setFirstName("TestChangeRecordKeepOldValue");
emp1.setLastName("Original_1");
emp.addManagedEmployee(emp1);
Employee emp2 = new Employee();
emp2.setFirstName("TestChangeRecordKeepOldValue");
emp2.setLastName("Original_2");
emp.addManagedEmployee(emp2);
Project proj1 = new SmallProject();
proj1.setName("Original_1");
emp.addProject(proj1);
Project proj2 = new LargeProject();
proj2.setName("Original_2");
emp.addProject(proj2);
Project proj3 = new LargeProject();
proj3.setName("Original_3");
proj3.setTeamLeader(emp);
emp1.addProject(proj3);
emp2.addProject(proj3);
// persist original object and all referenced objects
beginTransaction(em);
Equipment equipment1 = new Equipment();
equipment1.setDescription("Original_1");
// persist is not cascaded for department.equipment - have to explicitly persist it.
em.persist(equipment1);
dep.addEquipment(equipment1);
Equipment equipment2 = new Equipment();
equipment2.setDescription("Original_2");
// persist is not cascaded for department.equipment - have to explicitly persist it.
// moreover, equipment.id is used as a key in dep.equipment Map, therefore equipmet
// should be persisted before been added to dep.
em.persist(equipment2);
dep.addEquipment(equipment2);
// persist is not cascaded for employee.department - have to explicitly persist it.
// moreover, equipment.id is used as a key in dep.equipment Map, therefore equipmet
// should be persisted before been added to dep.
em.persist(dep);
em.persist(emp);
commitTransaction(em);
// backup original object and all referenced objects
CopyGroup copyGroupBackup = new CopyGroup();
copyGroupBackup.cascadeAllParts();
dbs.copy(emp, copyGroupBackup);
// emp references (directly or through other objects) all the created objects, therefore all of them are copied.
Map backupMap = copyGroupBackup.getCopies();
// verify that backup objects are identical to originals
Iterator<Map.Entry> it = backupMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = it.next();
Object original = entry.getKey();
ClassDescriptor descriptor = dbs.getDescriptor(original);
if (!descriptor.isAggregateDescriptor()) {
Object backup = entry.getValue();
if (original == backup) {
fail("Test problem: backup failed: original == backup: " + original);
}
if (!dbs.compareObjects(original, backup)) {
fail("Test problem: backup failed: compareObjects(original, backup) == false: " + original + "; " + backup);
}
}
}
// change original object
beginTransaction(em);
// DirectToField
emp.setLastName("Manager_NewName");
// DirectToField
emp.setSalary(100);
// Aggregate
emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2000, 0, 1));
emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2002, 0, 1));
// Aggregate
// emp.setFormerEmployment(new FormerEmployment("New", new EmploymentPeriod(Helper.dateFromYearMonthDate(1989, 0, 1), Helper.dateFromYearMonthDate(1992, 11, 31))));
emp.getFormerEmployment().setFormerCompany("New");
emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1989, 0, 1));
emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1992, 11, 31));
// Transformation
emp.setStartTime(Helper.timeFromHourMinuteSecond(10, 0, 0));
// DirectCollection
emp.removeResponsibility("Original_1");
emp.addResponsibility("New_1");
// Private Collection 1 to many
PhoneNumber phone1New = new PhoneNumber("New_1", "111", "1111111");
emp.addPhoneNumber(phone1New);
emp.removePhoneNumber(phone1);
// Collection 1 to many
emp.removeManagedEmployee(emp1);
emp1.setManager(null);
em.remove(emp1);
Employee emp1New = new Employee();
emp1New.setFirstName("TestChangeRecordKeepOldValue");
emp1New.setLastName("New_1");
emp1New.addProject(proj3);
emp.addManagedEmployee(emp1New);
// Collection many to many
emp.removeProject(proj1);
em.remove(proj1);
Project proj1New = new LargeProject();
proj1New.setName("New_1");
emp.addProject(proj1New);
// ObjectReference
proj3.setTeamLeader(null);
// ObjectReference
Address addressNew = new Address();
addressNew.setCountry("New");
addressNew.setProvince("New");
addressNew.setCity("New");
addressNew.setStreet("New");
addressNew.setPostalCode("New");
emp.setAddress(addressNew);
em.remove(address);
// Map 1 to many
dep.getEquipment().remove(equipment1.getId());
Equipment equipment1New = new Equipment();
equipment1New.setDescription("New_1");
em.persist(equipment1New);
dep.addEquipment(equipment1New);
// additional change typically overrides existing aggregate or collection with the new one, then alters aggregate or adds to collection.
if (addSecondStep) {
// Aggregate
emp.setPeriod(new EmploymentPeriod());
emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2001, 0, 1));
emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2003, 0, 1));
// Aggregate
emp.setFormerEmployment(new FormerEmployment("New_New", new EmploymentPeriod(Helper.dateFromYearMonthDate(1988, 0, 1), Helper.dateFromYearMonthDate(1991, 11, 31))));
emp.getFormerEmployment().setPeriod(new EmploymentPeriod());
emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1987, 0, 1));
emp.getFormerEmployment().getPeriod().setEndDate(Helper.dateFromYearMonthDate(1990, 0, 1));
// Transformation
emp.setEndTime(Helper.timeFromHourMinuteSecond(18, 0, 0));
// DirectCollection
emp.setResponsibilities(new ArrayList());
emp.addResponsibility("New_New_1");
// Private Collection 1 to many
emp.setPhoneNumbers(new HashSet());
PhoneNumber phone1NewNew = new PhoneNumber("New_New_1", "111", "1111111");
emp.addPhoneNumber(phone1NewNew);
// Collection 1 to many
emp1New.setManager(null);
emp2.setManager(null);
emp.setManagedEmployees(new Vector());
Employee emp1NewNew = new Employee();
emp1NewNew.setFirstName("TestChangeRecordKeepOldValue");
emp1NewNew.setLastName("New_New_1");
emp1NewNew.addProject(proj3);
emp.addManagedEmployee(emp1NewNew);
em.remove(emp1New);
em.remove(emp2);
// Collection many to many
emp.setProjects(new ArrayList());
Project proj1NewNew = new LargeProject();
proj1NewNew.setName("New_New_1");
emp.addProject(proj1NewNew);
em.remove(proj1New);
em.remove(proj2);
// ObjectReference
Address addressNewNew = new Address();
addressNewNew.setCountry("New_New");
addressNewNew.setProvince("New_New");
addressNewNew.setCity("New_New");
addressNewNew.setStreet("New_New");
addressNewNew.setPostalCode("New_New");
emp.setAddress(addressNewNew);
em.remove(addressNew);
// Map 1 to many
// We are about to override equipment map.
// It's a private OneToMany mapping so normally all the
// members would be removed automatically.
// However in theis case we have explicitly persisted the the new member added in thhe current transaction
// (because Equipment's id is used as its key in the Department.equipment Map)
// therefore we have to explicitly em.remove it.
em.remove(equipment1New);
dep.setEquipment(new HashMap());
Equipment equipment1NewNew = new Equipment();
equipment1NewNew.setDescription("New_New_1");
em.persist(equipment1NewNew);
dep.addEquipment(equipment1NewNew);
}
commitTransaction(em);
// backup updated objects
CopyGroup copyGroupUpdated = new CopyGroup();
copyGroupUpdated.cascadeAllParts();
dbs.copy(emp, copyGroupUpdated);
// copies of the updated objects will be altered to contain old values.
// if altering the test, make sure that emp still references (directly or through other objects) all the updated objects, so that all of them are copied.
Map oldValueMap = copyGroupUpdated.getCopies();
// using ChangeRecords bring back the original state of the object
Iterator<Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet>> itChangeSets = ((org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet) listener.uowChangeSet).getCloneToObjectChangeSet().entrySet().iterator();
while (itChangeSets.hasNext()) {
Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet> entry = itChangeSets.next();
Object object = entry.getKey();
ClassDescriptor descriptor = dbs.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet = entry.getValue();
if (!changeSet.shouldBeDeleted() && !changeSet.isNew()) {
List<ChangeRecord> changes = changeSet.getChanges();
if (changes != null && !changes.isEmpty()) {
Object oldValueObject = oldValueMap.get(object);
for (ChangeRecord changeRecord : changeSet.getChanges()) {
Object oldValue = changeRecord.getOldValue();
DatabaseMapping mapping = ((org.eclipse.persistence.internal.sessions.ChangeRecord) changeRecord).getMapping();
mapping.setRealAttributeValueInObject(oldValueObject, oldValue);
}
}
}
}
}
String errorMsgOldValues = "";
// now compare oldValue objects with corresponding backup objects
itChangeSets = ((org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet) listener.uowChangeSet).getCloneToObjectChangeSet().entrySet().iterator();
while (itChangeSets.hasNext()) {
Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet> entry = itChangeSets.next();
Object object = entry.getKey();
ClassDescriptor descriptor = dbs.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
ObjectChangeSet changeSet = entry.getValue();
if (!changeSet.shouldBeDeleted() && !changeSet.isNew()) {
List<ChangeRecord> changes = changeSet.getChanges();
if (changes != null && !changes.isEmpty()) {
Object oldValueObject = oldValueMap.get(object);
Object backupObject = backupMap.get(object);
// compare oldValue with backup object
if (!dbs.compareObjects(oldValueObject, backupObject)) {
errorMsgOldValues += '\t' + object.toString() + '\n';
}
}
}
}
}
// set of attached to em objects
Set updatedObjects = new HashSet();
for (Object object : oldValueMap.keySet()) {
ClassDescriptor descriptor = dbs.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
updatedObjects.add(object);
}
}
// verify that the objects were correctly written to the db
String errorMsgDb = "";
clearCache();
Map updatedToReadBack = new HashMap();
EntityManager em2 = createEntityManager();
beginTransaction(em2);
UnitOfWork uow2 = ((EntityManagerImpl) em2.getDelegate()).getActivePersistenceContext(null);
// before comparison clear all read-only mappings that we didn't set in the attached to em objects.
for (Object object : updatedObjects) {
Object readBack = uow2.readObject(object);
if (readBack instanceof Address) {
((Address) readBack).getEmployees().clear();
} else if (readBack instanceof PhoneNumber) {
((PhoneNumber) readBack).setId(null);
} else if (readBack instanceof Department) {
((Department) readBack).getEmployees().clear();
}
updatedToReadBack.put(object, readBack);
}
// now compare object attached to em with the object read from the db
for (Object entryObject : updatedToReadBack.entrySet()) {
Map.Entry entry = (Map.Entry) entryObject;
Object object = entry.getKey();
Object readBack = entry.getValue();
if (!dbs.compareObjects(object, readBack)) {
errorMsgDb += '\t' + object.toString() + '\n';
}
}
rollbackTransaction(em2);
// clean up
beginTransaction(em);
Set objectsToRemove = new HashSet();
// remove all dependencies and add cache objects to be directly removed.
for (Object object : updatedObjects) {
if (object instanceof Employee) {
((Employee) object).getManagedEmployees().clear();
((Employee) object).setManager(null);
((Employee) object).setAddress((Address) null);
((Employee) object).getProjects().clear();
((Employee) object).setDepartment(null);
objectsToRemove.add(object);
} else if (object instanceof Project) {
((Project) object).setTeamLeader(null);
objectsToRemove.add(object);
} else if (object instanceof Address || object instanceof Department) {
objectsToRemove.add(object);
}
}
// remove objects that should be removed directly.
for (Object object : objectsToRemove) {
em.remove(object);
}
commitTransaction(em);
String errorMsg = "";
if (errorMsgOldValues.length() > 0) {
errorMsgOldValues = "Some old values and back up objects are not equal:\n" + errorMsgOldValues;
errorMsg += errorMsgOldValues;
}
if (errorMsgDb.length() > 0) {
errorMsgDb = "\nSome values were incorrectly written into the db:\n" + errorMsgDb;
errorMsg += errorMsgDb;
}
if (errorMsg.length() > 0) {
fail(errorMsg);
}
} finally {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
closeEntityManager(em);
dbs.getEventManager().removeListener(listener);
}
}
use of org.eclipse.persistence.testing.models.jpa.composite.advanced.member_1.Address in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method testNoPersistOnCommit.
// Test Not using the persist operation on commit.
public void testNoPersistOnCommit() {
// Properties only works in jse.
if (isOnServer()) {
return;
}
EntityManager em = createEntityManager();
beginTransaction(em);
Employee employee = new Employee();
employee.setLastName("SomeName");
Address addr = new Address();
addr.setCity("Douglas");
try {
em.persist(employee);
commitTransaction(em);
verifyObjectInCacheAndDatabase(employee);
closeEntityManager(em);
em = createEntityManager();
beginTransaction(em);
((RepeatableWriteUnitOfWork) JpaHelper.getEntityManager(em).getUnitOfWork()).setDiscoverUnregisteredNewObjectsWithoutPersist(true);
employee = em.find(Employee.class, employee.getId());
employee.setAddress(addr);
addr.getEmployees().add(employee);
commitTransaction(em);
verifyObjectInCacheAndDatabase(employee);
closeEntityManager(em);
em = createEntityManager();
clearCache();
beginTransaction(em);
((RepeatableWriteUnitOfWork) JpaHelper.getEntityManager(em).getUnitOfWork()).setDiscoverUnregisteredNewObjectsWithoutPersist(true);
employee = em.find(Employee.class, employee.getId());
employee.getAddress().setCountry("country");
employee.getAddress().getEmployees().size();
employee.setAddress((Address) null);
em.remove(employee);
commitTransaction(em);
em = createEntityManager();
beginTransaction(em);
employee = em.find(Employee.class, employee.getId());
assertNull("Employee Not Deleted", employee);
commitTransaction(em);
closeEntityManager(em);
} catch (RuntimeException exception) {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
closeEntityManager(em);
throw exception;
} finally {
try {
em = createEntityManager();
clearCache();
beginTransaction(em);
em.remove(em.find(Address.class, addr.getID()));
commitTransaction(em);
} catch (RuntimeException ex) {
// ignore
}
}
}
use of org.eclipse.persistence.testing.models.jpa.composite.advanced.member_1.Address in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method testGetIdentifier.
public void testGetIdentifier() {
EntityManagerFactory emf = getEntityManagerFactory();
EntityManager em = createEntityManager();
beginTransaction(em);
try {
Employee emp = new Employee();
emp.setFirstName("Abe");
emp.setLastName("Jones");
Address addr = new Address();
addr.setCity("Palo Alto");
emp.setAddress(addr);
PhoneNumber pn = new PhoneNumber();
pn.setNumber("1234456");
pn.setType("Home");
emp.addPhoneNumber(pn);
pn.setOwner(emp);
em.persist(emp);
em.flush();
Integer id = emp.getId();
em.clear();
clearCache();
emp = em.find(Employee.class, emp.getId());
PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
Object retrievedId = util.getIdentifier(emp);
assertTrue("Got an incorrect id from persistenceUtil.getIdentifier()", id.equals(retrievedId));
} finally {
rollbackTransaction(em);
}
}
use of org.eclipse.persistence.testing.models.jpa.composite.advanced.member_1.Address in project eclipselink by eclipse-ee4j.
the class EntityMappingsAdvancedJUnitTestCase method testClassInstanceConverter.
public void testClassInstanceConverter() {
EntityManager em = createEntityManager();
beginTransaction(em);
Address add = new Address();
add.setCity("St. Louis");
add.setType(new Bungalow());
em.persist(add);
commitTransaction(em);
int assignedSequenceNumber = add.getId();
em.clear();
getDatabaseSession().getIdentityMapAccessor().initializeAllIdentityMaps();
add = em.find(Address.class, assignedSequenceNumber);
assertTrue("Did not correctly persist a mapping using a class-instance converter", (add.getType() instanceof Bungalow));
beginTransaction(em);
em.remove(add);
commitTransaction(em);
}
Aggregations