Add emulation of transaction retries to memory impl of RunInTransaction.

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"
 
@@ skipping 283 matching lines @@
                                                 So(txnDS.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
 
                                                 f.Val = 20
                                                 So(txnDS.Put(f), ShouldBeNil)
 
                                                 So(txnDS.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10) // still gets 10
 
                                                 return nil
-                                        }, nil)
+                                        }, &dsS.TransactionOptions{Attempts: 1})
                                         So(err.Error(), ShouldContainSubstring, "concurrent")
 
                                         f := &Foo{Id: 1}
                                         So(ds.Get(f), ShouldBeNil)
                                         So(f.Val, ShouldEqual, 11)
                                 })
 
                                 Convey("Reusing a transaction context is bad news", func() {
                                         txnDS := dsS.Interface(nil)
                                         err := ds.RunInTransaction(func(c context.Context) error {
@@ skipping 11 matching lines @@
                                                         panic("noooo")
                                                 }, nil)
                                                 So(err.Error(), ShouldContainSubstring, "nested transactions")
                                                 return nil
                                         }, nil)
                                         So(err, ShouldBeNil)
                                 })
 
                                 Convey("Concurrent transactions only accept one set of changes", func() {
                                         // Note: I think this implementation is actually /slightly/ wrong.
-                                        // Accorting to my read of the docs for appengine, when you open a
+                                        // 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 {
                                                         So(dsS.Get(c).Put(&Foo{Id: 1, Val: 27}), ShouldBeNil)
@@ skipping 63 matching lines @@
                                                                 So(ds.Put(&Foo{Val: 200}), ShouldBeNil)
                                                                 panic("wheeeeee")
                                                         }, nil)
                                                 }, ShouldPanic)
 
                                                 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() {
+                                                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() {
+                                                tst.SetTransactionRetryCount(100) // more than 3
+                                                calls := 0
+                                                So(ds.RunInTransaction(func(c context.Context) error {
+                                                        calls++
+                                                        return nil
+                                                }, nil), ShouldEqual, dsS.ErrConcurrentTransaction)
+                                                So(calls, ShouldEqual, 3)
+                                        })
+
+                                        Convey("non-default TransactionOptions ", func() {
+                                                tst.SetTransactionRetryCount(100) // more than 20
+                                                calls := 0
+                                                So(ds.RunInTransaction(func(c context.Context) error {
+                                                        calls++
+                                                        return nil
+                                                }, &dsS.TransactionOptions{Attempts: 20}), ShouldEqual, dsS.ErrConcurrentTransaction)
+                                                So(calls, ShouldEqual, 20)
+                                        })
+
+                                        Convey("SetTransactionRetryCount is respected", func() {
+                                                tst.SetTransactionRetryCount(1) // less than 3
+                                                calls := 0
+                                                So(ds.RunInTransaction(func(c context.Context) error {
+                                                        calls++
+                                                        return nil
+                                                }, nil), ShouldBeNil)
+                                                So(calls, ShouldEqual, 2)
+                                        })
+
+                                        Convey("fatal errors are not retried", func() {
+                                                tst.SetTransactionRetryCount(1)
+                                                calls := 0
+                                                So(ds.RunInTransaction(func(c context.Context) error {
+                                                        calls++
+                                                        return fmt.Errorf("omg")
+                                                }, nil).Error(), ShouldEqual, "omg")
+                                                So(calls, ShouldEqual, 1)
+                                        })
+                                })
                         })
                 })
-
         })
 }
 
 func TestCompoundIndexes(t *testing.T) {
         t.Parallel()
 
         idxKey := func(def dsS.IndexDefinition) string {
                 So(def, ShouldNotBeNil)
                 return "idx::" + string(serialize.ToBytes(*def.PrepForIdxTable()))
         }
 
         numItms := func(c *memCollection) uint64 {
                 ret, _ := c.GetTotals()
                 return ret
         }
 
         Convey("Test Compound indexes", t, func() {
                 type Model struct {
                         ID int64 `gae:"$id"`
 
                         Field1 []string
                         Field2 []int64
                 }
 
                 c := Use(context.Background())
                 ds := dsS.Get(c)
-                t := ds.Raw().Testable().(*dsImpl)
+                t := ds.Testable().(*dsImpl)
                 head := t.data.head
 
                 So(ds.Put(&Model{1, []string{"hello", "world"}, []int64{10, 11}}), ShouldBeNil)
 
                 idx := dsS.IndexDefinition{
                         Kind: "Model",
                         SortBy: []dsS.IndexColumn{
                                 {Property: "Field2"},
                         },
                 }
 
                 coll := head.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 2)
 
                 idx.SortBy[0].Property = "Field1"
                 coll = head.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 2)
 
                 idx.SortBy = append(idx.SortBy, dsS.IndexColumn{Property: "Field1"})
                 So(head.GetCollection(idxKey(idx)), ShouldBeNil)
 
                 t.AddIndexes(&idx)
                 coll = head.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 4)
         })
 }