/* | |
* TestInstanceCallbacks.java | |
* | |
* Created on October 12, 2006, 1:19 PM | |
* | |
* To change this template, choose Tools | Template Manager | |
* and open the template in the editor. | |
*/ | |
/* | |
* Licensed to the Apache Software Foundation (ASF) under one | |
* or more contributor license agreements. See the NOTICE file | |
* distributed with this work for additional information | |
* regarding copyright ownership. The ASF licenses this file | |
* to you under the Apache License, Version 2.0 (the | |
* "License"); you may not use this file except in compliance | |
* with the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, | |
* software distributed under the License is distributed on an | |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
* KIND, either express or implied. See the License for the | |
* specific language governing permissions and limitations | |
* under the License. | |
*/ | |
package org.apache.openjpa.persistence.kernel; | |
import org.apache.openjpa.persistence.kernel.common.apps.InstanceCallbacksTest; | |
import org.apache.openjpa.persistence.kernel.common.apps.RuntimeTest1; | |
import junit.framework.AssertionFailedError; | |
import org.apache.openjpa.persistence.OpenJPAEntityManager; | |
public class TestInstanceCallbacks extends BaseKernelTest { | |
private static final int COMMIT = 0; | |
private static final int FLUSH = 1; | |
private static final int PRESTORE = 2; | |
private OpenJPAEntityManager _pm = null; | |
private InstanceCallbacksTest _callbacks = null; | |
public TestInstanceCallbacks(String name) { | |
super(name); | |
} | |
/** | |
* Creates a new instance of TestInstanceCallbacks | |
*/ | |
public TestInstanceCallbacks() { | |
} | |
public void setUp() throws Exception { | |
deleteAll(InstanceCallbacksTest.class); | |
deleteAll(RuntimeTest1.class); | |
_pm = getPM(true, true); | |
startTx(_pm); | |
_callbacks = new InstanceCallbacksTest(); | |
_callbacks.setStringField("foo"); | |
_pm.persist(_callbacks); | |
Object id = _pm.getObjectId(_callbacks); | |
endTx(_pm); | |
endEm(_pm); | |
// re-find with different PM | |
_pm = getPM(); | |
_callbacks = | |
(InstanceCallbacksTest) _pm.find(InstanceCallbacksTest.class, id); | |
} | |
public void tearDown() throws Exception { | |
rollbackTx(_pm); | |
endEm(_pm); | |
super.tearDown(); | |
} | |
public void testPostLoad() { | |
_callbacks.getStringField(); | |
assertTrue(_callbacks.postLoadCalled); | |
} | |
public void testPreStore() { | |
preStoreTest(COMMIT); | |
} | |
public void testPreStoreWithFlush() { | |
preStoreTest(FLUSH); | |
} | |
public void testPreStoreWithPreStore() { | |
preStoreTest(PRESTORE); | |
} | |
private void preStoreTest(int action) { | |
assertNoCallbacksInvoked(_callbacks); | |
// _pm.begin(); | |
startTx(_pm); | |
_callbacks.setStringField("bar"); | |
Object oid = _pm.getObjectId(_callbacks); | |
if (action == COMMIT) { | |
_pm.flush(); | |
endTx(_pm); | |
} else if (action == FLUSH) | |
_pm.flush(); | |
else if (action == PRESTORE) | |
_pm.preFlush(); | |
assertTrue("prestore wasnt called", _callbacks.preStoreCalled); | |
if (action != COMMIT) { | |
// _pm.commit(); | |
if (action != FLUSH) | |
_pm.flush(); | |
endTx(_pm); | |
} | |
OpenJPAEntityManager pm = getPM(); | |
InstanceCallbacksTest callbacks = (InstanceCallbacksTest) | |
pm.find(InstanceCallbacksTest.class, oid); | |
assertNoCallbacksInvoked(callbacks); | |
assertEquals("getonetoone strng is not jdoprestore", "jdoPreStore", | |
callbacks.getOneOne().getStringField()); | |
endEm(pm); | |
} | |
public void testPreDelete() { | |
assertNoCallbacksInvoked(_callbacks); | |
startTx(_pm); | |
_pm.remove(_callbacks); | |
assertTrue(_callbacks.preDeleteCalled); | |
endTx(_pm); | |
} | |
public void testPreDeleteRecursion() { | |
assertNoCallbacksInvoked(_callbacks); | |
startTx(_pm); | |
_callbacks.preDeleteCycle = 0; | |
_pm.remove(_callbacks); | |
assertEquals(1, _callbacks.preDeleteCycle); | |
endTx(_pm); | |
} | |
public void testSetRelatedReferenceInPreStore() { | |
assertNull(_callbacks.getRelId()); | |
InstanceCallbacksTest callbacks2 = new InstanceCallbacksTest(); | |
callbacks2.setRelId(_pm.getObjectId(_callbacks)); | |
startTx(_pm); | |
_pm.persist(callbacks2); | |
_pm.flush(); | |
endTx(_pm); | |
assertEquals(8888, _callbacks.getIntField()); | |
try { | |
assertEquals(callbacks2, _callbacks.getRel()); | |
} catch (AssertionFailedError afe) { | |
bug(1162, afe, "Setting a related object reference in " | |
+ "preStore fails"); | |
} | |
} | |
public void testFlushCausesFlush() { | |
//### JDO2MIG : this is failing because we're consuming exceptions | |
// throws from callbacks; need to decide what to do with them | |
causeFlushTest(FLUSH); | |
} | |
public void testPreStoreCausesFlush() { | |
//### JDO2MIG : this is failing because we're consuming exceptions | |
// throws from callbacks; need to decide what to do with them | |
causeFlushTest(PRESTORE); | |
} | |
private void causeFlushTest(int action) { | |
startTx(_pm); | |
_callbacks.setStringField("sss"); | |
_callbacks.flushInPreStore = true; | |
try { | |
if (action == FLUSH) | |
_pm.flush(); | |
else | |
_pm.preFlush(); | |
bug(1139, "Recursive flush allowed because exception swallowed"); | |
} catch (Exception je) { | |
} | |
rollbackTx(_pm); | |
} | |
private void assertNoCallbacksInvoked(InstanceCallbacksTest pc) { | |
OpenJPAEntityManager pm = | |
(OpenJPAEntityManager) currentEntityManager(); | |
assertFalse("Expected preDelete to not have been called for object ID " | |
+ pm.getObjectId(pc), pc.preDeleteCalled); | |
assertFalse("Expected preClear to not have been called for object ID " | |
+ pm.getObjectId(pc), pc.preClearCalled); | |
assertFalse("Expected preStore to not have been called for object ID " | |
+ pm.getObjectId(pc), pc.preStoreCalled); | |
} | |
/* | |
// no JPA equivalent | |
public void testDetachAttach() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(); | |
DetachAttachEvent pc = (DetachAttachEvent) pm.find | |
(DetachAttachEvent.class,createDetachableId(4)); | |
DetachAttachEvent.EVENTS.clear(); | |
pc = (DetachAttachEvent) pm.detach(pc); | |
assertDetachEvents(new String[]{ "PRED4", "POSTD4" }); | |
endEm(pm,()); | |
assertTrue(pm.isDetached(pc)); | |
pm = getPM(); | |
startTx(pm,()); | |
//FIXME jthomas | |
// pm.addInstanceLifecycleListener(new CreateLifecycleListener() { | |
// public void postCreate(InstanceLifecycleEvent ev) { | |
// fail("No post create necessary"); | |
// } | |
// }, null); | |
pm.persist(pc); | |
assertDetachEvents(new String[]{ "PREA4", "POSTA4" }); | |
endTx(pm,()); | |
endEm(pm,()); | |
} | |
public void testDetachAttachRelations() { | |
OpenJPAEntityManager pm = getPM(); | |
startTx(pm,()); | |
DetachAttachEvent pc = (DetachAttachEvent) pm.find | |
(DetachAttachEvent.class,createDetachableId(2)); | |
pc.setOneOne((DetachAttachEvent) pm.find | |
(DetachAttachEvent.class,createDetachableId(4))); | |
endTx(pm,()); | |
DetachAttachEvent.EVENTS.clear(); | |
pc = (DetachAttachEvent) pm.detach(pc); | |
endEm(pm,()); | |
assertDetachEvents( | |
new String[]{ "PRED2", "PRED4", "POSTD2", "POSTD4" }); | |
pm = getPM(); | |
startTx(pm,()); | |
pm.persist(pc); | |
assertDetachEvents( | |
new String[]{ "PREA2", "PREA4", "POSTA2", "POSTA4" }); | |
rollbackTx(pm,()); | |
endEm(pm,()); | |
} | |
private void assertDetachEvents(String[] expected) { | |
Collection events = DetachAttachEvent.EVENTS; | |
if (expected.length != events.size()) { | |
StringBuffer buf = new StringBuffer(); | |
for (int i = 0; i < expected.length; i++) | |
buf.append(expected[i]).append(","); | |
buf.append("!="); | |
for (Iterator it = events.iterator(); it.hasNext();) | |
buf.append(it.next()).append(","); | |
fail("mismatch event count:" + buf); | |
} | |
String event; | |
for (int i = 0; i < expected.length; i++) { | |
if (!events.remove(expected[i])) | |
fail("Event not fired:" + expected[i]); | |
if (events.contains(expected[i])) | |
fail("Event fired twice:" + expected[i]); | |
} | |
if (!events.isEmpty()) | |
fail("Excess events fired:" + events); | |
DetachAttachEvent.EVENTS.clear(); | |
} | |
private Object createDetachableId(int field) { | |
OpenJPAEntityManager pm = getPM(); | |
startTx(pm,()); | |
DetachAttachEvent pc = new DetachAttachEvent(); | |
pc.setIntField(field); | |
pm.persist(pc); | |
endTx(pm,()); | |
endEm(pm,()); | |
// return pm.getObjectId(pc); | |
return pc.getId(); | |
} | |
*/ | |
} |