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 73 matching lines @@
                                 })
 
                         })
                         Convey("Deleteing with a bogus key is bad", func() {
                                 So(ds.Delete(ds.NewKey("Foo", "wat", 100, nil)), ShouldEqual, dsS.ErrInvalidKey)
                         })
                         Convey("Deleteing a DNE entity is fine", func() {
                                 So(ds.Delete(ds.NewKey("Foo", "wat", 0, nil)), ShouldBeNil)
                         })
 
+                        Convey("Deleting entities from a nonexistant namespace works", func() {
+                                aid := infoS.Get(c).FullyQualifiedAppID()
+                                keys := make([]*dsS.Key, 10)
+                                for i := range keys {
+                                        keys[i] = ds.MakeKey(aid, "noexist", "Kind", i+1)
+                                }
+                                So(ds.DeleteMulti(keys), ShouldBeNil)
+                                count := 0
+                                So(ds.Raw().DeleteMulti(keys, func(err error) {
+                                        count++
+                                        So(err, ShouldBeNil)
+                                }), ShouldBeNil)
+                                So(count, ShouldEqual, len(keys))
+                        })
+
                         Convey("with multiple puts", func() {
                                 So(testGetMeta(c, k), ShouldEqual, 1)
 
                                 foos := make([]Foo, 10)
                                 for i := range foos {
                                         foos[i].Val = 10
                                         foos[i].Parent = k
                                 }
                                 So(ds.PutMulti(foos), ShouldBeNil)
                                 So(testGetMeta(c, k), ShouldEqual, 11)
@@ skipping 346 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)
+
+                                So(ds.Delete(ds.MakeKey("Foo", 4)), ShouldBeNil)
+
+                                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)
+
+                                So(ds.Delete(ds.MakeKey("Foo", 4)), ShouldBeNil)
+
+                                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)
         })
 }