Add the ability to disable special automatic entities in impl/memory

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"
 
         dsS "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         infoS "github.com/luci/gae/service/info"
+        . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 type MetaGroup struct {
         _id    int64    `gae:"$id,1"`
         _kind  string   `gae:"$kind,__entity_group__"`
         Parent *dsS.Key `gae:"$parent"`
 
         Version int64 `gae:"__version__"`
@@ skipping 481 matching lines @@
                                 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)
                         })
                 })
+
+                Convey("Testable.DisableSpecialEntities", func() {
+                        ds.Testable().DisableSpecialEntities(true)
+
+                        So(ds.Put(&Foo{}), ShouldErrLike, "allocateIDs is disabled")
+
+                        So(ds.Put(&Foo{ID: 1}), ShouldBeNil)
+
+                        ds.Testable().CatchupIndexes()
+
+                        count, err := ds.Count(dsS.NewQuery(""))
+                        So(err, ShouldBeNil)
+                        So(count, ShouldEqual, 1) // normally this would include __entity_group__
+                })
         })
 }
 
 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)
         })
 }