Make Get operations only serialize the bare minimum.

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 183 matching lines @@
                 return f.IntID, nil
         case "kind":
                 if f.Kind == "" {
                         return "FakePLS", nil
                 }
                 return f.Kind, nil
         }
         return nil, ErrMetaFieldUnset
 }
 
+func (f *FakePLS) GetAllMeta() PropertyMap {
+        ret := PropertyMap{}
+        if id, err := f.GetMeta("id"); err != nil {
+                So(ret.SetMeta("id", id), ShouldBeNil)
+        }
+        if kind, err := f.GetMeta("kind"); err != nil {
+                So(ret.SetMeta("kind", kind), ShouldBeNil)
+        }
+        return ret
+}
+
 func (f *FakePLS) SetMeta(key string, val interface{}) error {
         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
@@ skipping 356 matching lines @@
                                 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")
+                                cs := &FakePLS{failGetMeta: true}
+                                So(ds.Get(cs).Error(), ShouldContainSubstring, "unable to extract $kind")
                         })
                 })
 
                 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()
                                 keys := []*Key{ds.MakeKey("Kind", 1)}
                                 So(rds.GetMulti(keys, nil, func(pm PropertyMap, err error) {
                                         So(err, ShouldBeNil)
                                         So(pm["Value"][0].Value(), ShouldEqual, 1)
                                 }), ShouldBeNil)
                         })
+
+                        Convey("but general failure to save is fine on a Get", func() {
+                                cs := &FakePLS{failSave: true, IntID: 7}
+                                So(ds.Get(cs), ShouldBeNil)
+                        })
                 })
 
         })
 }
 
 func TestGetAll(t *testing.T) {
         t.Parallel()
 
         Convey("Test GetAll", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
@@ skipping 247 matching lines @@
                                 So(ds.Run(q, func(k *Key, _ CursorCB) bool {
                                         So(k.Last().IntID, ShouldEqual, i+1)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }