datastore: Update AllocateIDs to take keys.

impl/memory/datastore_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         "testing"
         "time"
@@ skipping 144 matching lines @@
                                                         "Val":  {dsS.MkProperty(10)},
                                                         "Name": {dsS.MkProperty("")},
                                                         "$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)
+                                keys := ds.NewIncompleteKeys(100, "Foo", nil)
+                                So(ds.AllocateIDs(keys), ShouldBeNil)
+                                So(len(keys), ShouldEqual, 100)
 
+                                // Assert that none of our keys share the same ID.
+                                ids := make(map[int64]struct{})
+                                for _, k := range keys {
+                                        ids[k.IntID()] = struct{}{}
+                                }
+                                So(len(ids), ShouldEqual, len(keys))
+
+                                // Put a new object and ensure that it is allocated an unused ID.
                                 f := &Foo{Val: 10}
                                 So(ds.Put(f), ShouldBeNil)
                                 k := ds.KeyForObj(f)
                                 So(k.String(), ShouldEqual, "dev~app::/Foo,102")
+
+                                _, ok := ids[k.IntID()]
+                                So(ok, ShouldBeFalse)
                         })
                 })
 
                 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")
 
@@ skipping 573 matching lines @@
                         // Add "foos" to a new namespace, then confirm that it gets indexed.
                         So(dsS.Get(infoS.Get(ctx).MustNamespace("qux")).PutMulti(foos), ShouldBeNil)
                         dsS.Get(ctx).Testable().CatchupIndexes()
 
                         results = nil
                         So(dsS.Get(infoS.Get(ctx).MustNamespace("qux")).GetAll(q, &results), ShouldBeNil)
                         So(len(results), ShouldEqual, 2)
                 })
         })
 }