Re-add metadata passthrough on Get operations

service/datastore/pls_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 (
         "bytes"
@@ skipping 319 matching lines @@
 type MismatchTypes struct {
         S  string
         B  bool
         F  float32
         K  Key
         T  time.Time
         G  GeoPoint
         IS []int
 }
 
-type BadSpecial struct {
+type BadMeta struct {
         ID int64  `gae:"$id"`
         id string `gae:"$id"`
 }
 
 type Doubler struct {
         S string
         I int64
         B bool
 }
 
@@ skipping 17 matching lines @@
                                 props[i].SetValue(v+v, props[i].IndexSetting())
                         case int64:
                                 // + means integer addition.
                                 props[i].SetValue(v+v, props[i].IndexSetting())
                         }
                 }
         }
         return propMap, nil
 }
 
-func (d *Doubler) GetMeta(string) (interface{}, error) { return nil, ErrMetaFieldUnset }
-func (d *Doubler) SetMeta(string, interface{}) error   { return ErrMetaFieldUnset }
-func (d *Doubler) Problem() error                      { return nil }
+func (d *Doubler) GetMeta(string) (interface{}, error)                   { return nil, ErrMetaFieldUnset }
+func (d *Doubler) GetMetaDefault(_ string, dflt interface{}) interface{} { return dflt }
+func (d *Doubler) SetMeta(string, interface{}) error                     { return ErrMetaFieldUnset }
+func (d *Doubler) Problem() error                                        { return nil }
 
 var _ PropertyLoadSaver = (*Doubler)(nil)
 
 type Deriver struct {
         S, Derived, Ignored string
 }
 
 func (d *Deriver) Load(props PropertyMap) error {
         for name, p := range props {
                 if name != "S" {
                         continue
                 }
                 d.S = p[0].Value().(string)
                 d.Derived = "derived+" + d.S
         }
         return nil
 }
 
 func (d *Deriver) Save(withMeta bool) (PropertyMap, error) {
         return map[string][]Property{
                 "S": {mp(d.S)},
         }, nil
 }
 
-func (d *Deriver) GetMeta(string) (interface{}, error) { return nil, ErrMetaFieldUnset }
-func (d *Deriver) SetMeta(string, interface{}) error   { return ErrMetaFieldUnset }
-func (d *Deriver) Problem() error                      { return nil }
+func (d *Deriver) GetMeta(string) (interface{}, error)                   { return nil, ErrMetaFieldUnset }
+func (d *Deriver) GetMetaDefault(_ string, dflt interface{}) interface{} { return dflt }
+func (d *Deriver) SetMeta(string, interface{}) error                     { return ErrMetaFieldUnset }
+func (d *Deriver) Problem() error                                        { return nil }
 
 var _ PropertyLoadSaver = (*Deriver)(nil)
 
 type BK struct {
         Key blobstore.Key
 }
 
 type Convertable []int64
 
 var _ PropertyConverter = (*Convertable)(nil)
@@ skipping 1139 matching lines @@
                                         // We therefore test equality explicitly, instead of relying on reflect.DeepEqual.
                                         So(gotT.T.Equal(tc.want.(*T).T), ShouldBeTrue)
                                 } else {
                                         So(got, ShouldResemble, tc.want)
                                 }
                         })
                 }
         })
 }
 
-func TestSpecial(t *testing.T) {
+func TestMeta(t *testing.T) {
         t.Parallel()
 
-        Convey("Test special fields", t, func() {
+        Convey("Test meta fields", t, func() {
                 Convey("Can retrieve from struct", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         val, err := pls.GetMeta("id")
                         So(err, ShouldBeNil)
                         So(val, ShouldEqual, 100)
 
                         val, err = pls.GetMeta("kind")
                         So(err, ShouldBeNil)
                         So(val, ShouldEqual, "whatnow")
+
+                        So(pls.GetMetaDefault("kind", "zappo"), ShouldEqual, "whatnow")
+                        So(pls.GetMetaDefault("id", "stringID"), ShouldEqual, "stringID")
+                        So(pls.GetMetaDefault("id", 6), ShouldEqual, 100)
                 })
 
                 Convey("Getting something not there is an error", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         _, err := pls.GetMeta("wat")
                         So(err, ShouldEqual, ErrMetaFieldUnset)
                 })
 
+                Convey("Default works for missing fields", func() {
+                        o := &N0{ID: 100}
+                        pls := GetPLS(o)
+                        So(pls.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                })
+
                 Convey("getting/setting from a bad struct is an error", func() {
                         o := &Recursive{}
                         pls := GetPLS(o)
                         _, err := pls.GetMeta("wat")
                         So(err, ShouldNotBeNil)
 
                         err = pls.SetMeta("wat", 100)
                         So(err, ShouldNotBeNil)
                 })
 
-                Convey("can assign values to exported special fields", func() {
+                Convey("Default works for bad structs", func() {
+                        o := &Recursive{}
+                        pls := GetPLS(o)
+                        So(pls.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                })
+
+                Convey("can assign values to exported meta fields", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         err := pls.SetMeta("id", int64(200))
                         So(err, ShouldBeNil)
                         So(o.ID, ShouldEqual, 200)
 
                 })
 
                 Convey("assigning to unsassiagnable fields is a simple error", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         err := pls.SetMeta("kind", "hi")
                         So(err.Error(), ShouldContainSubstring, "unexported field")
 
                         err = pls.SetMeta("noob", "hi")
                         So(err, ShouldEqual, ErrMetaFieldUnset)
                 })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
                 Convey("multiple overlapping fields is an error", func() {
-                        o := &BadSpecial{}
+                        o := &BadMeta{}
                         pls := GetPLS(o)
                         err := pls.Load(nil)
                         So(err, ShouldErrLike, "multiple times")
                         e := pls.Problem()
                         _, err = pls.Save(true)
                         So(err, ShouldEqual, e)
                         err = pls.Load(nil)
                         So(err, ShouldEqual, e)
                 })
 
@@ skipping 105 matching lines @@
 
                 Convey("Bad default meta type", func() {
                         type BadDefault struct {
                                 Val time.Time `gae:"$meta,tomorrow"`
                         }
                         pls := GetPLS(&BadDefault{})
                         So(pls.Problem().Error(), ShouldContainSubstring, "bad type")
                 })
         })
 }