Fix error message from KeyForObj when passing an invalid struct.

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 561 matching lines @@
 func (i *IDParser) getFullID() string {
         return fmt.Sprintf("%s|%d", i.parent, i.id)
 }
 
 func (i *IDParser) GetAllMeta() PropertyMap {
         pm := GetPLS(i).GetAllMeta()
         pm.SetMeta("id", i.getFullID())
         return pm
 }
 
-func (i *IDParser) GetMeta(key string) (interface{}, error) {
+func (i *IDParser) GetMeta(key string) (interface{}, bool) {
         if key == "id" {
-                return i.getFullID(), nil
+                return i.getFullID(), true
         }
         return GetPLS(i).GetMeta(key)
 }
 
-func (i *IDParser) GetMetaDefault(key string, dflt interface{}) interface{} {
-        return GetMetaDefaultImpl(i.GetMeta, key, dflt)
-}
-
-func (i *IDParser) SetMeta(key string, value interface{}) (err error) {
+func (i *IDParser) SetMeta(key string, value interface{}) bool {
         if key == "id" {
                 // let the panics flooowwww
                 vS := strings.SplitN(value.(string), "|", 2)
                 i.parent = vS[0]
+                var err error
                 i.id, err = strconv.ParseInt(vS[1], 10, 64)
-                return
+                if err != nil {
+                        panic(err)
+                }
+                return true
         }
         return GetPLS(i).SetMeta(key, value)
 }
 
 type KindOverride struct {
         ID int64 `gae:"$id"`
 
         customKind string `gae:"-"`
 }
 
 var _ MetaGetterSetter = (*KindOverride)(nil)
 
 func (i *KindOverride) GetAllMeta() PropertyMap {
         pm := GetPLS(i).GetAllMeta()
         if i.customKind != "" {
                 pm.SetMeta("kind", i.customKind)
         }
         return pm
 }
 
-func (i *KindOverride) GetMeta(key string) (interface{}, error) {
+func (i *KindOverride) GetMeta(key string) (interface{}, bool) {
         if key == "kind" && i.customKind != "" {
-                return i.customKind, nil
+                return i.customKind, true
         }
         return GetPLS(i).GetMeta(key)
 }
 
-func (i *KindOverride) GetMetaDefault(key string, dflt interface{}) interface{} {
-        return GetMetaDefaultImpl(i.GetMeta, key, dflt)
-}
-
-func (i *KindOverride) SetMeta(key string, value interface{}) error {
+func (i *KindOverride) SetMeta(key string, value interface{}) bool {
         if key == "kind" {
                 kind := value.(string)
                 if kind != "KindOverride" {
                         i.customKind = kind
                 } else {
                         i.customKind = ""
                 }
-                return nil
+                return true
         }
-        return ErrMetaFieldUnset
+        return GetPLS(i).SetMeta(key, value)
 }
 
 type EmbeddedID struct {
         Thing string
         Val   int
 }
 
 var _ PropertyConverter = (*EmbeddedID)(nil)
 
 func (e *EmbeddedID) ToProperty() (ret Property, err error) {
@@ skipping 963 matching lines @@
 
         checkErr := func(actual interface{}, expected string) bool {
                 if expected == "" {
                         So(actual, ShouldErrLike, nil)
                 } else {
                         So(actual, ShouldErrLike, expected)
                 }
                 return expected != ""
         }
 
+        getPLSErr := func(obj interface{}) (pls PropertyLoadSaver, err error) {
+                defer func() {
+                        if v := recover(); v != nil {
+                                err = v.(error)
+                        }
+                }()
+                pls = GetPLS(obj)
+                return
+        }
+
         Convey("Test round-trip", t, func() {
                 for _, tc := range testCases {
                         tc := tc
                         Convey(tc.desc, func() {
                                 pls, ok := tc.src.(PropertyLoadSaver)
                                 if !ok {
-                                        pls = GetPLS(tc.src)
-                                }
-                                if checkErr(pls.Problem(), tc.plsErr) {
-                                        return
+                                        var err error
+                                        pls, err = getPLSErr(tc.src)
+                                        if checkErr(err, tc.plsErr) {
+                                                return
+                                        }
                                 }
                                 So(pls, ShouldNotBeNil)
 
                                 savedProps, err := pls.Save(false)
                                 if checkErr(err, tc.saveErr) {
                                         return
                                 }
                                 So(savedProps, ShouldNotBeNil)
 
                                 var got interface{}
                                 if _, ok := tc.want.(PropertyMap); ok {
                                         pls = PropertyMap{}
                                         got = pls
                                 } else {
                                         got = reflect.New(reflect.TypeOf(tc.want).Elem()).Interface()
                                         if pls, ok = got.(PropertyLoadSaver); !ok {
-                                                pls = GetPLS(got)
+                                                var err error
+                                                pls, err = getPLSErr(got)
+                                                if checkErr(err, tc.plsLoadErr) {
+                                                        return
+                                                }
                                         }
                                 }
 
-                                if checkErr(pls.Problem(), tc.plsLoadErr) {
-                                        return
-                                }
                                 So(pls, ShouldNotBeNil)
 
                                 err = pls.Load(savedProps)
                                 if checkErr(err, tc.loadErr) {
                                         return
                                 }
                                 if tc.want == nil {
                                         return
                                 }
 
                                 if gotT, ok := got.(*T); ok {
                                         // Round tripping a time.Time can result in a different time.Location: Local instead of UTC.
                                         // 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 TestMeta(t *testing.T) {
         t.Parallel()
 
         Convey("Test meta fields", t, func() {
                 Convey("Can retrieve from struct", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
-                        val, err := mgs.GetMeta("id")
-                        So(err, ShouldBeNil)
+                        val, ok := mgs.GetMeta("id")
+                        So(ok, ShouldBeTrue)
                         So(val, ShouldEqual, 100)
 
-                        val, err = mgs.GetMeta("kind")
-                        So(err, ShouldBeNil)
+                        val, ok = mgs.GetMeta("kind")
+                        So(ok, ShouldBeTrue)
                         So(val, ShouldEqual, "whatnow")
 
-                        So(mgs.GetMetaDefault("kind", "zappo"), ShouldEqual, "whatnow")
-                        So(mgs.GetMetaDefault("id", "stringID"), ShouldEqual, "stringID")
-                        So(mgs.GetMetaDefault("id", 6), ShouldEqual, 100)
+                        So(GetMetaDefault(mgs, "kind", "zappo"), ShouldEqual, "whatnow")
+                        So(GetMetaDefault(mgs, "id", "stringID"), ShouldEqual, "stringID")
+                        So(GetMetaDefault(mgs, "id", 6), ShouldEqual, 100)
                 })
 
                 Convey("Getting something not there is an error", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
-                        _, err := mgs.GetMeta("wat")
-                        So(err, ShouldEqual, ErrMetaFieldUnset)
+                        _, ok := mgs.GetMeta("wat")
+                        So(ok, ShouldBeFalse)
                 })
 
                 Convey("Default works for missing fields", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
-                        So(mgs.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                        So(GetMetaDefault(mgs, "whozit", 10), ShouldEqual, 10)
                 })
 
-                Convey("getting/setting from a bad struct is an error", func() {
-                        o := &Recursive{}
-                        mgs := getMGS(o)
-                        _, err := mgs.GetMeta("wat")
-                        So(err, ShouldNotBeNil)
-
-                        err = mgs.SetMeta("wat", 100)
-                        So(err, ShouldNotBeNil)
-                })
-
-                Convey("Default works for bad structs", func() {
-                        o := &Recursive{}
-                        mgs := getMGS(o)
-                        So(mgs.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                Convey("getting mgs for bad struct is an error", func() {
+                        So(func() { getMGS(&Recursive{}) }, ShouldPanicLike,
+                                `field "R" is recursively defined`)
                 })
 
                 Convey("can assign values to exported meta fields", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
-                        err := mgs.SetMeta("id", int64(200))
-                        So(err, ShouldBeNil)
+                        So(mgs.SetMeta("id", int64(200)), ShouldBeTrue)
                         So(o.ID, ShouldEqual, 200)
-
                 })
 
-                Convey("assigning to unsassiagnable fields is a simple error", func() {
+                Convey("assigning to unsassiagnable fields returns !ok", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
-                        err := mgs.SetMeta("kind", "hi")
-                        So(err.Error(), ShouldContainSubstring, "unexported field")
-
-                        err = mgs.SetMeta("noob", "hi")
-                        So(err, ShouldEqual, ErrMetaFieldUnset)
+                        So(mgs.SetMeta("kind", "hi"), ShouldBeFalse)
+                        So(mgs.SetMeta("noob", "hi"), ShouldBeFalse)
                 })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
                 Convey("a simple struct has a default $kind", func() {
                         So(GetPLS(&Simple{}).GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$kind": []Property{mpNI("Simple")},
                         })
                 })
 
                 Convey("multiple overlapping fields is an error", func() {
                         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)
+                        So(func() { GetPLS(o) }, ShouldPanicLike, "multiple times")
                 })
 
                 Convey("empty property names are invalid", func() {
                         So(validPropertyName(""), ShouldBeFalse)
                 })
 
                 Convey("attempting to get a PLS for a non *struct is an error", func() {
-                        pls := GetPLS((*[]string)(nil))
-                        So(pls.Problem(), ShouldEqual, ErrInvalidEntityType)
-
-                        Convey("the error PLS can still be used", func() {
-                                k, _ := pls.GetMeta("kind")
-                                So(k, ShouldBeNil)
-
-                                props := pls.GetAllMeta()
-                                So(props, ShouldResemble, PropertyMap{
-                                        "$kind": []Property{mpNI("")},
-                                })
-
-                                _, err := pls.Save(true)
-                                So(err, ShouldNotBeNil)
-                        })
+                        So(func() { GetPLS((*[]string)(nil)) }, ShouldPanicLike,
+                                "cannot GetPLS(*[]string): not a pointer-to-struct")
                 })
 
                 Convey("convertible meta default types", func() {
                         type OKDefaults struct {
                                 When   string `gae:"$when,tomorrow"`
                                 Amount int64  `gae:"$amt,100"`
                                 DoIt   Toggle `gae:"$doit,on"`
                         }
                         okd := &OKDefaults{}
-                        pls := GetPLS(okd)
                         mgs := getMGS(okd)
-                        So(pls.Problem(), ShouldBeNil)
 
-                        v, err := mgs.GetMeta("when")
-                        So(err, ShouldBeNil)
+                        v, ok := mgs.GetMeta("when")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, "tomorrow")
 
-                        v, err = mgs.GetMeta("amt")
-                        So(err, ShouldBeNil)
+                        v, ok = mgs.GetMeta("amt")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(100))
 
                         So(okd.DoIt, ShouldEqual, Auto)
-                        v, err = mgs.GetMeta("doit")
-                        So(err, ShouldBeNil)
+                        v, ok = mgs.GetMeta("doit")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldBeTrue)
 
-                        err = mgs.SetMeta("doit", false)
-                        So(err, ShouldBeNil)
-                        v, err = mgs.GetMeta("doit")
-                        So(err, ShouldBeNil)
+                        So(mgs.SetMeta("doit", false), ShouldBeTrue)
+                        v, ok = mgs.GetMeta("doit")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldBeFalse)
                         So(okd.DoIt, ShouldEqual, Off)
 
-                        err = mgs.SetMeta("doit", true)
-                        So(err, ShouldBeNil)
-                        v, err = mgs.GetMeta("doit")
-                        So(err, ShouldBeNil)
+                        So(mgs.SetMeta("doit", true), ShouldBeTrue)
+                        v, ok = mgs.GetMeta("doit")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldBeTrue)
                         So(okd.DoIt, ShouldEqual, On)
 
                         Convey("Toggle fields REQUIRE a default", func() {
                                 type BadToggle struct {
                                         Bad Toggle `gae:"$wut"`
                                 }
-                                pls := GetPLS(&BadToggle{})
-                                So(pls.Problem().Error(), ShouldContainSubstring, "bad/missing default")
+                                So(func() { GetPLS(&BadToggle{}) }, ShouldPanicLike, "bad/missing default")
                         })
                 })
 
                 Convey("meta fields can be saved", func() {
                         type OKDefaults struct {
                                 When   string `gae:"$when,tomorrow"`
                                 Amount int64  `gae:"$amt,100"`
                         }
                         pls := GetPLS(&OKDefaults{})
                         pm, err := pls.Save(true)
                         So(err, ShouldBeNil)
                         So(pm, ShouldResemble, PropertyMap{
                                 "$when": {mpNI("tomorrow")},
                                 "$amt":  {mpNI(100)},
                                 "$kind": {mpNI("OKDefaults")},
                         })
 
-                        v, err := pm.GetMeta("when")
-                        So(err, ShouldBeNil)
+                        v, ok := pm.GetMeta("when")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, "tomorrow")
 
-                        v, err = pm.GetMeta("amt")
-                        So(err, ShouldBeNil)
+                        v, ok = pm.GetMeta("amt")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(100))
                 })
 
                 Convey("default are optional", func() {
                         type OverrideDefault struct {
                                 Val int64 `gae:"$val"`
                         }
                         o := &OverrideDefault{}
                         mgs := getMGS(o)
 
-                        v, err := mgs.GetMeta("val")
-                        So(err, ShouldBeNil)
+                        v, ok := mgs.GetMeta("val")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(0))
                 })
 
                 Convey("overridable defaults", func() {
                         type OverrideDefault struct {
                                 Val int64 `gae:"$val,100"`
                         }
                         o := &OverrideDefault{}
                         mgs := getMGS(o)
 
-                        v, err := mgs.GetMeta("val")
-                        So(err, ShouldBeNil)
+                        v, ok := mgs.GetMeta("val")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(100))
 
                         o.Val = 10
-                        v, err = mgs.GetMeta("val")
-                        So(err, ShouldBeNil)
+                        v, ok = mgs.GetMeta("val")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(10))
                 })
 
                 Convey("Derived metadata fields", func() {
                         type DerivedString string
                         type DerivedInt int16
                         type DerivedStruct struct {
                                 ID  DerivedString `gae:"$id"`
                                 Foo DerivedInt    `gae:"$foo"`
                         }
                         o := &DerivedStruct{"hello", 10}
                         mgs := getMGS(o)
-                        v, err := mgs.GetMeta("id")
-                        So(err, ShouldBeNil)
+                        v, ok := mgs.GetMeta("id")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, "hello")
 
-                        v, err = mgs.GetMeta("foo")
-                        So(err, ShouldBeNil)
+                        v, ok = mgs.GetMeta("foo")
+                        So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(10))
 
-                        So(mgs.SetMeta("id", "nerds"), ShouldBeNil)
-                        So(mgs.SetMeta("foo", 20), ShouldBeNil)
+                        So(mgs.SetMeta("id", "nerds"), ShouldBeTrue)
+                        So(mgs.SetMeta("foo", 20), ShouldBeTrue)
                         So(o.ID, ShouldEqual, DerivedString("nerds"))
                         So(o.Foo, ShouldEqual, DerivedInt(20))
                 })
 
                 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")
+                        So(func() { GetPLS(&BadDefault{}) }, ShouldPanicLike, "bad type")
                 })
 
                 Convey("MetaGetterSetter implementation (IDParser)", func() {
                         idp := &IDParser{parent: "moo", id: 100}
                         mgs := getMGS(idp)
-                        So(mgs.GetMetaDefault("id", ""), ShouldEqual, "moo|100")
-                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "CoolKind")
+                        So(GetMetaDefault(mgs, "id", ""), ShouldEqual, "moo|100")
 
-                        So(mgs.SetMeta("kind", "Something"), ShouldErrLike, "unexported field")
-                        So(mgs.SetMeta("id", "happy|27"), ShouldBeNil)
+                        So(GetMetaDefault(mgs, "kind", ""), ShouldEqual, "CoolKind")
+
+                        So(mgs.SetMeta("kind", "Something"), ShouldBeFalse)
+                        So(mgs.SetMeta("id", "happy|27"), ShouldBeTrue)
 
                         So(idp.parent, ShouldEqual, "happy")
                         So(idp.id, ShouldEqual, 27)
 
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {mpNI("happy|27")},
                                 "$kind": {mpNI("CoolKind")},
                         })
                 })
 
                 Convey("MetaGetterSetter implementation (KindOverride)", func() {
                         ko := &KindOverride{ID: 20}
                         mgs := getMGS(ko)
-                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "KindOverride")
+                        So(GetMetaDefault(mgs, "kind", ""), ShouldEqual, "KindOverride")
 
                         ko.customKind = "something"
-                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "something")
+                        So(GetMetaDefault(mgs, "kind", ""), ShouldEqual, "something")
 
-                        So(mgs.SetMeta("kind", "Nerp"), ShouldBeNil)
+                        So(mgs.SetMeta("kind", "Nerp"), ShouldBeTrue)
                         So(ko.customKind, ShouldEqual, "Nerp")
 
-                        So(mgs.SetMeta("kind", "KindOverride"), ShouldBeNil)
+                        So(mgs.SetMeta("kind", "KindOverride"), ShouldBeTrue)
                         So(ko.customKind, ShouldEqual, "")
 
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {mpNI(20)},
                                 "$kind": {mpNI("KindOverride")},
                         })
                         ko.customKind = "wut"
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {mpNI(20)},
                                 "$kind": {mpNI("wut")},
                         })
 
                         props, err := GetPLS(ko).Save(true)
                         So(err, ShouldBeNil)
                         So(props, ShouldResemble, PropertyMap{
                                 "$id":   {mpNI(20)},
                                 "$kind": {mpNI("wut")},
                         })
                 })
 
                 Convey("Embeddable Metadata structs", func() {
                         ide := &IDEmbedder{EmbeddedID{"hello", 10}}
                         pls := GetPLS(ide)
-                        val, err := pls.GetMeta("id")
-                        So(err, ShouldBeNil)
+                        val, ok := pls.GetMeta("id")
+                        So(ok, ShouldBeTrue)
                         So(val, ShouldEqual, "hello|10")
 
-                        So(pls.SetMeta("id", "sup|1337"), ShouldBeNil)
+                        So(pls.SetMeta("id", "sup|1337"), ShouldBeTrue)
                         So(ide.EmbeddedID, ShouldResemble, EmbeddedID{"sup", 1337})
 
                         So(pls.GetAllMeta(), ShouldResembleV, PropertyMap{
                                 "$id":   {mpNI("sup|1337")},
                                 "$kind": {mpNI("IDEmbedder")},
                         })
                 })
         })
 }