Add API to allow you to get the non-transactional datastore or taskqueue.

impl/memory/datastore_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         "testing"
         "time"
@@ skipping 237 matching lines @@
 
                                                 So(pm.SetMeta("key", k), ShouldBeNil)
                                                 So(ds.Get(pm).Error(), ShouldContainSubstring, "cross-group")
                                                 return nil
                                         }, nil)
                                         So(err, ShouldBeNil)
                                 })
 
                                 Convey("Get takes a snapshot", func() {
                                         err := ds.RunInTransaction(func(c context.Context) error {
-                                                txnDS := dsS.Get(c)
+                                                ds := dsS.Get(c)
 
-                                                So(txnDS.Get(f), ShouldBeNil)
+                                                So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
 
                                                 // Don't ever do this in a real program unless you want to guarantee
                                                 // a failed transaction :)
                                                 f.Val = 11
-                                                So(ds.Put(f), ShouldBeNil)
+                                                So(dsS.GetNoTxn(c).Put(f), ShouldBeNil)
 
-                                                So(txnDS.Get(f), ShouldBeNil)
+                                                So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
 
                                                 return nil
                                         }, nil)
                                         So(err, ShouldBeNil)
 
                                         f := &Foo{ID: 1}
                                         So(ds.Get(f), ShouldBeNil)
                                         So(f.Val, ShouldEqual, 11)
                                 })
 
                                 Convey("and snapshots are consistent even after Puts", func() {
                                         err := ds.RunInTransaction(func(c context.Context) error {
-                                                txnDS := dsS.Get(c)
+                                                ds := dsS.Get(c)
 
                                                 f := &Foo{ID: 1}
-                                                So(txnDS.Get(f), ShouldBeNil)
+                                                So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
 
                                                 // Don't ever do this in a real program unless you want to guarantee
                                                 // a failed transaction :)
                                                 f.Val = 11
-                                                So(ds.Put(f), ShouldBeNil)
+                                                So(dsS.GetNoTxn(c).Put(f), ShouldBeNil)
 
-                                                So(txnDS.Get(f), ShouldBeNil)
+                                                So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
 
                                                 f.Val = 20
-                                                So(txnDS.Put(f), ShouldBeNil)
+                                                So(ds.Put(f), ShouldBeNil)
 
-                                                So(txnDS.Get(f), ShouldBeNil)
+                                                So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10) // still gets 10
 
                                                 return nil
                                         }, &dsS.TransactionOptions{Attempts: 1})
                                         So(err.Error(), ShouldContainSubstring, "concurrent")
 
                                         f := &Foo{ID: 1}
                                         So(ds.Get(f), ShouldBeNil)
                                         So(f.Val, ShouldEqual, 11)
                                 })
@@ skipping 24 matching lines @@
                                         // Note: I think this implementation is actually /slightly/ wrong.
                                         // According to my read of the docs for appengine, when you open a
                                         // transaction it actually (essentially) holds a reference to the
                                         // entire datastore. Our implementation takes a snapshot of the
                                         // entity group as soon as something observes/affects it.
                                         //
                                         // That said... I'm not sure if there's really a semantic difference.
                                         err := ds.RunInTransaction(func(c context.Context) error {
                                                 So(dsS.Get(c).Put(&Foo{ID: 1, Val: 21}), ShouldBeNil)
 
-                                                err := ds.RunInTransaction(func(c context.Context) error {
+                                                err := dsS.GetNoTxn(c).RunInTransaction(func(c context.Context) error {
                                                         So(dsS.Get(c).Put(&Foo{ID: 1, Val: 27}), ShouldBeNil)
                                                         return nil
                                                 }, nil)
                                                 So(err, ShouldBeNil)
 
                                                 return nil
                                         }, nil)
                                         So(err.Error(), ShouldContainSubstring, "concurrent")
 
                                         f := &Foo{ID: 1}
@@ skipping 59 matching lines @@
                                                 f := &Foo{ID: 1}
                                                 So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
                                         })
                                 })
 
                                 Convey("Transaction retries", func() {
                                         tst := ds.Testable()
                                         Reset(func() { tst.SetTransactionRetryCount(0) })
 
-                                        Convey("SetTransactionRetryCount set to zere", func() {
+                                        Convey("SetTransactionRetryCount set to zero", func() {
                                                 tst.SetTransactionRetryCount(0)
                                                 calls := 0
                                                 So(ds.RunInTransaction(func(c context.Context) error {
                                                         calls++
                                                         return nil
                                                 }, nil), ShouldBeNil)
                                                 So(calls, ShouldEqual, 1)
                                         })
 
                                         Convey("default TransactionOptions is 3 attempts", func() {
@@ skipping 189 matching lines @@
                 So(ds.Put(&Model{ID: 1, Value: []int64{20, 30}}), ShouldBeNil)
 
                 vals := []dsS.PropertyMap{}
                 So(ds.GetAll(dsS.NewQuery("Model").Project("Value"), &vals), ShouldBeNil)
                 So(len(vals), ShouldEqual, 2)
 
                 So(vals[0]["Value"][0].Value(), ShouldEqual, 20)
                 So(vals[1]["Value"][0].Value(), ShouldEqual, 30)
         })
 }