Refactor multiarg, split MGS/PLS.

service/datastore/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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 128 matching lines @@
 
 type CommonStruct struct {
         ID     int64 `gae:"$id"`
         Parent *Key  `gae:"$parent"`
 
         Value int64
 }
 
 type permaBad struct {
         PropertyLoadSaver
+        MetaGetterSetter
 }
 
 func (f *permaBad) Load(pm PropertyMap) error {
         return errors.New("permaBad")
 }
 
 type SingletonStruct struct {
         id int64 `gae:"$id,1"`
 }
 
@@ skipping 306 matching lines @@
                                 Convey("get single error for RPC failure", func() {
                                         fplss := []FakePLS{{Kind: "FailAll"}, {}}
                                         So(ds.Put(fplss), ShouldEqual, errFailAll)
                                 })
 
                                 Convey("get multi error for individual failures", func() {
                                         fplss := []FakePLS{{}, {Kind: "Fail"}}
                                         So(ds.Put(fplss), ShouldResemble, errors.MultiError{nil, errFail})
                                 })
 
-                                Convey("put with non-modifyable type is an error", func() {
-                                        cs := CommonStruct{}
-                                        So(func() { ds.Put(cs) }, ShouldPanicLike,
-                                                "invalid input type (datastore.CommonStruct): not a pointer")
-                                })
-
                                 Convey("get with *Key is an error", func() {
                                         So(func() { ds.Get(&Key{}) }, ShouldPanicLike,
                                                 "invalid input type (*datastore.Key): not user datatype")
                                 })
 
                                 Convey("struct with no $kind is an error", func() {
                                         s := MGSWithNoKind{}
                                         So(ds.Put(&s), ShouldErrLike, "unable to extract $kind")
                                 })
 
                                 Convey("struct with invalid but non-nil key is an error", func() {
                                         type BadParent struct {
                                                 ID     int64 `gae:"$id"`
                                                 Parent *Key  `gae:"$parent"`
                                         }
                                         // having an Incomplete parent makes an invalid key
                                         bp := &BadParent{ID: 1, Parent: ds.MakeKey("Something", 0)}
                                         So(ds.Put(bp), ShouldErrLike, ErrInvalidKey)
                                 })
 
                                 Convey("vararg with errors", func() {
                                         successSlice := []CommonStruct{{Value: 0}, {Value: 1}}
                                         failSlice := []FakePLS{{Kind: "Fail"}, {Value: 3}}
                                         emptySlice := []CommonStruct(nil)
                                         cs0 := CommonStruct{Value: 4}
-                                        cs1 := FakePLS{Kind: "Fail", Value: 5}
+                                        failPLS := FakePLS{Kind: "Fail", Value: 5}
                                         fpls := FakePLS{StringID: "ohai", Value: 6}
 
-                                        err := ds.Put(successSlice, failSlice, emptySlice, &cs0, &cs1, &fpls)
+                                        err := ds.Put(successSlice, failSlice, emptySlice, &cs0, &failPLS, &fpls)
                                         So(err, ShouldResemble, errors.MultiError{
                                                 nil, errors.MultiError{errFail, nil}, nil, nil, errFail, nil})
                                         So(successSlice[0].ID, ShouldEqual, 1)
                                         So(successSlice[1].ID, ShouldEqual, 2)
                                         So(cs0.ID, ShouldEqual, 5)
                                 })
                         })
 
                         Convey("ok", func() {
                                 Convey("[]S", func() {
@@ skipping 206 matching lines @@
                         er, err = ds.Exists(k, ds.MakeKey("DNE", "other"))
                         So(err, ShouldBeNil)
                         So(er.Get(0), ShouldBeTrue)
                         So(er.Get(1), ShouldBeFalse)
 
                         // Multi-arg keys with two missing.
                         er, err = ds.Exists(ds.MakeKey("DNE", "nope"), ds.MakeKey("DNE", "other"))
                         So(err, ShouldBeNil)
                         So(er.Any(), ShouldBeFalse)
 
+                        // Single struct pointer.
+                        er, err = ds.Exists(&CommonStruct{ID: 1})
+                        So(err, ShouldBeNil)
+                        So(er.All(), ShouldBeTrue)
+
                         // Multi-arg mixed key/struct/slices.
-                        er, err = ds.Exists(&CommonStruct{ID: 1}, []*CommonStruct(nil), []*Key{ds.MakeKey("DNE", "nope"), ds.MakeKey("hello", "ohai")})
+                        er, err = ds.Exists(
+                                &CommonStruct{ID: 1},
+                                []*CommonStruct(nil),
+                                []*Key{ds.MakeKey("DNE", "nope"), ds.MakeKey("hello", "ohai")},
+                        )
                         So(err, ShouldBeNil)
                         So(er.Get(0), ShouldBeTrue)
                         So(er.Get(1), ShouldBeTrue)
                         So(er.Get(2), ShouldBeFalse)
                         So(er.Get(2, 0), ShouldBeFalse)
                         So(er.Get(2, 1), ShouldBeTrue)
                 })
 
                 Convey("ExistsMulti", func() {
                         Convey("Returns no error if there are no failures.", func() {
@@ skipping 30 matching lines @@
                                 })
 
                                 Convey("get multi error for individual failure", func() {
                                         keys := []*Key{
                                                 ds.MakeKey("Ok", 1),
                                                 ds.MakeKey("Fail", 2),
                                         }
                                         So(ds.Delete(keys), ShouldResemble, errors.MultiError{nil, errFail})
                                 })
 
+                                Convey("put with non-modifyable type is an error", func() {
+                                        cs := CommonStruct{}
+                                        So(func() { ds.Put(cs) }, ShouldPanicLike,
+                                                "invalid input type (datastore.CommonStruct): not a pointer")
+                                })
+
                                 Convey("get single error when deleting a single", func() {
                                         k := ds.MakeKey("Fail", 1)
                                         So(ds.Delete(k), ShouldEqual, errFail)
                                 })
                         })
 
                         Convey("good", func() {
-                                // Single struct.
+                                // Single struct pointer.
                                 So(ds.Delete(&CommonStruct{ID: 1}), ShouldBeNil)
 
                                 // Single key.
                                 So(ds.Delete(ds.MakeKey("hello", "ohai")), ShouldBeNil)
 
                                 // Single struct DNE.
                                 So(ds.Delete(&CommonStruct{ID: noSuchEntityID}), ShouldEqual, ErrNoSuchEntity)
 
                                 // Single key DNE.
                                 So(ds.Delete(ds.MakeKey("DNE", "nope")), ShouldEqual, ErrNoSuchEntity)
 
                                 // Mixed key/struct/slices.
-                                err := ds.Delete(&CommonStruct{ID: 1}, []*Key{ds.MakeKey("hello", "ohai"), ds.MakeKey("DNE", "nope")})
+                                err := ds.Delete(
+                                        &CommonStruct{ID: 1},
+                                        []*Key{ds.MakeKey("hello", "ohai"), ds.MakeKey("DNE", "nope")},
+                                )
                                 So(err, ShouldResemble, errors.MultiError{nil, errors.MultiError{nil, ErrNoSuchEntity}})
                         })
                 })
 
                 Convey("Testing DeleteMulti", func() {
                         Convey("Succeeds for valid keys.", func() {
                                 So(ds.DeleteMulti([]*Key{ds.MakeKey("hello", "ohai")}), ShouldBeNil)
                                 So(ds.DeleteMulti([]*Key{ds.MakeKey("hello", "ohai"), ds.MakeKey("hello", "sup")}), ShouldBeNil)
                         })
 
@@ skipping 60 matching lines @@
                                         // It just won't save the key
                                         cs := &FakePLS{IntID: 10, failSetMeta: true}
                                         So(ds.Get(cs), ShouldBeNil)
                                 })
 
                                 Convey("vararg with errors", func() {
                                         successSlice := []CommonStruct{{ID: 1}, {ID: 2}}
                                         failSlice := []CommonStruct{{ID: noSuchEntityID}, {ID: 3}}
                                         emptySlice := []CommonStruct(nil)
                                         cs0 := CommonStruct{ID: 4}
-                                        cs1 := CommonStruct{ID: noSuchEntityID}
+                                        failPLS := CommonStruct{ID: noSuchEntityID}
                                         fpls := FakePLS{StringID: "ohai"}
 
-                                        err := ds.Get(successSlice, failSlice, emptySlice, &cs0, &cs1, &fpls)
+                                        err := ds.Get(successSlice, failSlice, emptySlice, &cs0, &failPLS, &fpls)
                                         So(err, ShouldResemble, errors.MultiError{
                                                 nil, errors.MultiError{ErrNoSuchEntity, nil}, nil, nil, ErrNoSuchEntity, nil})
                                         So(successSlice[0].Value, ShouldEqual, 1)
                                         So(successSlice[1].Value, ShouldEqual, 2)
                                         So(cs0.Value, ShouldEqual, 5)
                                         So(fpls.Value, ShouldEqual, 7)
                                 })
                         })
 
                         Convey("ok", func() {
@@ skipping 898 matching lines @@
                         if err != nil {
                                 panic(fmt.Errorf("failed to find absolute path for `%s`", sameLevelDir))
                         }
 
                         ids, err := FindAndParseIndexYAML(abs)
                         So(err, ShouldBeNil)
                         So(ids[1].Kind, ShouldEqual, "Test Foo")
                 })
         })
 }