/******************************************************************************* | |
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* Oracle - initial API and implementation from Oracle TopLink | |
******************************************************************************/ | |
package org.eclipse.persistence.testing.tests.transparentindirection; | |
import java.util.*; | |
import org.eclipse.persistence.descriptors.RelationalDescriptor; | |
import org.eclipse.persistence.mappings.*; | |
import org.eclipse.persistence.sessions.*; | |
import org.eclipse.persistence.indirection.IndirectContainer; | |
import org.eclipse.persistence.testing.models.transparentindirection.AbstractOrder; | |
import org.eclipse.persistence.testing.models.transparentindirection.AbstractOrderLine; | |
import org.eclipse.persistence.testing.models.transparentindirection.AbstractSalesRep; | |
import org.eclipse.persistence.testing.models.transparentindirection.OrderLine; | |
import org.eclipse.persistence.testing.models.transparentindirection.SalesRep; | |
import org.eclipse.persistence.testing.models.transparentindirection.Order; | |
/** | |
* Test the IndirectList with assorted DatabaseSessions and UnitsOfWork. | |
* @author: Big Country | |
*/ | |
public class IndirectContainerTestDatabase extends ZTestCase { | |
int originalID; | |
/** | |
* Constructor | |
* @param name java.lang.String | |
*/ | |
public IndirectContainerTestDatabase(String name) { | |
super(name); | |
} | |
/** | |
* | |
*/ | |
protected AbstractOrder buildOrderShell() { | |
return new Order(); | |
} | |
/** | |
* | |
*/ | |
protected String buildTestContact1() { | |
return "Freddy"; | |
} | |
/** | |
* | |
*/ | |
protected String buildTestContact2() { | |
return "Richard"; | |
} | |
/** | |
* | |
*/ | |
protected AbstractOrder buildTestOrder1() { | |
AbstractOrder order = buildTestOrderShell("Tommy 2Tone"); | |
order.addSalesRep(newSalesRep("Slippery Sam")); | |
order.addSalesRep(newSalesRep("Slippery Sam's Brother")); | |
order.addSalesRep(newSalesRep("Slippery Samantha")); | |
order.addSalesRep2(newSalesRep("Edgar")); | |
order.addSalesRep2(newSalesRep("Rick")); | |
order.addSalesRep2(newSalesRep("Dan")); | |
order.addSalesRep2(newSalesRep("Johnny")); | |
order.addContact("Tommy"); | |
order.addContact("Pato"); | |
order.addContact("Ranking Roger"); | |
order.addContact2("Jimmy"); | |
order.addContact2("Robert"); | |
order.addContact2("John"); | |
order.addContact2("Keith"); | |
order.addLine(newOrderLine("Specials", 1)); | |
order.addLine(newOrderLine("General Public", 3)); | |
order.addLine(newOrderLine("Madness", 1)); | |
order.setTotal(765); | |
order.total2 = 987; | |
return order; | |
} | |
protected AbstractOrder buildTestOrder2() { | |
AbstractOrder order = buildTestOrderShell("Ferdinand Fox"); | |
order.addSalesRep(newSalesRep("Tricky Dick")); | |
order.addSalesRep(newSalesRep("Shady Shakeem")); | |
order.addSalesRep2(newSalesRep("John")); | |
order.addSalesRep2(newSalesRep("Paul")); | |
order.addSalesRep2(newSalesRep("George")); | |
order.addSalesRep2(newSalesRep("Ringo")); | |
order.addContact("Ferdy"); | |
order.addContact("Franny"); | |
order.addContact2("Gene"); | |
order.addContact2("Paul"); | |
order.addContact2("Ace"); | |
order.addContact2("Peter"); | |
order.addLine(newOrderLine("Squirrel Feeder", 3)); | |
order.addLine(newOrderLine("Squirrel Trap", 6)); | |
order.addLine(newOrderLine("Squirrel Cookbook", 1)); | |
order.setTotal(1234); | |
order.total2 = 7890; | |
return order; | |
} | |
/** | |
* | |
*/ | |
protected AbstractOrder buildTestOrder3() { | |
AbstractOrder order = buildTestOrderShell("Conform Test"); | |
order.addSalesRep(newSalesRep("Tom")); | |
order.addSalesRep2(newSalesRep("Mark")); | |
order.addContact("Jason"); | |
order.addContact2("Guy"); | |
order.addLine(newOrderLine(null, 1)); | |
order.setTotal(3456); | |
order.total2 = 5678; | |
return order; | |
} | |
/** | |
* | |
*/ | |
protected AbstractOrderLine buildTestOrderLine1() { | |
return newOrderLine("Spice Girls", 5); | |
} | |
/** | |
* | |
*/ | |
protected AbstractOrder buildTestOrderShell(String customerName) { | |
return new Order(customerName); | |
} | |
protected AbstractOrderLine newOrderLine(String item, int quanity) { | |
return new OrderLine(item, quanity); | |
} | |
protected AbstractSalesRep newSalesRep(String name) { | |
return new SalesRep(name); | |
} | |
/** | |
* | |
*/ | |
protected AbstractSalesRep buildTestSalesRep1() { | |
return newSalesRep("Sales Weasel"); | |
} | |
/** | |
* | |
*/ | |
protected AbstractSalesRep buildTestSalesRep2() { | |
return newSalesRep("Uncle Ernie"); | |
} | |
/** | |
* | |
*/ | |
protected void compareOrders(AbstractOrder expected, AbstractOrder actual) { | |
this.assertEquals("The customer name is incorrect.", expected.customerName, actual.customerName); | |
this.assertTrue("The sales reps should NOT be populated yet.", !((IndirectContainer)actual.getSalesRepContainer()).isInstantiated()); | |
this.assertEquals("The number of sales reps is incorrect.", expected.getNumberOfSalesReps(), actual.getNumberOfSalesReps()); | |
this.assertTrue("The sales reps should be populated.", ((IndirectContainer)actual.getSalesRepContainer()).isInstantiated()); | |
this.assertUnorderedElementsEqual("The sales reps are not correct.", expected.getSalesRepVector(), actual.getSalesRepVector()); | |
this.assertTrue("The contacts should NOT be populated.", !((IndirectContainer)actual.getContactContainer()).isInstantiated()); | |
this.assertEquals("Number of contacts is incorrect.", expected.getNumberOfContacts(), actual.getNumberOfContacts()); | |
this.assertTrue("The contacts should be populated.", ((IndirectContainer)actual.getContactContainer()).isInstantiated()); | |
this.assertUnorderedElementsEqual("The contacts are not correct.", expected.getContactVector(), actual.getContactVector()); | |
this.assertTrue("The order lines should NOT be populated yet.", !((IndirectContainer)actual.getLineContainer()).isInstantiated()); | |
this.assertEquals("The number of order lines is incorrect.", expected.getNumberOfLines(), actual.getNumberOfLines()); | |
this.assertTrue("The order lines should be populated.", ((IndirectContainer)actual.getLineContainer()).isInstantiated()); | |
this.assertUnorderedElementsEqual("The order lines are not correct.", expected.getLineVector(), actual.getLineVector()); | |
this.assertEquals("Number of contacts2 is incorrect.", expected.getNumberOfContacts2(), actual.getNumberOfContacts2()); | |
this.assertUnorderedElementsEqual("The contacts2 are not correct.", expected.getContactVector2(), actual.getContactVector2()); | |
this.assertEquals("The number of sales reps 2 is incorrect.", expected.getNumberOfSalesReps2(), actual.getNumberOfSalesReps2()); | |
this.assertUnorderedElementsEqual("The sales reps 2 are not correct.", expected.getSalesRepVector2(), actual.getSalesRepVector2()); | |
this.assertTrue("The total should NOT be instantiated yet.", !(actual.total.isInstantiated())); | |
this.assertEquals("The total is incorrect.", expected.getTotal(), actual.getTotal()); | |
this.assertTrue("The total should be instantiated.", actual.total.isInstantiated()); | |
this.assertEquals("The total 2 is incorrect.", expected.total2, actual.total2); | |
} | |
/** | |
* Return the database session. | |
*/ | |
protected Session getBackdoorSession() { | |
return this.getSession(); | |
} | |
/** | |
* no Gromit support for this feature yet | |
*/ | |
public static void modifyOrderDescriptor(RelationalDescriptor d) { | |
((CollectionMapping)d.getMappingForAttributeName("salesReps")).useTransparentCollection(); | |
((CollectionMapping)d.getMappingForAttributeName("contacts")).useTransparentCollection(); | |
((CollectionMapping)d.getMappingForAttributeName("lines")).useTransparentCollection(); | |
} | |
protected AbstractOrder readOrder(AbstractOrder key) { | |
return (AbstractOrder)this.getSession().readObject(key); | |
} | |
/** | |
* set up test fixtures: | |
* log in to database | |
*/ | |
protected void setUp() { | |
super.setUp(); | |
AbstractOrder order = this.buildTestOrder1(); | |
this.writeNewOrder(order); | |
originalID = order.id; | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
} | |
protected void tearDown() { | |
super.tearDown(); | |
} | |
public void testReadAndWriteObject() { | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = this.readOrder(key); | |
orderFromDB.customerName = "DoubleTake"; | |
this.updateOrder(orderFromDB); | |
this.compareOrders(orderFromDB, orderFromDB);// just verify the instantiations | |
} | |
/** | |
* | |
*/ | |
public void testRefreshNewObject() { | |
AbstractOrder originalOrder = this.buildTestOrder2(); | |
this.writeNewOrder(originalOrder); | |
// re-read the object to get the clone if necessary | |
originalOrder = (AbstractOrder)this.getSession().readObject(originalOrder); | |
AbstractOrderLine orderLine = (AbstractOrderLine)((AbstractOrderLine)originalOrder.getLineStream().nextElement()).clone(); | |
orderLine.itemName = "munged"; | |
this.getBackdoorSession().executeNonSelectingSQL("update ORDLINE set ITEM_NAME = '" + orderLine.itemName + "' where ID = " + orderLine.id); | |
AbstractOrder orderFromDB = (AbstractOrder)this.getSession().refreshObject(originalOrder); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertTrue("New order line not found.", orderFromDB.containsLine(orderLine)); | |
this.assertTrue("The order lines should be populated.", ((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
// there were problems with TransformationMappings, so make sure they work too | |
this.assertTrue("The total should NOT be instantiated yet.", !(orderFromDB.total.isInstantiated())); | |
this.assertEquals("The total is incorrect.", this.buildTestOrder2().getTotal(), orderFromDB.getTotal()); | |
this.assertTrue("The total should be instantiated.", orderFromDB.total.isInstantiated()); | |
this.assertEquals("The total 2 is incorrect.", this.buildTestOrder2().total2, orderFromDB.total2); | |
} | |
/** | |
* | |
*/ | |
public void testRefreshObject() { | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
AbstractOrderLine orderLine = (AbstractOrderLine)orderFromDB.getLineStream().nextElement(); | |
this.assertTrue("The order lines should be populated.", ((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
// there were problems with TransformationMappings, so make sure they work too | |
AbstractOrder expected = this.buildTestOrder1(); | |
this.assertTrue("The total should NOT be instantiated yet.", !(orderFromDB.total.isInstantiated())); | |
this.assertEquals("The total is incorrect.", expected.getTotal(), orderFromDB.getTotal()); | |
this.assertTrue("The total should be instantiated.", orderFromDB.total.isInstantiated()); | |
this.assertEquals("The total 2 is incorrect.", expected.total2, orderFromDB.total2); | |
orderLine = (AbstractOrderLine)orderLine.clone(); | |
orderLine.itemName = "munged"; | |
this.getBackdoorSession().executeNonSelectingSQL("update ORDLINE set ITEM_NAME = '" + orderLine.itemName + "' where ID = " + orderLine.id); | |
orderFromDB = (AbstractOrder)this.getSession().refreshObject(orderFromDB); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertTrue("New order line not found.", orderFromDB.containsLine(orderLine)); | |
this.assertTrue("The order lines should be populated.", ((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
// there were problems with TransformationMappings, so make sure they work too | |
this.assertTrue("The total should NOT be instantiated yet.", !(orderFromDB.total.isInstantiated())); | |
this.assertEquals("The total is incorrect.", expected.getTotal(), orderFromDB.getTotal()); | |
this.assertTrue("The total should be instantiated.", orderFromDB.total.isInstantiated()); | |
this.assertEquals("The total 2 is incorrect.", expected.total2, orderFromDB.total2); | |
} | |
/** | |
* | |
*/ | |
public void testUOWAddContact() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
String contact = this.buildTestContact1(); | |
orderFromDB.addContact(contact); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The contacts should NOT be populated.", !((IndirectContainer)orderFromDB.getContactContainer()).isInstantiated()); | |
this.assertEquals("The number of contacts is incorrect.", this.buildTestOrder1().getNumberOfContacts() + 1, orderFromDB.getNumberOfContacts()); | |
this.assertTrue("New contact not found.", orderFromDB.containsContact(contact)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWAddContact2() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
String contact = this.buildTestContact2(); | |
orderFromDB.addContact2(contact); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertEquals("The number of contacts2 is incorrect.", this.buildTestOrder1().getNumberOfContacts2() + 1, orderFromDB.getNumberOfContacts2()); | |
this.assertTrue("New contact2 not found.", orderFromDB.containsContact2(contact)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWAddLine() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
AbstractOrderLine orderLine = this.buildTestOrderLine1(); | |
orderFromDB.addLine(orderLine); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertEquals("The number of order lines is incorrect.", this.buildTestOrder1().getNumberOfLines() + 1, orderFromDB.getNumberOfLines()); | |
this.assertTrue("New order line not found.", orderFromDB.containsLine(orderLine)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWAddSalesRep() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
AbstractSalesRep salesRep = this.buildTestSalesRep1(); | |
orderFromDB.addSalesRep(salesRep); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The sales reps should NOT be populated.", !((IndirectContainer)orderFromDB.getSalesRepContainer()).isInstantiated()); | |
this.assertEquals("The number of sales reps is incorrect.", this.buildTestOrder1().getNumberOfSalesReps() + 1, orderFromDB.getNumberOfSalesReps()); | |
this.assertTrue("New sales rep not found.", orderFromDB.containsSalesRep(salesRep)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWAddSalesRep2() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
AbstractSalesRep salesRep = this.buildTestSalesRep2(); | |
orderFromDB.addSalesRep2(salesRep); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertEquals("The number of sales reps 2 is incorrect.", this.buildTestOrder1().getNumberOfSalesReps2() + 1, orderFromDB.getNumberOfSalesReps2()); | |
this.assertTrue("New sales rep 2 not found.", orderFromDB.containsSalesRep2(salesRep)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWChangeTotal() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
int newTotal = 1111; | |
orderFromDB.setTotal(newTotal); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The total should NOT be instantiated.", !orderFromDB.total.isInstantiated()); | |
this.assertEquals("The total is incorrect.", newTotal, orderFromDB.getTotal()); | |
this.assertTrue("The total should be instantiated.", orderFromDB.total.isInstantiated()); | |
} | |
public void testUOWChangeTotal2() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
int newTotal2 = 2222; | |
orderFromDB.total2 = newTotal2; | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertEquals("The total 2 is incorrect.", newTotal2, orderFromDB.total2); | |
} | |
public void testUOWNewObject() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder originalOrder = this.buildTestOrder2(); | |
uow.registerObject(originalOrder); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalOrder.id; | |
AbstractOrder orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.compareOrders(originalOrder, orderFromDB); | |
} | |
/** | |
* | |
*/ | |
public void testUOWRemoveContact() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
String contact = (String)orderFromDB.getContactStream().nextElement(); | |
orderFromDB.removeContact(contact); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The contacts should NOT be populated.", !((IndirectContainer)orderFromDB.getContactContainer()).isInstantiated()); | |
this.assertEquals("The number of contacts is incorrect.", this.buildTestOrder1().getNumberOfContacts() - 1, orderFromDB.getNumberOfContacts()); | |
this.assertTrue("Removed contact still present.", !orderFromDB.containsContact(contact)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWRemoveContact2() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
String contact = (String)orderFromDB.getContactStream2().nextElement(); | |
orderFromDB.removeContact2(contact); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertEquals("The number of contacts2 is incorrect.", this.buildTestOrder1().getNumberOfContacts2() - 1, orderFromDB.getNumberOfContacts2()); | |
this.assertTrue("Removed contact2 still present.", !orderFromDB.containsContact2(contact)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWRemoveLine() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
AbstractOrderLine orderLine = (AbstractOrderLine)orderFromDB.getLineStream().nextElement(); | |
orderFromDB.removeLine(orderLine); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertEquals("The number of order lines is incorrect.", this.buildTestOrder1().getNumberOfLines() - 1, orderFromDB.getNumberOfLines()); | |
this.assertTrue("Removed order line still present.", !orderFromDB.containsLine(orderLine)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWRemoveSalesRep() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
AbstractSalesRep salesRep = (AbstractSalesRep)orderFromDB.getSalesRepStream().nextElement(); | |
orderFromDB.removeSalesRep(salesRep); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("The sales reps should NOT be populated.", !((IndirectContainer)orderFromDB.getSalesRepContainer()).isInstantiated()); | |
this.assertEquals("The number of sales reps is incorrect.", this.buildTestOrder1().getNumberOfSalesReps() - 1, orderFromDB.getNumberOfSalesReps()); | |
this.assertTrue("Removed sales rep still present.", !orderFromDB.containsSalesRep(salesRep)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWRemoveSalesRep2() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
AbstractSalesRep salesRep = (AbstractSalesRep)orderFromDB.getSalesRepStream2().nextElement(); | |
orderFromDB.removeSalesRep2(salesRep); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertEquals("The number of sales reps 2 is incorrect.", this.buildTestOrder1().getNumberOfSalesReps2() - 1, orderFromDB.getNumberOfSalesReps2()); | |
this.assertTrue("Removed sales rep 2 still present.", !orderFromDB.containsSalesRep2(salesRep)); | |
} | |
/** | |
* | |
*/ | |
public void testUOWUnchanged() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
this.assertTrue("The sales reps should NOT be populated.", !((IndirectContainer)orderFromDB.getSalesRepContainer()).isInstantiated()); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertTrue("The contacts should NOT be populated.", !((IndirectContainer)orderFromDB.getContactContainer()).isInstantiated()); | |
uow.commit(); | |
this.assertTrue("The sales reps should NOT be populated.", !((IndirectContainer)orderFromDB.getSalesRepContainer()).isInstantiated()); | |
this.assertEquals("The number of sales reps is incorrect.", this.buildTestOrder1().getNumberOfSalesReps(), orderFromDB.getNumberOfSalesReps()); | |
this.assertTrue("The sales reps should be populated.", ((IndirectContainer)orderFromDB.getSalesRepContainer()).isInstantiated()); | |
this.assertTrue("The contacts should NOT be populated.", !((IndirectContainer)orderFromDB.getContactContainer()).isInstantiated()); | |
this.assertEquals("The number of contacts is incorrect.", this.buildTestOrder1().getNumberOfContacts(), orderFromDB.getNumberOfContacts()); | |
this.assertTrue("The contacts should be populated.", ((IndirectContainer)orderFromDB.getContactContainer()).isInstantiated()); | |
this.assertTrue("The order lines should NOT be populated.", !((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertEquals("The number of order lines is incorrect.", this.buildTestOrder1().getNumberOfLines(), orderFromDB.getNumberOfLines()); | |
this.assertTrue("The order lines should be populated.", ((IndirectContainer)orderFromDB.getLineContainer()).isInstantiated()); | |
this.assertEquals("The number of contacts2 is incorrect.", this.buildTestOrder1().getNumberOfContacts2(), orderFromDB.getNumberOfContacts2()); | |
this.assertEquals("The number of sales reps 2 is incorrect.", this.buildTestOrder1().getNumberOfSalesReps2(), orderFromDB.getNumberOfSalesReps2()); | |
this.assertTrue("The total should NOT be instantiated yet.", !(orderFromDB.total.isInstantiated())); | |
this.assertEquals("The total is incorrect.", this.buildTestOrder1().getTotal(), orderFromDB.getTotal()); | |
this.assertTrue("The total should be instantiated.", orderFromDB.total.isInstantiated()); | |
this.assertEquals("The total 2 is incorrect.", this.buildTestOrder1().total2, orderFromDB.total2); | |
} | |
/** | |
* Test that the uow works when the collection is replaced without first accessing the original. | |
*/ | |
public void testUOWReplaceCollection() { | |
UnitOfWork uow = this.getSession().acquireUnitOfWork(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalID; | |
AbstractOrder orderFromDB = (AbstractOrder)uow.readObject(key); | |
orderFromDB.clearLines(); | |
uow.commit(); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.assertTrue("Order lines were not removed.", orderFromDB.getLineVector().isEmpty()); | |
} | |
/** | |
* | |
*/ | |
public void testMergeCloneWithSerializedTransparentIndirection() { | |
UnitOfWork uow = getSession().acquireUnitOfWork(); | |
Order originalClone = (Order)uow.readObject(Order.class); | |
originalClone.addSalesRep(new SalesRep("George the Customer")); | |
uow.release(); | |
uow = this.getSession().acquireUnitOfWork(); | |
uow.readObject(originalClone); | |
uow.mergeCloneWithReferences(originalClone); | |
try { | |
uow.commit(); | |
} catch (NullPointerException ex) { | |
this.assertTrue("Merging of the clone did not trigger the back up value holder" + ex.toString(), false); | |
} | |
} | |
/** | |
* | |
*/ | |
public void testWriteAndReadObject() { | |
AbstractOrder originalOrder = this.buildTestOrder2(); | |
this.writeNewOrder(originalOrder); | |
this.getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
AbstractOrder key = this.buildOrderShell(); | |
key.id = originalOrder.id; | |
AbstractOrder orderFromDB = (AbstractOrder)this.getSession().readObject(key); | |
this.compareOrders(originalOrder, orderFromDB); | |
} | |
public void updateOrder(AbstractOrder order) { | |
this.getDatabaseSession().writeObject(order); | |
} | |
/** | |
* write out the new order | |
*/ | |
protected void writeNewOrder(AbstractOrder order) { | |
for (Enumeration stream = order.getSalesRepStream(); stream.hasMoreElements();) { | |
this.getDatabaseSession().writeObject(stream.nextElement()); | |
} | |
for (Enumeration stream = order.getSalesRepStream2(); stream.hasMoreElements();) { | |
this.getDatabaseSession().writeObject(stream.nextElement()); | |
} | |
this.getDatabaseSession().writeObject(order); | |
} | |
} |