Add missing AllocateIDs API.

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 92 matching lines @@
                                 So(testGetMeta(c, k), ShouldEqual, 11)
 
                                 keys := make([]*dsS.Key, len(foos))
                                 for i, f := range foos {
                                         keys[i] = ds.KeyForObj(&f)
                                 }
 
                                 Convey("ensure that group versions persist across deletes", func() {
                                         So(ds.DeleteMulti(append(keys, k)), ShouldBeNil)
 
-                                        // TODO(riannucci): replace with a Count query instead of this cast
-                                        /*
-                                                ents := ds.(*dsImpl).data.head.GetCollection("ents:")
-                                                num, _ := ents.GetTotals()
-                                                // /__entity_root_ids__,Foo
-                                                // /Foo,1/__entity_group__,1
-                                                // /Foo,1/__entity_group_ids__,1
-                                                So(num, ShouldEqual, 3)
-                                        */
+                                        ds.Testable().CatchupIndexes()
+
+                                        count := 0
+                                        So(ds.Run(dsS.NewQuery(""), func(_ *dsS.Key, _ dsS.CursorCB) bool {
+                                                count++
+                                                return true
+                                        }), ShouldBeNil)
+                                        So(count, ShouldEqual, 3)
 
                                         So(testGetMeta(c, k), ShouldEqual, 22)
 
                                         So(ds.Put(&Foo{ID: 1}), ShouldBeNil)
                                         So(testGetMeta(c, k), ShouldEqual, 23)
                                 })
 
                                 Convey("can Get", func() {
                                         vals := make([]dsS.PropertyMap, len(keys))
                                         for i := range vals {
                                                 vals[i] = dsS.PropertyMap{}
                                                 So(vals[i].SetMeta("key", keys[i]), ShouldBeNil)
                                         }
                                         So(ds.GetMulti(vals), ShouldBeNil)
 
                                         for i, val := range vals {
                                                 So(val, ShouldResemble, dsS.PropertyMap{
                                                         "Val":  {dsS.MkProperty(10)},
                                                         "$key": {dsS.MkPropertyNI(keys[i])},
                                                 })
                                         }
                                 })
 
                         })
+
+                        Convey("allocating ids prevents their use", func() {
+                                start, err := ds.AllocateIDs(ds.MakeKey("Foo", 0), 100)
+                                So(err, ShouldBeNil)
+                                So(start, ShouldEqual, 2)
+
+                                f := &Foo{Val: 10}
+                                So(ds.Put(f), ShouldBeNil)
+                                k := ds.KeyForObj(f)
+                                So(k.String(), ShouldEqual, "dev~app::/Foo,102")
+                        })
                 })
 
                 Convey("implements DSTransactioner", func() {
                         Convey("Put", func() {
                                 f := &Foo{Val: 10}
                                 So(ds.Put(f), ShouldBeNil)
                                 k := ds.KeyForObj(f)
                                 So(k.String(), ShouldEqual, "dev~app::/Foo,1")
 
                                 Convey("can Put new entity groups", func() {
@@ skipping 361 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)
         })
 }