Re-add metadata passthrough on Get operations

service/datastore/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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 98 matching lines @@
                         }
                         if KeyIncomplete(k) {
                                 k = NewKey(k.AppID(), k.Namespace(), k.Kind(), "", int64(i+1), k.Parent())
                         }
                 }
                 cb(k, err)
         }
         return nil
 }
 
-func (f *fakeDatastore) GetMulti(keys []Key, cb GetMultiCB) error {
+func (f *fakeDatastore) GetMulti(keys []Key, _meta MultiMetaGetter, cb GetMultiCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errors.New("GetMulti fail all")
         }
         for i, k := range keys {
                 if k.Kind() == "Fail" {
                         cb(nil, errors.New("GetMulti fail"))
                 } else {
                         cb(PropertyMap{"Value": {MkProperty(i + 1)}}, nil)
                 }
         }
@@ skipping 35 matching lines @@
 }
 
 type FakePLS struct {
         IntID    int64
         StringID string
         Kind     string
 
         Value     int64
         gotLoaded bool
 
-        failGetMeta  bool
-        failLoad     bool
-        failProblem  bool
-        failSave     bool
-        failSaveMeta bool
+        failGetMeta bool
+        failLoad    bool
+        failProblem bool
+        failSave    bool
+        failSetMeta bool
 }
 
+var _ PropertyLoadSaver = (*FakePLS)(nil)
+
 func (f *FakePLS) Load(pm PropertyMap) error {
         if f.failLoad {
                 return errors.New("FakePLS.Load")
         }
         f.gotLoaded = true
         f.Value = pm["Value"][0].Value().(int64)
         return nil
 }
 
 func (f *FakePLS) Save(withMeta bool) (PropertyMap, error) {
@@ skipping 10 matching lines @@
                 if f.Kind == "" {
                         ret.SetMeta("kind", "FakePLS")
                 } else {
                         ret.SetMeta("kind", f.Kind)
                 }
                 ret.SetMeta("assertExtra", true)
         }
         return ret, nil
 }
 
+func (f *FakePLS) GetMetaDefault(key string, dflt interface{}) interface{} {
+        return GetMetaDefaultImpl(f.GetMeta, key, dflt)
+}
+
 func (f *FakePLS) GetMeta(key string) (interface{}, error) {
         if f.failGetMeta {
                 return nil, errors.New("FakePLS.GetMeta")
         }
         switch key {
         case "id":
                 if f.StringID != "" {
                         return f.StringID, nil
                 }
                 return f.IntID, nil
         case "kind":
                 if f.Kind == "" {
                         return "FakePLS", nil
                 }
                 return f.Kind, nil
         }
         return nil, ErrMetaFieldUnset
 }
 
 func (f *FakePLS) SetMeta(key string, val interface{}) error {
-        if f.failSaveMeta {
+        if f.failSetMeta {
                 return errors.New("FakePL.SetMeta")
         }
         if key == "id" {
                 switch x := val.(type) {
                 case int64:
                         f.IntID = x
                 case string:
                         f.StringID = x
                 }
                 return nil
@@ skipping 352 matching lines @@
 
                         Convey("get multi error for individual failures", func() {
                                 fplss := []FakePLS{{IntID: 1}, {IntID: 2, Kind: "Fail"}}
                                 So(ds.GetMulti(fplss), ShouldResemble, errors.MultiError{nil, errors.New("GetMulti fail")})
                         })
 
                         Convey("get with non-modifiable type is an error", func() {
                                 cs := CommonStruct{}
                                 So(ds.Get(cs).Error(), ShouldContainSubstring, "invalid Get input type")
                         })
+
+                        Convey("failure to save metadata is an issue too", func() {
+                                cs := &FakePLS{failSave: true}
+                                So(ds.Get(cs).Error(), ShouldContainSubstring, "FakePLS.Save")
+                        })
                 })
 
                 Convey("ok", func() {
                         Convey("Get", func() {
                                 cs := &CommonStruct{ID: 1}
                                 So(ds.Get(cs), ShouldBeNil)
                                 So(cs.Value, ShouldEqual, 1)
                         })
 
                         Convey("Raw access too", func() {
                                 rds := ds.Raw()
-                                So(rds.GetMulti([]Key{rds.NewKey("Kind", "", 1, nil)}, func(pm PropertyMap, err error) {
+                                keys := []Key{rds.NewKey("Kind", "", 1, nil)}
+                                So(rds.GetMulti(keys, nil, func(pm PropertyMap, err error) {
                                         So(err, ShouldBeNil)
                                         So(pm["Value"][0].Value(), ShouldEqual, 1)
                                 }), ShouldBeNil)
                         })
                 })
 
         })
 }
 
 func TestGetAll(t *testing.T) {
@@ skipping 225 matching lines @@
                                 So(ds.Run(q, (*Key)(nil), func(obj interface{}, _ func() (Cursor, error)) bool {
                                         So(obj.(Key).IntID(), ShouldEqual, i+1)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }