Fix races in txnBuf

filter/txnBuf/txnbuf_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 txnBuf
 
 import (
         "bytes"
         "fmt"
         "math/rand"
@@ skipping 137 matching lines @@
 func TestTransactionBuffers(t *testing.T) {
         t.Parallel()
 
         Convey("Get/Put/Delete", t, func() {
                 under, over, ds := mkds(dataMultiRoot)
                 ds.Testable().SetTransactionRetryCount(1)
 
                 So(under.PutMulti.Total(), ShouldEqual, 0)
                 So(over.PutMulti.Total(), ShouldEqual, 0)
 
-                Convey("Good", func() {
+                FocusConvey("Good", func() {

[dnj, 2015/11/11 16:08:28]

Switch back to regular Convey.

                         Convey("read-only", func() {
                                 So(ds.RunInTransaction(func(c context.Context) error {
                                         ds := datastore.Get(c)
 
                                         So(4, fooShouldHave(ds), dataMultiRoot[3].Value)
                                         return nil
                                 }, nil), ShouldBeNil)
                         })
 
                         Convey("single-level read/write", func() {
@@ skipping 11 matching lines @@
                                         return nil
                                 }, &datastore.TransactionOptions{XG: true}), ShouldBeNil)
 
                                 // 2 because we are simulating a transaction failure
                                 So(under.PutMulti.Total(), ShouldEqual, 2)
 
                                 So(3, fooShouldHave(ds), 1, 2, 3, 4)
                                 So(4, fooShouldHave(ds), 1, 2, 3, 4)
                         })
 
-                        Convey("multi-level read/write", func() {
+                        FocusConvey("multi-level read/write", func() {

[dnj, 2015/11/11 16:08:28]

Switch back to regular Convey.

[iannucci, 2015/11/11 18:06:40]

oops, done (for both)

                                 So(ds.RunInTransaction(func(c context.Context) error {
                                         ds := datastore.Get(c)
 
                                         So(3, fooShouldHave(ds), dataMultiRoot[2].Value)
 
                                         So(3, fooSetTo(ds), 1, 2, 3, 4)
                                         So(7, fooSetTo(ds))
 
                                         vals := []*Foo{
                                                 {ID: 793},
@@ skipping 39 matching lines @@
 
                                         // now we see it
                                         So(3, fooShouldHave(ds), 10, 20, 30, 40)
                                         return nil
                                 }, &datastore.TransactionOptions{XG: true}), ShouldBeNil)
 
                                 // 2 because we are simulating a transaction failure
                                 So(under.PutMulti.Total(), ShouldEqual, 2)
                                 So(under.DeleteMulti.Total(), ShouldEqual, 2)
 
-                                // 'over' Put operations are amplified because the inner transaction
-                                // commits go through the 'over' filter on the outer transaction. So it's
-                                // # Puts + # inner txns, times 2 because we are simulating a failed
-                                // transaction.
-                                So(over.PutMulti.Total(), ShouldEqual, 10)
+                                So(over.PutMulti.Total(), ShouldEqual, 8)
 
                                 So(7, fooShouldHave(ds))
                                 So(3, fooShouldHave(ds), 10, 20, 30, 40)
                         })
 
                         Convey("can allocate IDs from an inner transaction", func() {
                                 nums := []int64{4, 8, 15, 16, 23, 42}
                                 k := (*datastore.Key)(nil)
                                 So(ds.RunInTransaction(func(c context.Context) error {
                                         ds := datastore.Get(c)
@@ skipping 566 matching lines @@
 
                                                 vals = []*Foo{}
                                                 So(ds.GetAll(q, &vals), ShouldBeNil)
                                                 So(vals, ShouldResemble, []*Foo{foo1, projectData[0], foo7})
 
                                                 return nil
                                         }, nil), ShouldBeNil)
 
                                         vals = []*Foo{}
                                         So(ds.GetAll(q, &vals), ShouldBeNil)
-                                        So(vals, ShouldResemble, []*Foo{foo1, projectData[0], foo7})
+                                        So(vals, ShouldResembleV, []*Foo{foo1, projectData[0], foo7})
 
                                         return nil
                                 }, nil), ShouldBeNil)
 
                                 vals := []*Foo{}
                                 So(ds.GetAll(q, &vals), ShouldBeNil)
                                 So(vals, ShouldResemble, []*Foo{foo1, projectData[0], foo7})
 
                         })
 
                         Convey("start transaction from inside query", func() {
                                 _, _, ds := mkds(projectData)
                                 So(ds.RunInTransaction(func(c context.Context) error {
                                         ds := datastore.Get(c)
 
                                         q := datastore.NewQuery("Foo").Ancestor(root)
                                         return ds.Run(q, func(pm datastore.PropertyMap, _ datastore.CursorCB) bool {
                                                 So(ds.RunInTransaction(func(c context.Context) error {
+                                                        ds := datastore.Get(c)
                                                         pm["Value"] = append(pm["Value"], datastore.MkProperty("wat"))
                                                         return ds.Put(pm)
                                                 }, nil), ShouldBeNil)
                                                 return true
                                         })
                                 }, &datastore.TransactionOptions{XG: true}), ShouldBeNil)
 
                                 So(ds.Run(datastore.NewQuery("Foo"), func(pm datastore.PropertyMap, _ datastore.CursorCB) bool {
                                         val := pm["Value"]
                                         So(val[len(val)-1].Value(), ShouldResemble, "wat")
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
 
         })
 
 }