/tests/com/google/appengine/datanucleus/jdo/JDOTransactionTest.java

  1/**********************************************************************
  2Copyright (c) 2009 Google Inc.
  3
  4Licensed under the Apache License, Version 2.0 (the "License");
  5you may not use this file except in compliance with the License.
  6You may obtain a copy of the License at
  7
  8http://www.apache.org/licenses/LICENSE-2.0
  9
 10Unless required by applicable law or agreed to in writing, software
 11distributed under the License is distributed on an "AS IS" BASIS,
 12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13See the License for the specific language governing permissions and
 14limitations under the License.
 15**********************************************************************/
 16package com.google.appengine.datanucleus.jdo;
 17
 18import com.google.appengine.api.datastore.DatastoreService;
 19import com.google.appengine.api.datastore.DatastoreServiceFactory;
 20import com.google.appengine.api.datastore.Entity;
 21import com.google.appengine.api.datastore.EntityNotFoundException;
 22import com.google.appengine.api.datastore.Key;
 23import com.google.appengine.api.datastore.KeyFactory;
 24import com.google.appengine.api.datastore.TransactionOptions;
 25import com.google.appengine.datanucleus.DatastoreServiceFactoryInternal;
 26import com.google.appengine.datanucleus.DatastoreServiceRecordingImpl;
 27import com.google.appengine.datanucleus.DatastoreTestCase;
 28import com.google.appengine.datanucleus.Inner;
 29import com.google.appengine.datanucleus.TxnIdAnswer;
 30import com.google.appengine.datanucleus.test.jdo.Flight;
 31import com.google.appengine.datanucleus.test.jdo.HasKeyAncestorKeyPkJDO;
 32
 33import org.datanucleus.api.jdo.exceptions.TransactionNotReadableException;
 34import org.datanucleus.api.jdo.exceptions.TransactionNotWritableException;
 35import org.easymock.EasyMock;
 36
 37import javax.jdo.JDOHelper;
 38import javax.jdo.PersistenceManager;
 39import javax.jdo.PersistenceManagerFactory;
 40import javax.jdo.Query;
 41import javax.jdo.Transaction;
 42
 43/**
 44 * Verifies jdo txn behavior across the following variables:
 45 * datasource type (txn | nontxn)
 46 * programmatic txn demarcation (yes | no)
 47 * operation (read | write)
 48 * support for that operation outside a txn (yes | no)
 49 * 
 50 * See https://spreadsheets.google.com/a/google.com/pub?key=p8C3zgqqUfpstFKZ4ns1bQg
 51 * for all the gory details.
 52 *
 53 * @author Erick Armbrust <earmbrust@google.com>
 54 * @author Max Ross <maxr@google.com>
 55 */
 56public class JDOTransactionTest extends DatastoreTestCase {
 57
 58  private DatastoreService mockDatastoreService = EasyMock.createMock(DatastoreService.class);
 59  private com.google.appengine.api.datastore.Transaction mockTxn = EasyMock.createMock(
 60      com.google.appengine.api.datastore.Transaction.class);
 61  private DatastoreServiceRecordingImpl recordingImpl;
 62  private TxnIdAnswer txnIdAnswer;
 63  private DatastoreService ds;
 64
 65  @Override
 66  protected void setUp() throws Exception {
 67    super.setUp();
 68    txnIdAnswer = new TxnIdAnswer();
 69    ds = DatastoreServiceFactory.getDatastoreService();
 70    recordingImpl =
 71        new DatastoreServiceRecordingImpl(mockDatastoreService, ds, mockTxn, txnIdAnswer);
 72    DatastoreServiceFactoryInternal.setDatastoreService(recordingImpl);
 73  }
 74
 75  @Override
 76  protected void tearDown() throws Exception {
 77    EasyMock.reset(mockDatastoreService, mockTxn);
 78    DatastoreServiceFactoryInternal.setDatastoreService(null);
 79    recordingImpl = null;
 80    super.tearDown();
 81  }
 82
 83  /**
 84   * A new PersistenceManagerFactory should be fetched on a per-test basis.  The
 85   * DatastoreService within the DatastorePersistenceHandler is obtained via the
 86   * DatastoreServiceFactory, so this ensures that the "injected" factory impl
 87   * is returned.
 88   */
 89  private PersistenceManagerFactory getPersistenceManagerFactory(String pmfName) {
 90    return JDOHelper.getPersistenceManagerFactory(pmfName);
 91  }
 92
 93  private void testWritePermutationWithExpectedDatastoreTxn(
 94      PersistenceManager pm, boolean explicitDemarcation,
 95      boolean nonTransactionalWrite) {
 96    EasyMock.expect(mockDatastoreService.beginTransaction(EasyMock.isA(TransactionOptions.class))).andReturn(mockTxn);
 97    EasyMock.expect(mockDatastoreService.put(
 98        EasyMock.isA(com.google.appengine.api.datastore.Transaction.class),
 99        EasyMock.isA(Entity.class))).andReturn(null);
100    EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer).anyTimes();
101    EasyMock.expect(mockTxn.isActive()).andReturn(true).anyTimes();
102    EasyMock.expect(mockTxn.getApp()).andReturn("test").anyTimes();
103    mockTxn.commit();
104    EasyMock.replay(mockDatastoreService, mockTxn);
105
106    Flight f1 = new Flight();
107    f1.setName("Harold");
108    f1.setOrigin("BOS");
109    f1.setDest("MIA");
110    f1.setYou(1);
111    f1.setMe(2);
112
113    Transaction txn = pm.currentTransaction();
114    txn.setNontransactionalWrite(nonTransactionalWrite);
115    if (explicitDemarcation) {
116      txn.begin();
117    }
118    try {
119      pm.makePersistent(f1);
120    } finally {
121      if (explicitDemarcation) {
122        txn.commit();
123      }
124    }
125    EasyMock.verify(mockDatastoreService, mockTxn);
126    EasyMock.reset(mockDatastoreService, mockTxn);
127  }
128
129  private void testUpdatePermutationWithExpectedDatastoreTxn(
130      PersistenceManagerFactory pmf, boolean explicitDemarcation, boolean nonTransactionalWrite)
131      throws EntityNotFoundException {
132    Entity flightEntity = Flight.newFlightEntity("Harold", "BOS", "MIA", 1, 2);
133    ds.put(flightEntity);
134    EasyMock.expect(mockDatastoreService.beginTransaction(EasyMock.isA(TransactionOptions.class))).andReturn(mockTxn);
135    EasyMock.expect(mockDatastoreService.get(
136        EasyMock.isA(com.google.appengine.api.datastore.Transaction.class),
137        EasyMock.isA(Key.class))).andReturn(flightEntity);
138    EasyMock.expect(mockDatastoreService.get(
139        EasyMock.isA(Key.class))).andReturn(flightEntity);
140    EasyMock.expect(mockDatastoreService.put(
141        EasyMock.isA(com.google.appengine.api.datastore.Transaction.class),
142        EasyMock.isA(Entity.class))).andReturn(null);
143    EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer).anyTimes();
144    EasyMock.expect(mockTxn.isActive()).andReturn(true).anyTimes();
145    EasyMock.expect(mockTxn.getApp()).andReturn("test").anyTimes();
146    mockTxn.commit();
147    EasyMock.replay(mockDatastoreService, mockTxn);
148
149    PersistenceManager pm = pmf.getPersistenceManager();
150    Transaction txn = pm.currentTransaction();
151    txn.setNontransactionalWrite(nonTransactionalWrite);
152    if (explicitDemarcation) {
153      txn.begin();
154    }
155    try {
156      Flight f1 = pm.getObjectById(Flight.class, KeyFactory.keyToString(flightEntity.getKey()));
157      f1.setYou(88);
158    } finally {
159      if (explicitDemarcation) {
160        txn.commit();
161      }
162      pm.close();
163    }
164    EasyMock.verify(mockDatastoreService, mockTxn);
165    EasyMock.reset(mockDatastoreService, mockTxn);
166  }
167
168  private void testReadPermutationWithExpectedDatastoreTxn(
169      PersistenceManager pm, boolean explicitDemarcation,
170      boolean nonTransactionalRead) throws EntityNotFoundException {
171
172    EasyMock.expect(mockDatastoreService.beginTransaction(EasyMock.isA(TransactionOptions.class))).andReturn(mockTxn);
173    EasyMock.expect(mockDatastoreService.get(
174        EasyMock.isA(com.google.appengine.api.datastore.Transaction.class),
175        EasyMock.isA(Key.class))).andReturn(null);
176    EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer).anyTimes();
177    EasyMock.expect(mockTxn.isActive()).andReturn(true).anyTimes();
178    EasyMock.expect(mockTxn.getApp()).andReturn("test").anyTimes();
179    mockTxn.commit();
180    EasyMock.replay(mockDatastoreService, mockTxn);
181
182    Entity f1 = Flight.newFlightEntity("foo", "bar", "baz", 1, 2);
183    ds.put(f1);
184
185    Transaction txn = pm.currentTransaction();
186    txn.setNontransactionalRead(nonTransactionalRead);
187    if (explicitDemarcation) {
188      txn.begin();
189    }
190    try {
191      pm.getObjectById(Flight.class, KeyFactory.keyToString(f1.getKey()));
192    } finally {
193      if (explicitDemarcation) {
194        txn.commit();
195      }
196    }
197
198    EasyMock.verify(mockDatastoreService, mockTxn);
199    EasyMock.reset(mockDatastoreService, mockTxn);
200  }
201
202  private void testWritePermutationWithoutExpectedDatastoreTxn(
203      PersistenceManager pm, boolean explicitDemarcation, boolean nonTransactionalOpAllowed) {
204    EasyMock.expect(mockDatastoreService.put(EasyMock.isA(Entity.class))).andReturn(null);
205    EasyMock.replay(mockDatastoreService, mockTxn);
206
207    Flight f1 = new Flight();
208    f1.setName("Harold");
209    f1.setOrigin("BOS");
210    f1.setDest("MIA");
211    f1.setYou(1);
212    f1.setMe(2);
213
214    Transaction txn = pm.currentTransaction();
215    txn.setNontransactionalWrite(nonTransactionalOpAllowed);
216    txn.setNontransactionalRead(nonTransactionalOpAllowed);
217    if (explicitDemarcation) {
218      txn.begin();
219    }
220    try {
221      pm.makePersistent(f1);
222    } finally {
223      if (explicitDemarcation) {
224        txn.commit();
225      }
226    }
227
228    EasyMock.verify(mockDatastoreService, mockTxn);
229    EasyMock.reset(mockDatastoreService, mockTxn);
230  }
231
232  private void testUpdatePermutationWithoutExpectedDatastoreTxn(
233      PersistenceManagerFactory pmf, boolean explicitDemarcation, boolean nonTransactionalOp)
234      throws EntityNotFoundException {
235    Entity flightEntity = Flight.newFlightEntity("Harold", "BOS", "MIA", 1, 2);
236    ds.put(flightEntity);
237    EasyMock.expect(mockDatastoreService.get(
238        EasyMock.isA(Key.class))).andReturn(flightEntity);
239    EasyMock.expect(mockDatastoreService.get(
240        EasyMock.isA(Key.class))).andReturn(flightEntity);
241    EasyMock.expect(mockDatastoreService.put(
242        EasyMock.isA(Entity.class))).andReturn(null);
243    EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer).anyTimes();
244    EasyMock.replay(mockDatastoreService, mockTxn);
245
246    PersistenceManager pm = pmf.getPersistenceManager();
247    Transaction txn = pm.currentTransaction();
248    txn.setNontransactionalWrite(nonTransactionalOp);
249    txn.setNontransactionalRead(nonTransactionalOp);
250    if (explicitDemarcation) {
251      txn.begin();
252    }
253    try {
254      Flight f1 = pm.getObjectById(Flight.class, KeyFactory.keyToString(flightEntity.getKey()));
255      f1.setYou(88);
256    } finally {
257      if (explicitDemarcation) {
258        txn.commit();
259      }
260      pm.close();
261    }
262    EasyMock.verify(mockDatastoreService, mockTxn);
263    EasyMock.reset(mockDatastoreService, mockTxn);
264  }
265
266  private void testReadPermutationWithoutExpectedDatastoreTxn(
267      PersistenceManager pm, boolean explicitDemarcation,
268      boolean nonTransactionalRead) throws EntityNotFoundException {
269    EasyMock.expect(mockDatastoreService.get(EasyMock.isA(Key.class))).andReturn(null);
270    EasyMock.replay(mockDatastoreService, mockTxn);
271
272    Entity f1 = Flight.newFlightEntity("foo", "bar", "baz", 1, 2);
273    ds.put(f1);
274
275    Transaction txn = pm.currentTransaction();
276    txn.setNontransactionalRead(nonTransactionalRead);
277    if (explicitDemarcation) {
278      txn.begin();
279    }
280    try {
281      pm.getObjectById(Flight.class, KeyFactory.keyToString(f1.getKey()));
282    } finally {
283      if (explicitDemarcation) {
284        txn.commit();
285      }
286    }
287    EasyMock.verify(mockDatastoreService, mockTxn);
288    EasyMock.reset(mockDatastoreService, mockTxn);
289  }
290
291  private interface QueryRunner {
292    void runQuery(PersistenceManager pm);
293    boolean isAncestor();
294  }
295
296  private void testQueryPermutationWithoutExpectedDatastoreTxn(
297      PersistenceManager pm, boolean explicitDemarcation,
298      boolean nonTransactionalRead, QueryRunner queryRunner) throws EntityNotFoundException {
299    if (queryRunner.isAncestor()) {
300      EasyMock.expect(mockDatastoreService.getCurrentTransaction(null)).andReturn(null);
301    }
302    EasyMock.expect(mockDatastoreService.prepare(
303        (com.google.appengine.api.datastore.Transaction) EasyMock.isNull(),
304        EasyMock.isA(com.google.appengine.api.datastore.Query.class))).andReturn(null);
305    EasyMock.replay(mockDatastoreService, mockTxn);
306
307    Transaction txn = pm.currentTransaction();
308    txn.setNontransactionalRead(nonTransactionalRead);
309    if (explicitDemarcation) {
310      txn.begin();
311    }
312    try {
313      queryRunner.runQuery(pm);
314    } finally {
315      if (explicitDemarcation) {
316        txn.commit();
317      }
318    }
319    EasyMock.verify(mockDatastoreService, mockTxn);
320    EasyMock.reset(mockDatastoreService, mockTxn);
321  }
322
323  private void testQueryPermutationWithExpectedDatastoreTxn(
324      PersistenceManager pm, boolean explicitDemarcation,
325      boolean nonTransactionalRead, QueryRunner queryRunner) throws EntityNotFoundException {
326
327    EasyMock.expect(mockDatastoreService.beginTransaction(EasyMock.isA(TransactionOptions.class))).andReturn(mockTxn);
328    if (queryRunner.isAncestor()) {
329      EasyMock.expect(mockDatastoreService.getCurrentTransaction(null)).andReturn(mockTxn);
330    }
331    if (queryRunner.isAncestor()) {
332      EasyMock.expect(mockDatastoreService.prepare(
333          EasyMock.isA(com.google.appengine.api.datastore.Transaction.class),
334          EasyMock.isA(com.google.appengine.api.datastore.Query.class))).andReturn(null);
335      EasyMock.expect(mockTxn.isActive()).andReturn(true).times(3);
336    } else {
337      EasyMock.expect(mockDatastoreService.prepare(
338          (com.google.appengine.api.datastore.Transaction) EasyMock.isNull(),
339          EasyMock.isA(com.google.appengine.api.datastore.Query.class))).andReturn(null);
340    }
341    EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer).anyTimes();
342    EasyMock.expect(mockTxn.getApp()).andReturn("test").anyTimes();
343    mockTxn.commit();
344    EasyMock.replay(mockDatastoreService, mockTxn);
345
346    Transaction txn = pm.currentTransaction();
347    txn.setNontransactionalRead(nonTransactionalRead);
348    if (explicitDemarcation) {
349      txn.begin();
350    }
351    try {
352      queryRunner.runQuery(pm);
353    } finally {
354      if (explicitDemarcation) {
355        txn.commit();
356      }
357    }
358
359    EasyMock.verify(mockDatastoreService, mockTxn);
360    EasyMock.reset(mockDatastoreService, mockTxn);
361  }
362
363
364  private void testIllegalWritePermutation(
365      PersistenceManager pm, boolean explicitDemarcation, boolean nonTransactionalWrite) {
366
367    EasyMock.replay(mockDatastoreService, mockTxn);
368
369    Flight f1 = new Flight();
370    f1.setName("Harold");
371    f1.setOrigin("BOS");
372    f1.setDest("MIA");
373    f1.setYou(1);
374    f1.setMe(2);
375
376    Transaction txn = pm.currentTransaction();
377    txn.setNontransactionalWrite(nonTransactionalWrite);
378    if (explicitDemarcation) {
379      txn.begin();
380    }
381    try {
382      pm.makePersistent(f1);
383      fail("Expected exception");
384    } catch (TransactionNotWritableException e) {
385      // good
386    }
387    EasyMock.verify(mockDatastoreService, mockTxn);
388    EasyMock.reset(mockDatastoreService, mockTxn);
389  }
390
391  private void testIllegalUpdatePermutation(
392      PersistenceManagerFactory pmf, boolean explicitDemarcation, boolean nonTransactionalOp)
393      throws EntityNotFoundException {
394    Entity flightEntity = Flight.newFlightEntity("Harold", "BOS", "MIA", 1, 2);
395    ds.put(flightEntity);
396    EasyMock.replay(mockDatastoreService, mockTxn);
397
398    PersistenceManager pm = pmf.getPersistenceManager();
399    Transaction txn = pm.currentTransaction();
400    txn.setNontransactionalWrite(nonTransactionalOp);
401    txn.setNontransactionalRead(nonTransactionalOp);
402    if (explicitDemarcation) {
403      txn.begin();
404    }
405    try {
406      /*Flight f =*/ pm.getObjectById(Flight.class, KeyFactory.keyToString(flightEntity.getKey()));
407      fail("expected exception");
408    } catch (TransactionNotReadableException tnre) {
409      // good
410    } finally {
411      if (explicitDemarcation) {
412        txn.commit();
413      }
414      pm.close();
415    }
416    EasyMock.verify(mockDatastoreService, mockTxn);
417    EasyMock.reset(mockDatastoreService, mockTxn);
418
419  }
420
421  private void testIllegalReadPermutation(
422      PersistenceManager pm, boolean explicitDemarcation,
423      boolean nonTransactionalRead) throws EntityNotFoundException {
424
425    EasyMock.replay(mockDatastoreService, mockTxn);
426
427    Entity f1 = Flight.newFlightEntity("foo", "bar", "baz", 1, 2);
428    ds.put(f1);
429
430    Transaction txn = pm.currentTransaction();
431    txn.setNontransactionalRead(nonTransactionalRead);
432    if (explicitDemarcation) {
433      txn.begin();
434    }
435    try {
436      pm.getObjectById(Flight.class, KeyFactory.keyToString(f1.getKey()));
437      fail("Expected exception");
438    } catch (TransactionNotReadableException e) {
439      // good
440    }
441    EasyMock.verify(mockDatastoreService, mockTxn);
442    EasyMock.reset(mockDatastoreService, mockTxn);
443  }
444
445  private static final boolean EXPLICIT_DEMARCATION = true;
446  private static final boolean NO_EXPLICIT_DEMARCATION = false;
447  private static final boolean NON_TXN_OP_ALLOWED = true;
448  private static final boolean NON_TXN_OP_NOT_ALLOWED = false;
449
450  public void testWritesWithDatastoreTxn() throws Exception {
451    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
452        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
453    PersistenceManager pm = pmf.getPersistenceManager();
454    testWritePermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
455    testWritePermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
456    pm.close();
457    pmf.close();
458  }
459
460  public void testUpdatesWithDatastoreTxn() throws Exception {
461    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
462        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
463    testUpdatePermutationWithExpectedDatastoreTxn(pmf, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
464    testUpdatePermutationWithExpectedDatastoreTxn(pmf, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
465    pmf.close();
466  }
467
468  public void testReadsWithDatastoreTxn() throws Exception {
469    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
470        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
471    PersistenceManager pm = pmf.getPersistenceManager();
472    testReadPermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
473    testReadPermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
474    pm.close();
475    pmf.close();
476  }
477
478  public void testWritesWithoutDatastoreTxn() throws Exception {
479    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
480        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
481    PersistenceManager pm = pmf.getPersistenceManager();
482    testWritePermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
483    pm.close();
484    pmf.close();
485
486    pmf = getPersistenceManagerFactory(
487        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
488    pm = pmf.getPersistenceManager();
489    testWritePermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
490    testWritePermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
491    testWritePermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
492
493    pm.close();
494    pmf.close();
495  }
496
497  public void testUpdatesWithoutDatastoreTxn() throws Exception {
498    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
499        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
500    testUpdatePermutationWithoutExpectedDatastoreTxn(pmf, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
501    pmf.close();
502
503    pmf = getPersistenceManagerFactory(
504        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
505    testUpdatePermutationWithoutExpectedDatastoreTxn(pmf, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
506    testUpdatePermutationWithoutExpectedDatastoreTxn(pmf, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
507    testUpdatePermutationWithoutExpectedDatastoreTxn(pmf, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
508
509    pmf.close();
510  }
511
512  public void testReadsWithoutDatastoreTxn() throws Exception {
513    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
514        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
515    PersistenceManager pm = pmf.getPersistenceManager();
516    testReadPermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
517    pm.close();
518    pmf.close();
519
520    pmf = getPersistenceManagerFactory(
521        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
522    pm = pmf.getPersistenceManager();
523    testReadPermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
524    testReadPermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
525    testReadPermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED);
526
527    pm.close();
528    pmf.close();
529  }
530
531  public void testIllegalWrites() throws Exception {
532    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
533        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
534    PersistenceManager pm = pmf.getPersistenceManager();
535    testIllegalWritePermutation(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
536    pm.close();
537    pmf.close();
538    pmf = getPersistenceManagerFactory(
539        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
540    pm = pmf.getPersistenceManager();
541    testIllegalWritePermutation(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
542    pm.close();
543    pmf.close();
544  }
545
546  public void testIllegalUpdates() throws Exception {
547    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
548        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
549    testIllegalUpdatePermutation(pmf, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
550    pmf.close();
551    pmf = getPersistenceManagerFactory(
552        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
553    testIllegalUpdatePermutation(pmf, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
554    pmf.close();
555  }
556
557  public void testIllegalReads() throws Exception {
558    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
559        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
560    PersistenceManager pm = pmf.getPersistenceManager();
561    testIllegalReadPermutation(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
562    pm.close();
563    pmf.close();
564    pmf = getPersistenceManagerFactory(
565        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
566    pm = pmf.getPersistenceManager();
567    testIllegalReadPermutation(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED);
568    pm.close();
569    pmf.close();
570  }
571
572  private static final QueryRunner ANCESTOR = new QueryRunner() {
573    public void runQuery(PersistenceManager pm) {
574      Query q = pm.newQuery(HasKeyAncestorKeyPkJDO.class, "ancestorKey == :p");
575      q.execute(KeyFactory.createKey("yar", 23));
576    }
577
578    public boolean isAncestor() {
579      return true;
580    }
581  };
582
583  private static final QueryRunner NON_ANCESTOR = new QueryRunner() {
584    public void runQuery(PersistenceManager pm) {
585      Query q = pm.newQuery(Flight.class);
586      q.execute();
587    }
588
589    public boolean isAncestor() {
590      return false;
591    }
592  };
593
594  @Inner("TODO -- see if we can avoid this tx mock check")
595  public void testQueriesWithDatastoreTxn() throws Exception {
596    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
597        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
598    PersistenceManager pm = pmf.getPersistenceManager();
599    testQueryPermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, ANCESTOR);
600    testQueryPermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED, ANCESTOR);
601    testQueryPermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, NON_ANCESTOR);
602    testQueryPermutationWithExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED, NON_ANCESTOR);
603    pm.close();
604    pmf.close();
605  }
606
607  public void testQueriesWithoutDatastoreTxn() throws Exception {
608    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
609        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
610    PersistenceManager pm = pmf.getPersistenceManager();
611    testQueryPermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, ANCESTOR);
612    pm.close();
613    pmf.close();
614
615    pmf = getPersistenceManagerFactory(
616        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
617    pm = pmf.getPersistenceManager();
618    testQueryPermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, ANCESTOR);
619    testQueryPermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED, ANCESTOR);
620    testQueryPermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, ANCESTOR);
621    testQueryPermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, NON_ANCESTOR);
622    testQueryPermutationWithoutExpectedDatastoreTxn(pm, EXPLICIT_DEMARCATION, NON_TXN_OP_NOT_ALLOWED, NON_ANCESTOR);
623    testQueryPermutationWithoutExpectedDatastoreTxn(pm, NO_EXPLICIT_DEMARCATION, NON_TXN_OP_ALLOWED, NON_ANCESTOR);
624
625    pm.close();
626    pmf.close();
627  }
628
629  public void testEmptyTxnBlock_Txn() {
630    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
631        JDOTestCase.PersistenceManagerFactoryName.transactional.name());
632    PersistenceManager pm = pmf.getPersistenceManager();
633    try {
634      EasyMock.expect(mockDatastoreService.beginTransaction(EasyMock.isA(TransactionOptions.class))).andReturn(mockTxn);
635      EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer);
636      EasyMock.expect(mockTxn.getId()).andAnswer(txnIdAnswer);
637      mockTxn.commit();
638      EasyMock.expectLastCall();
639      EasyMock.replay(mockDatastoreService, mockTxn);
640      pm.currentTransaction().begin();
641      pm.currentTransaction().commit();
642      EasyMock.verify(mockDatastoreService, mockTxn);
643    } finally {
644      if (pm.currentTransaction().isActive()) {
645        pm.currentTransaction().rollback();
646      }
647      pm.close();
648      pmf.close();
649    }
650  }
651
652  public void testEmptyTxnBlock_NoTxn() {
653    PersistenceManagerFactory pmf = getPersistenceManagerFactory(
654        JDOTestCase.PersistenceManagerFactoryName.nontransactional.name());
655    PersistenceManager pm = pmf.getPersistenceManager();
656    try {
657      EasyMock.replay(mockDatastoreService, mockTxn);
658      pm.currentTransaction().begin();
659      pm.currentTransaction().commit();
660      EasyMock.verify(mockDatastoreService, mockTxn);
661    } finally {
662      if (pm.currentTransaction().isActive()) {
663        pm.currentTransaction().rollback();
664      }
665      pm.close();
666      pmf.close();
667    }
668  }
669}