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

impl/prod/everything_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.
 
 // +build appengine
 
 package prod
 
 import (
         "testing"
@@ skipping 45 matching lines @@
                 Convey("Can probe/change Namespace", func() {
                         So(inf.GetNamespace(), ShouldEqual, "")
                         ctx, err = inf.Namespace("wat")
                         So(err, ShouldBeNil)
                         inf = info.Get(ctx)
                         So(inf.GetNamespace(), ShouldEqual, "wat")
                         ds = datastore.Get(ctx)
                         So(ds.MakeKey("Hello", "world").Namespace(), ShouldEqual, "wat")
                 })
 
+                Convey("Can get non-transactional context", func() {
+                        ctx, err := inf.Namespace("foo")
+                        So(err, ShouldBeNil)
+                        ds = datastore.Get(ctx)
+                        inf = info.Get(ctx)
+
+                        ds.RunInTransaction(func(ctx context.Context) error {
+                                So(ds.MakeKey("Foo", "bar").Namespace(), ShouldEqual, "foo")
+
+                                So(ds.Put(&TestStruct{ValueI: []int64{100}}), ShouldBeNil)
+
+                                err = datastore.GetNoTxn(ctx).RunInTransaction(func(ctx context.Context) error {
+                                        ds = datastore.Get(ctx)
+                                        So(ds.MakeKey("Foo", "bar").Namespace(), ShouldEqual, "foo")
+                                        So(ds.Put(&TestStruct{ValueI: []int64{100}}), ShouldBeNil)
+                                        return nil
+                                }, nil)
+                                So(err, ShouldBeNil)
+
+                                return nil
+                        }, nil)
+                })
+
                 Convey("Can Put/Get", func() {
                         orig := TestStruct{
                                 ValueI: []int64{1, 7, 946688461000000, 996688461000000},
                                 ValueB: []bool{true, false},
                                 ValueS: []string{"hello", "world"},
                                 ValueF: []float64{1.0, 7.0, 946688461000000.0, 996688461000000.0},
                                 ValueBS: [][]byte{
                                         []byte("allo"),
                                         []byte("hello"),
                                         []byte("world"),
@@ skipping 106 matching lines @@
                         So(tval, ShouldResemble, pm["Time"][0].Value())
 
                         ent := datastore.PropertyMap{
                                 "$key": {mpNI(ds.MakeKey("Something", "value"))},
                         }
                         So(ds.Get(&ent), ShouldBeNil)
                         So(ent["Time"], ShouldResemble, pm["Time"])
                 })
         })
 }