Add Consistent(bool) to Testing interface

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 439 matching lines @@
                                                 calls := 0
                                                 So(ds.RunInTransaction(func(c context.Context) error {
                                                         calls++
                                                         return fmt.Errorf("omg")
                                                 }, nil).Error(), ShouldEqual, "omg")
                                                 So(calls, ShouldEqual, 1)
                                         })
                                 })
                         })
                 })
+
+                Convey("Testable.Consistent", func() {
+                        Convey("false", func() {
+                                ds.Testable().Consistent(false) // the default
+                                for i := 0; i < 10; i++ {
+                                        So(ds.Put(&Foo{ID: int64(i + 1), Val: i + 1}), ShouldBeNil)
+                                }
+                                q := dsS.NewQuery("Foo").Gt("Val", 3)
+                                count, err := ds.Count(q)
+                                So(err, ShouldBeNil)
+                                So(count, ShouldEqual, 0)
+
+                                ds.Delete(ds.MakeKey("Foo", 4))
+
+                                count, err = ds.Count(q)
+                                So(err, ShouldBeNil)
+                                So(count, ShouldEqual, 0)
+
+                                ds.Testable().Consistent(true)
+                                count, err = ds.Count(q)
+                                So(err, ShouldBeNil)
+                                So(count, ShouldEqual, 6)
+                        })
+
+                        Convey("true", func() {
+                                ds.Testable().Consistent(true)
+                                for i := 0; i < 10; i++ {
+                                        So(ds.Put(&Foo{ID: int64(i + 1), Val: i + 1}), ShouldBeNil)
+                                }
+                                q := dsS.NewQuery("Foo").Gt("Val", 3)
+                                count, err := ds.Count(q)
+                                So(err, ShouldBeNil)
+                                So(count, ShouldEqual, 7)
+
+                                ds.Delete(ds.MakeKey("Foo", 4))
+
+                                count, err = ds.Count(q)
+                                So(err, ShouldBeNil)
+                                So(count, ShouldEqual, 6)
+                        })
+                })
         })
 }
 
 func TestCompoundIndexes(t *testing.T) {
         t.Parallel()
 
         idxKey := func(def dsS.IndexDefinition) string {
                 So(def, ShouldNotBeNil)
                 return "idx::" + string(serialize.ToBytes(*def.PrepForIdxTable()))
         }
@@ skipping 57 matching lines @@
                 ds := dsS.Get(Use(context.Background()))
                 m := Model{ID: 1}
                 So(ds.Put(&m), ShouldBeNil)
 
                 // Reset to something non zero to ensure zero is fetched.
                 m.Time = time.Now().UTC()
                 So(ds.Get(&m), ShouldBeNil)
                 So(m.Time.IsZero(), ShouldBeTrue)
         })
 }