datastore: Update AllocateIDs to take keys.

service/datastore/checkfilter_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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "testing"
 
         "github.com/luci/gae/service/info"
+        "github.com/luci/luci-go/common/errors"
+        "golang.org/x/net/context"
+
         . "github.com/smartystreets/goconvey/convey"
-        "golang.org/x/net/context"
 )
 
 type fakeRDS struct{ RawInterface }
 
 func TestCheckFilter(t *testing.T) {
         t.Parallel()
 
         Convey("Test checkFilter", t, func() {
                 // Note that the way we have this context set up, any calls which aren't
                 // stopped at the checkFilter will nil-pointer panic. We use this panic
                 // behavior to indicate that the checkfilter has allowed a call to pass
                 // through to the implementation in the tests below. In a real application
                 // the panics observed in the tests below would actually be sucessful calls
                 // to the implementation.
                 c := SetRaw(info.Set(context.Background(), fakeInfo{}), fakeRDS{})
                 rds := GetRaw(c) // has checkFilter
                 So(rds, ShouldNotBeNil)
 
+                Convey("AllocateIDs", func() {
+                        Convey("Will return nil if no keys are supplied.", func() {
+                                So(rds.AllocateIDs(nil), ShouldBeNil)
+                        })
+
+                        Convey("Will reject keys that are not PartialValid.", func() {
+                                k := NewKey("s~aid", "ns", "", "", 0, nil) // No Kind.
+                                So(k.PartialValid("s~aid", "ns"), ShouldBeFalse)
+
+                                err := rds.AllocateIDs([]*Key{k})
+                                So(err, ShouldResemble, errors.MultiError{ErrInvalidKey})
+                        })
+
+                        Convey("Will reject keys with non-homogenous entity types.", func() {
+                                k0 := NewKey("s~aid", "ns", "OneKind", "", 0, nil)
+                                k1 := NewKey("s~aid", "ns", "OtherKind", "", 0, nil)
+
+                                err := rds.AllocateIDs([]*Key{k0, k1})
+                                So(err, ShouldResemble, errors.MultiError{nil, ErrInvalidKey})
+                        })
+                })
+
                 Convey("RunInTransaction", func() {
                         So(rds.RunInTransaction(nil, nil).Error(), ShouldContainSubstring, "is nil")
                         hit := false
                         So(func() {
                                 So(rds.RunInTransaction(func(context.Context) error {
                                         hit = true
                                         return nil
                                 }, nil), ShouldBeNil)
                         }, ShouldPanic)
                         So(hit, ShouldBeFalse)
@@ skipping 86 matching lines @@
                                 So(rds.DeleteMulti([]*Key{mkKey("s~aid", "ns", "Kind", 1)}, func(error) error {
                                         hit = true
                                         return nil
                                 }), ShouldBeNil)
                         }, ShouldPanic)
                         So(hit, ShouldBeFalse)
                 })
 
         })
 }