001: /*
002: * TestSavepointEmbedded.java
003: *
004: * Created on October 16, 2006, 10:29 AM
005: *
006: * To change this template, choose Tools | Template Manager
007: * and open the template in the editor.
008: */
009:
010: /*
011: * Licensed to the Apache Software Foundation (ASF) under one
012: * or more contributor license agreements. See the NOTICE file
013: * distributed with this work for additional information
014: * regarding copyright ownership. The ASF licenses this file
015: * to you under the Apache License, Version 2.0 (the
016: * "License"); you may not use this file except in compliance
017: * with the License. You may obtain a copy of the License at
018: *
019: * http://www.apache.org/licenses/LICENSE-2.0
020: *
021: * Unless required by applicable law or agreed to in writing,
022: * software distributed under the License is distributed on an
023: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
024: * KIND, either express or implied. See the License for the
025: * specific language governing permissions and limitations
026: * under the License.
027: */
028: package org.apache.openjpa.persistence.kernel;
029:
030: import java.util.Properties;
031:
032: import org.apache.openjpa.persistence.kernel.common.apps.EmbeddedOwnerPC;
033: import org.apache.openjpa.persistence.kernel.common.apps.EmbeddedPC;
034:
035: import org.apache.openjpa.persistence.OpenJPAEntityManager;
036:
037: public class TestSavepointEmbedded extends BaseKernelTest {
038:
039: private int id = 10000;
040:
041: /**
042: * Creates a new instance of TestSavepointEmbedded
043: */
044: public TestSavepointEmbedded(String name) {
045: super (name);
046: }
047:
048: protected String getSavepointPlugin() {
049: return "in-mem(PreFlush=false)";
050: }
051:
052: protected boolean expectNewEmbeddedFailure() {
053: return true;
054: }
055:
056: public Properties getProperties(String[] props) {
057: Properties properties = super .getProperties(props);
058: properties
059: .put("openjpa.SavepointManager", getSavepointPlugin());
060: return properties;
061: }
062:
063: public void setUp() {
064: deleteAll(EmbeddedOwnerPC.class);
065: }
066:
067: private EmbeddedOwnerPC newEmbeddedOwnerPC() {
068: return new EmbeddedOwnerPC(id++, id++);
069: }
070:
071: public void testClearNew() throws Exception {
072: doClearNewTest(true, 0, 0);
073: doClearNewTest(true, 2, 0);
074: doClearNewTest(true, 0, 2);
075: doClearNewTest(true, 2, 2);
076: doClearNewTest(false, 0, 0);
077: doClearNewTest(false, 2, 0);
078: doClearNewTest(false, 0, 2);
079: doClearNewTest(false, 2, 2);
080: }
081:
082: public void doClearNewTest(boolean newPC, int before, int after)
083: throws Exception {
084: deleteAll(EmbeddedOwnerPC.class);
085: OpenJPAEntityManager pm = getPM();
086: startTx(pm);
087: EmbeddedOwnerPC pc = newEmbeddedOwnerPC();
088: pm.persist(pc);
089: pc.setStringField("orig");
090: Object oid = pm.getObjectId(pc);
091: if (!newPC) {
092: endTx(pm);
093: endEm(pm);
094: pm = getPM();
095: startTx(pm);
096: pc = (EmbeddedOwnerPC) pm.find(EmbeddedOwnerPC.class, oid);
097: }
098: for (int i = 0; i < before; i++) {
099: pc.setStringField("b" + i);
100: pm.setSavepoint("b" + i);
101: }
102:
103: pc.setStringField("test");
104: pm.setSavepoint("test");
105: EmbeddedPC embed = new EmbeddedPC();
106: embed.setIntField(99);
107: pc.setEmbedded(embed);
108:
109: for (int i = 0; i < after; i++) {
110: pc.setStringField("a" + i);
111: pm.setSavepoint("a" + i);
112: }
113:
114: pm.rollbackToSavepoint("test");
115: if (newPC)
116: assertNull(pc.getEmbedded());
117: else
118: assertEquals(0, pc.getEmbedded().getIntField());
119: assertEquals("test", pc.getStringField());
120: endTx(pm);
121: endEm(pm);
122: }
123:
124: public void testEmbeddedReassign() {
125: doEmbeddedReassignTest(true, 0, 0);
126: doEmbeddedReassignTest(true, 2, 0);
127: doEmbeddedReassignTest(true, 0, 2);
128: doEmbeddedReassignTest(true, 2, 2);
129: doEmbeddedReassignTest(false, 0, 0);
130: doEmbeddedReassignTest(false, 2, 0);
131: doEmbeddedReassignTest(false, 0, 2);
132: doEmbeddedReassignTest(false, 2, 2);
133: }
134:
135: public void doEmbeddedReassignTest(boolean newPC, int before,
136: int after) {
137: deleteAll(EmbeddedOwnerPC.class);
138: deleteAll(EmbeddedPC.class);
139:
140: OpenJPAEntityManager pm = getPM();
141: startTx(pm);
142: EmbeddedOwnerPC pc = newEmbeddedOwnerPC();
143: EmbeddedPC embed = new EmbeddedPC();
144: embed.setIntField1(1000);
145: pc.setStringField("orig");
146: pm.persist(pc);
147: pc.setEmbedded(embed);
148:
149: Object oid = pm.getObjectId(pc);
150: if (!newPC) {
151: endTx(pm);
152: endEm(pm);
153: pm = getPM();
154: startTx(pm);
155: pc = (EmbeddedOwnerPC) pm.find(EmbeddedOwnerPC.class, oid);
156: }
157: for (int i = 0; i < before; i++) {
158: pc.setStringField("b" + i);
159: pm.setSavepoint("b" + i);
160: }
161:
162: pm.setSavepoint("test");
163: embed = new EmbeddedPC();
164: embed.setIntField1(2000);
165: pc.setEmbedded(embed);
166:
167: for (int i = 0; i < after; i++) {
168: pc.setStringField("b" + i);
169: pm.setSavepoint("a" + i);
170: }
171:
172: pm.rollbackToSavepoint("test");
173: assertNotNull(pc.getEmbedded());
174: assertEquals(1000, pc.getEmbedded().getIntField1());
175: endTx(pm);
176: endEm(pm);
177: }
178:
179: public void testEmbeddedChange() throws Exception {
180: try {
181: doEmbeddedChangeTest(true, 0, 0);
182: doEmbeddedChangeTest(true, 2, 0);
183: doEmbeddedChangeTest(true, 0, 2);
184: doEmbeddedChangeTest(true, 2, 2);
185: } catch (Throwable t) {
186: if (expectNewEmbeddedFailure())
187: bug(1141, t, "changes to new embedded not detected");
188: else
189: throw (Exception) t;
190: }
191: doEmbeddedChangeTest(false, 0, 0);
192: doEmbeddedChangeTest(false, 2, 0);
193: doEmbeddedChangeTest(false, 0, 2);
194: doEmbeddedChangeTest(false, 2, 2);
195: }
196:
197: public void doEmbeddedChangeTest(boolean newPC, int before,
198: int after) {
199: deleteAll(EmbeddedOwnerPC.class);
200: OpenJPAEntityManager pm = getPM();
201: startTx(pm);
202: EmbeddedOwnerPC pc = newEmbeddedOwnerPC();
203: EmbeddedPC embed = new EmbeddedPC();
204: embed.setIntField1(1000);
205: pc.setStringField("orig");
206: pm.persist(pc);
207: pc.setEmbedded(embed);
208:
209: Object oid = pm.getObjectId(pc);
210: if (!newPC) {
211: endTx(pm);
212: endEm(pm);
213: pm = getPM();
214: startTx(pm);
215: pc = (EmbeddedOwnerPC) pm.find(EmbeddedOwnerPC.class, oid);
216: }
217: for (int i = 0; i < before; i++) {
218: pc.setStringField("b" + i);
219: pm.setSavepoint("b" + i);
220: }
221:
222: pm.setSavepoint("test");
223: pc.getEmbedded().setIntField1(2000);
224:
225: for (int i = 0; i < after; i++) {
226: pc.setStringField("a" + i);
227: pm.setSavepoint("a" + i);
228: }
229:
230: pm.rollbackToSavepoint("test");
231: assertNotNull(pc.getEmbedded());
232: assertEquals(1000, pc.getEmbedded().getIntField1());
233: endTx(pm);
234: endEm(pm);
235: }
236:
237: public void testEmbeddedChange2() throws Exception {
238: try {
239: doEmbeddedChangeTest2(true, 0, 0);
240: doEmbeddedChangeTest2(true, 2, 0);
241: doEmbeddedChangeTest2(true, 0, 2);
242: doEmbeddedChangeTest2(true, 2, 2);
243: } catch (Throwable t) {
244: if (expectNewEmbeddedFailure())
245: bug(1141, t, "changes to new embedded not detected");
246: else
247: throw (Exception) t;
248: }
249: doEmbeddedChangeTest2(false, 0, 0);
250: doEmbeddedChangeTest2(false, 2, 0);
251: doEmbeddedChangeTest2(false, 0, 2);
252: doEmbeddedChangeTest2(false, 2, 2);
253: }
254:
255: // variation with changing embedde fields vs owner field
256: public void doEmbeddedChangeTest2(boolean newPC, int before,
257: int after) {
258: deleteAll(EmbeddedOwnerPC.class);
259: deleteAll(EmbeddedPC.class);
260: OpenJPAEntityManager pm = getPM();
261: startTx(pm);
262: EmbeddedOwnerPC pc = newEmbeddedOwnerPC();
263: EmbeddedPC embed = new EmbeddedPC();
264: embed.setIntField1(1000);
265: pc.setStringField("orig");
266: pm.persist(pc);
267: pc.setEmbedded(embed);
268:
269: Object oid = pm.getObjectId(pc);
270: if (!newPC) {
271: endTx(pm);
272: endEm(pm);
273: pm = getPM();
274: startTx(pm);
275: pc = (EmbeddedOwnerPC) pm.find(EmbeddedOwnerPC.class, oid);
276: }
277: for (int i = 0; i < before; i++) {
278: pc.getEmbedded().setIntField1(i);
279: pm.setSavepoint("b" + i);
280: }
281:
282: pm.setSavepoint("test");
283: pc.getEmbedded().setIntField1(2000);
284:
285: for (int i = 0; i < after; i++) {
286: pc.getEmbedded().setIntField1(i * -1);
287: pm.setSavepoint("a" + i);
288: }
289:
290: pm.rollbackToSavepoint("test");
291: assertNotNull(pc.getEmbedded());
292: if (before == 0)
293: assertEquals(1000, pc.getEmbedded().getIntField1());
294: else
295: assertEquals(before - 1, pc.getEmbedded().getIntField1());
296: endTx(pm);
297: endEm(pm);
298: }
299: }
|