001: /*
002: * TestSavepoints.java
003: *
004: * Created on October 16, 2006, 11:16 AM
005: *
006: * To change this template, choose Tools | Template Manager
007: * and open the template in the editor.
008: */
009: /*
010: * Licensed to the Apache Software Foundation (ASF) under one
011: * or more contributor license agreements. See the NOTICE file
012: * distributed with this work for additional information
013: * regarding copyright ownership. The ASF licenses this file
014: * to you under the Apache License, Version 2.0 (the
015: * "License"); you may not use this file except in compliance
016: * with the License. You may obtain a copy of the License at
017: *
018: * http://www.apache.org/licenses/LICENSE-2.0
019: *
020: * Unless required by applicable law or agreed to in writing,
021: * software distributed under the License is distributed on an
022: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
023: * KIND, either express or implied. See the License for the
024: * specific language governing permissions and limitations
025: * under the License.
026: */
027: package org.apache.openjpa.persistence.kernel;
028:
029: import java.util.Iterator;
030: import java.util.Properties;
031:
032: import org.apache.openjpa.persistence.kernel.common.apps.ModRuntimeTest1;
033: import org.apache.openjpa.persistence.kernel.common.apps.RuntimeTest4;
034: import org.apache.openjpa.persistence.kernel.common.apps.RuntimeTest5;
035:
036: import org.apache.openjpa.kernel.PCState;
037: import org.apache.openjpa.persistence.JPAFacadeHelper;
038: import org.apache.openjpa.persistence.OpenJPAEntityManager;
039: import org.apache.openjpa.persistence.OpenJPAPersistence;
040:
041: public class TestSavepoints extends BaseKernelTest {
042:
043: /**
044: * Creates a new instance of TestSavepoints
045: */
046: public TestSavepoints(String name) {
047: super (name);
048: }
049:
050: protected String getSavepointPlugin() {
051: return "in-mem";
052: }
053:
054: public Properties getProperties(String[] props) {
055: Properties properties = super .getProperties(props);
056: properties
057: .put("openjpa.SavepointManager", getSavepointPlugin());
058: return properties;
059: }
060:
061: public void setUp() {
062: deleteAll(ModRuntimeTest1.class);
063: deleteAll(RuntimeTest4.class);
064: deleteAll(RuntimeTest5.class);
065: }
066:
067: public void testSimple() {
068: doSimpleTest(true, 0, 0);
069: doSimpleTest(true, 2, 0);
070: doSimpleTest(true, 0, 2);
071: doSimpleTest(false, 0, 0);
072: doSimpleTest(false, 2, 0);
073: doSimpleTest(false, 0, 2);
074: }
075:
076: private void doSimpleTest(boolean newPC, int before, int after) {
077: OpenJPAEntityManager pm = getPM();
078: ModRuntimeTest1 pc = new ModRuntimeTest1();
079: startTx(pm);
080: pc.setStringField("orig");
081: pc.setIntField(-11);
082: //FIXME jthomas - setDateField
083: //pc.setDateField(randomDate());
084: pm.persist(pc);
085: Object oid = pm.getObjectId(pc);
086:
087: if (!newPC) {
088: endTx(pm);
089: pm = getPM();
090: startTx(pm);
091: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
092: }
093: for (int i = 0; i < before; i++) {
094: pc.setStringField("before" + i);
095: pc.setIntField(i);
096: //FIXME jthomas - setDateField
097: //pc.setDateField(randomDate());
098: pm.setSavepoint("before" + i);
099: }
100:
101: pc.setStringField("value");
102: pc.setIntField(333);
103: //FIXME jthomas - setDateField
104: //pc.setDateField(randomDate());
105: //Date date = (Date) pc.getDateField().clone();
106: pm.setSavepoint("test");
107:
108: for (int i = 0; i < after; i++) {
109: pc.setStringField("after" + i);
110: pc.setIntField(i * 10);
111: //FIXME jthomas - setDateField
112: //pc.setDateField(randomDate());
113: pm.setSavepoint("after" + i);
114: }
115:
116: pm.rollbackToSavepoint("test");
117: assertEquals("value", pc.getStringField());
118: assertEquals(333, pc.getIntField());
119: //FIXME jthomas - setDateField
120: //assertEquals(date, pc.getDateField());
121: endTx(pm);
122: endEm(pm);
123:
124: pm = getPM();
125: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
126: assertEquals("value", pc.getStringField());
127: assertEquals(333, pc.getIntField());
128: //FIXME jthomas - setDateField
129: //assertEquals(date, pc.getDateField());
130: endEm(pm);
131: }
132:
133: public void testCleanOrdering() {
134: OpenJPAEntityManager pm = getPM();
135: ModRuntimeTest1 pc = new ModRuntimeTest1("orig", 1);
136: startTx(pm);
137: pm.persist(pc);
138: Object oid = pm.getObjectId(pc);
139: endTx(pm);
140: endEm(pm);
141:
142: pm = getPM();
143: pm.setOptimistic(false);
144: startTx(pm);
145: ModRuntimeTest1 pc2 = new ModRuntimeTest1("foo", 2);
146: pm.persist(pc2);
147: pm.setSavepoint("s1");
148: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
149: assertTrue(pm.isTransactional(pc));
150: pm.setSavepoint("s2");
151: pc.setStringField("bar");
152: pm.rollbackToSavepoint("s2");
153: assertEquals("orig", pc.getStringField());
154: assertTrue(pm.isTransactional(pc));
155:
156: rollbackTx(pm);
157: endEm(pm);
158: }
159:
160: public void testLastSavepoint() {
161: OpenJPAEntityManager pm = getPM();
162: ModRuntimeTest1 pc = new ModRuntimeTest1("orig", 1);
163: startTx(pm);
164: pm.persist(pc);
165: Object oid = pm.getObjectId(pc);
166: endTx(pm);
167: endEm(pm);
168:
169: pm = getPM();
170: pm.setOptimistic(false);
171: startTx(pm);
172: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
173: pc.setStringField("s1");
174: pm.setSavepoint("s1");
175: pc.setStringField("s2");
176: pm.setSavepoint("s2");
177: pc.setStringField("diff");
178: pm.rollbackToSavepoint();
179: assertEquals("s2", pc.getStringField());
180: pm.releaseSavepoint();
181: try {
182: pm.rollbackToSavepoint("s1");
183: fail("Exhausted.");
184: } catch (Exception e) {
185: }
186: rollbackTx(pm);
187: endEm(pm);
188: }
189:
190: public void testNewRollback() {
191: doNewRollbackTest(false, 0, 0);
192: doNewRollbackTest(false, 2, 0);
193: doNewRollbackTest(false, 0, 2);
194: doNewRollbackTest(true, 0, 0);
195: doNewRollbackTest(true, 2, 0);
196: doNewRollbackTest(true, 0, 2);
197: }
198:
199: public void doNewRollbackTest(boolean restore, int before, int after) {
200: OpenJPAEntityManager pm = getPM();
201: pm.setRetainState(restore);
202: startTx(pm);
203:
204: for (int i = 0; i < before; i++) {
205: pm.persist(new ModRuntimeTest1("s" + i, i));
206: //pm.setSavepoint("before" + i);
207: }
208: pm.setSavepoint("test");
209:
210: ModRuntimeTest1 pc = new ModRuntimeTest1();
211: pc.setStringField("orig");
212: pm.persist(pc);
213: Object oid = pm.getObjectId(pc);
214:
215: for (int i = 0; i < after; i++) {
216: pm.persist(new ModRuntimeTest1());
217: pm.setSavepoint("after" + i);
218: }
219:
220: pm.rollbackToSavepoint("test");
221: assertEquals("orig", pc.getStringField());
222: assertFalse(pm.isPersistent(pc));
223: assertEquals(before, pm.getTransactionalObjects().size());
224: endTx(pm);
225: endEm(pm);
226:
227: pm = getPM();
228: assertNull(pm.find(ModRuntimeTest1.class, oid));
229: endEm(pm);
230: }
231:
232: public void testNewRelation() {
233: doNewRelationTest(true, 0, 0);
234: doNewRelationTest(true, 2, 0);
235: doNewRelationTest(true, 0, 2);
236: doNewRelationTest(false, 0, 0);
237: doNewRelationTest(false, 2, 0);
238: doNewRelationTest(false, 0, 2);
239: }
240:
241: public void doNewRelationTest(boolean nullRel, int before, int after) {
242: deleteAll(ModRuntimeTest1.class);
243:
244: OpenJPAEntityManager pm = getPM();
245: startTx(pm);
246: ModRuntimeTest1 pc = new ModRuntimeTest1();
247: pc.setStringField("orig");
248: if (!nullRel)
249: pc.setSelfOneOne(new ModRuntimeTest1("one", 1));
250: pm.persist(pc);
251: Object oid = pm.getObjectId(pc);
252: endTx(pm);
253: endEm(pm);
254:
255: pm = getPM();
256: pm.setRetainState(true);
257: startTx(pm);
258: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
259:
260: for (int i = 0; i < before; i++) {
261: pc.setSelfOneOne(new ModRuntimeTest1("before" + i, i));
262: pm.setSavepoint("before" + i);
263: }
264:
265: pm.setSavepoint("test");
266: pc.setSelfOneOne(new ModRuntimeTest1("new", 2));
267: ModRuntimeTest1 pc2 = pc.getSelfOneOne();
268:
269: for (int i = 0; i < after; i++) {
270: pc.setSelfOneOne(new ModRuntimeTest1());
271: pm.setSavepoint("after" + i);
272: }
273:
274: pm.rollbackToSavepoint("test");
275: assertEquals("orig", pc.getStringField());
276: assertFalse(pm.isPersistent(pc2));
277: if (before > 0)
278: assertEquals("before" + (before - 1), pc.getSelfOneOne()
279: .getStringField());
280: else {
281: if (nullRel)
282: assertNull(pc.getSelfOneOne());
283: else
284: assertEquals("one", pc.getSelfOneOne().getStringField());
285: }
286: endTx(pm);
287: endEm(pm);
288:
289: pm = getPM();
290: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
291: assertEquals("orig", pc.getStringField());
292: if (before > 0)
293: assertEquals("before" + (before - 1), pc.getSelfOneOne()
294: .getStringField());
295: else {
296: if (nullRel)
297: assertNull(pc.getSelfOneOne());
298: else
299: assertEquals("one", pc.getSelfOneOne().getStringField());
300: }
301: endEm(pm);
302: }
303:
304: public void testNullRelation() {
305: doNullRelationTest(true, 0, 0);
306: doNullRelationTest(true, 2, 0);
307: doNullRelationTest(true, 0, 2);
308: doNullRelationTest(false, 0, 0);
309: doNullRelationTest(false, 2, 0);
310: doNullRelationTest(false, 0, 2);
311: }
312:
313: public void doNullRelationTest(boolean retain, int before, int after) {
314: OpenJPAEntityManager pm = getPM();
315: startTx(pm);
316: ModRuntimeTest1 pc = new ModRuntimeTest1();
317: pc.setStringField("orig");
318: pc.setSelfOneOne(new ModRuntimeTest1("one", 1));
319: pm.persist(pc);
320: Object oid = pm.getObjectId(pc);
321: endTx(pm);
322: endEm(pm);
323:
324: pm = getPM();
325: pm.setRetainState(true);
326: startTx(pm);
327: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
328:
329: for (int i = 0; i < before; i++) {
330: pc.setSelfOneOne(new ModRuntimeTest1("before" + i, i));
331: pm.setSavepoint("before" + i);
332: }
333:
334: pm.setSavepoint("test");
335: pc.setSelfOneOne(null);
336:
337: for (int i = 0; i < after; i++) {
338: pc.setSelfOneOne(new ModRuntimeTest1());
339: pm.setSavepoint("after" + i);
340: }
341:
342: pm.rollbackToSavepoint("test");
343: assertEquals("orig", pc.getStringField());
344: if (before > 0)
345: assertEquals("before" + (before - 1), pc.getSelfOneOne()
346: .getStringField());
347: else
348: assertEquals("one", pc.getSelfOneOne().getStringField());
349: endTx(pm);
350: endEm(pm);
351:
352: pm = getPM();
353: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
354: assertEquals("orig", pc.getStringField());
355: if (before > 0)
356: assertEquals("before" + (before - 1), pc.getSelfOneOne()
357: .getStringField());
358: else
359: assertEquals("one", pc.getSelfOneOne().getStringField());
360: endEm(pm);
361: }
362:
363: public void testCollection() {
364: doCollectionTest(true, 0, 0);
365: doCollectionTest(true, 2, 0);
366: doCollectionTest(true, 0, 2);
367: doCollectionTest(false, 0, 0);
368: doCollectionTest(false, 2, 0);
369: doCollectionTest(false, 0, 2);
370: }
371:
372: public void doCollectionTest(boolean newPC, int before, int after) {
373: OpenJPAEntityManager pm = getPM();
374: startTx(pm);
375: ModRuntimeTest1 pc = new ModRuntimeTest1("orig", 1);
376: ModRuntimeTest1 pc2 = newElement(pc, "persist", 2);
377: ModRuntimeTest1 pc3 = newElement(pc, "delete", 3);
378: pm.persist(pc);
379: pm.persist(pc3);
380: Object oid = pm.getObjectId(pc);
381: ModRuntimeTest1 temp;
382: if (!newPC) {
383: endTx(pm);
384: endEm(pm);
385:
386: pm = getPM();
387: startTx(pm);
388: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
389: assertEquals(2, pc.getSelfOneMany().size());
390: for (Iterator it = pc.getSelfOneMany().iterator(); it
391: .hasNext();) {
392: temp = (ModRuntimeTest1) it.next();
393: if (temp.getIntField() == 2)
394: pc2 = temp;
395: else if (temp.getIntField() == 3)
396: pc3 = temp;
397: else
398: fail("unknown");
399: }
400: }
401:
402: for (int i = 0; i < before; i++) {
403: newElement(pc, "before" + i, (i + 1) * 10);
404: pm.setSavepoint("before" + i);
405: }
406: pm.setSavepoint("test");
407: pm.remove(pc3);
408: pc.getSelfOneMany().remove(pc2);
409:
410: // kodo 4 is more stringent on deleted relations.
411: pc.getSelfOneMany().remove(pc3);
412: pc2.setSelfOneMany(null);
413:
414: for (int i = 0; i < after; i++) {
415: newElement(pc, "after" + i, (i + 1) * -10);
416: pm.setSavepoint("after" + i);
417: }
418:
419: pm.rollbackToSavepoint("test");
420:
421: assertEquals("orig", pc.getStringField());
422: assertFalse(pm.isRemoved(pc2));
423: for (Iterator it = pc.getSelfOneMany().iterator(); it.hasNext();) {
424: temp = (ModRuntimeTest1) it.next();
425: assertFalse(pm.isRemoved(temp));
426: assertEquals(pc, temp.getSelfOneOne());
427: if (temp.getIntField() < 0)
428: fail("shouldn't be here:" + temp.getStringField());
429: }
430: assertTrue(pc.getSelfOneMany().contains(pc2));
431: assertTrue(pc.getSelfOneMany().contains(pc3));
432: assertEquals(2 + before, pc.getSelfOneMany().size());
433: endTx(pm);
434: endEm(pm);
435:
436: pm = getPM();
437: pc = (ModRuntimeTest1) pm.find(ModRuntimeTest1.class, oid);
438: assertEquals("orig", pc.getStringField());
439: assertEquals(2 + before, pc.getSelfOneMany().size());
440: boolean found2 = false;
441: boolean found3 = false;
442: for (Iterator it = pc.getSelfOneMany().iterator(); it.hasNext();) {
443: temp = (ModRuntimeTest1) it.next();
444: assertEquals(pc, temp.getSelfOneOne());
445: if (temp.getIntField() < 0)
446: fail("shouldn't be here:" + temp.getStringField());
447: else if (temp.getIntField() == 2)
448: found2 = true;
449: else if (temp.getIntField() == 3)
450: found3 = true;
451: }
452: assertTrue(found2 && found3);
453: endEm(pm);
454: }
455:
456: public void testChangeTracker() {
457: OpenJPAEntityManager pm = getPM();
458: startTx(pm);
459: RuntimeTest4 pc = new RuntimeTest4("orig");
460: for (int i = 0; i < 12; i++)
461: pc.getRuntimeTest5s().add(new RuntimeTest5("five" + i));
462: pm.persist(pc);
463: Object oid = pm.getObjectId(pc);
464: endTx(pm);
465: endEm(pm);
466:
467: pm = getPM();
468: startTx(pm);
469: pc = (RuntimeTest4) pm.find(RuntimeTest4.class, oid);
470: assertEquals(12, pc.getRuntimeTest5s().size());
471: int count = 0;
472: for (Iterator i = pc.getRuntimeTest5s().iterator(); count < 2; count++) {
473: i.next();
474: i.remove();
475: }
476: assertEquals(10, pc.getRuntimeTest5s().size());
477: pm.setSavepoint("test");
478: count = 0;
479: for (Iterator i = pc.getRuntimeTest5s().iterator(); count < 2; count++) {
480: i.next();
481: i.remove();
482: }
483: assertEquals(8, pc.getRuntimeTest5s().size());
484: endTx(pm);
485: endEm(pm);
486:
487: pm = getPM();
488: pc = (RuntimeTest4) pm.find(RuntimeTest4.class, oid);
489: assertEquals(8, pc.getRuntimeTest5s().size());
490: endEm(pm);
491: }
492:
493: private ModRuntimeTest1 newElement(ModRuntimeTest1 one, String str,
494: int i) {
495: ModRuntimeTest1 two = new ModRuntimeTest1(str, i);
496: two.setSelfOneOne(one);
497: one.getSelfOneMany().add(two);
498: return two;
499: }
500:
501: public static PCState getState(Object o) {
502: OpenJPAEntityManager pm = OpenJPAPersistence
503: .getEntityManager(o);
504:
505: if (pm == null)
506: return null;
507: return JPAFacadeHelper.toBroker(pm).getStateManager(o)
508: .getPCState();
509: }
510: }
|