datastore: variadic Get, Put, Exists, Delete.

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 81 matching lines @@
                         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)
+                                So(ds.DeleteMulti(keys...), ShouldBeNil)
                                 count := 0
                                 So(ds.Raw().DeleteMulti(keys, func(err error) error {
                                         count++
                                         So(err, ShouldBeNil)
                                         return nil
                                 }), 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)
 
                                 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)
+                                        So(ds.DeleteMulti(append(keys, k)...), ShouldBeNil)
 
                                         ds.Testable().CatchupIndexes()
 
                                         count := 0
                                         So(ds.Run(dsS.NewQuery(""), func(_ *dsS.Key) {
                                                 count++
                                         }), ShouldBeNil)
                                         So(count, ShouldEqual, 3)
 
                                         So(testGetMeta(c, k), ShouldEqual, 22)
@@ skipping 616 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)
                 })
         })
 }