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 568 matching lines @@
         return pm
 }
 
 func (i *IDParser) GetMeta(key string) (interface{}, error) {
         if key == "id" {
                 return i.getFullID(), nil
         }
         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) {
         if key == "id" {
                 // let the panics flooowwww
                 vS := strings.SplitN(value.(string), "|", 2)
                 i.parent = vS[0]
                 i.id, err = strconv.ParseInt(vS[1], 10, 64)
                 return
         }
         return GetPLS(i).SetMeta(key, value)
 }
@@ skipping 14 matching lines @@
         return pm
 }
 
 func (i *KindOverride) GetMeta(key string) (interface{}, error) {
         if key == "kind" && i.customKind != "" {
                 return i.customKind, nil
         }
         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 {
         if key == "kind" {
                 kind := value.(string)
                 if kind != "KindOverride" {
                         i.customKind = kind
                 } else {
                         i.customKind = ""
                 }
                 return nil
         }
@@ skipping 978 matching lines @@
                 } else {
                         So(actual, ShouldErrLike, expected)
                 }
                 return expected != ""
         }
 
         Convey("Test round-trip", t, func() {
                 for _, tc := range testCases {
                         tc := tc
                         Convey(tc.desc, func() {
-                                pls, ok := tc.src.(PropertyLoadSaver)
+                                pls, ok := tc.src.(interface {
+                                        PropertyLoadSaver
+                                        Problem() error
+                                })

[iannucci, 2015/12/12 03:52:22]

This silliness is because of the way the tests are structured. No one should
ever need to do this for real.

                                 if !ok {
                                         pls = GetPLS(tc.src)
                                 }
                                 if checkErr(pls.Problem(), 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 {
+                                        if pls, ok = got.(interface {
+                                                PropertyLoadSaver
+                                                Problem() error
+                                        }); !ok {
                                                 pls = GetPLS(got)
                                         }
                                 }
 
                                 if checkErr(pls.Problem(), tc.plsLoadErr) {
                                         return
                                 }
                                 So(pls, ShouldNotBeNil)
 
                                 err = pls.Load(savedProps)
@@ skipping 24 matching lines @@
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
                         val, err := mgs.GetMeta("id")
                         So(err, ShouldBeNil)
                         So(val, ShouldEqual, 100)
 
                         val, err = mgs.GetMeta("kind")
                         So(err, ShouldBeNil)
                         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)
+                        v, err := GetMetaDefault(mgs, "kind", "zappo")
+                        So(err, ShouldBeNil)
+                        So(v, ShouldEqual, "whatnow")
+
+                        v, err = GetMetaDefault(mgs, "id", "stringID")
+                        So(err, ShouldBeNil)
+                        So(v, ShouldEqual, "stringID")
+
+                        v, err = GetMetaDefault(mgs, "id", 6)
+                        So(err, ShouldBeNil)
+                        So(v, 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)
                 })
 
                 Convey("Default works for missing fields", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
-                        So(mgs.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                        v, err := GetMetaDefault(mgs, "whozit", 10)
+                        So(err, ShouldBeNil)
+                        So(v, 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() {
+                Convey("Default fails for bad structs", func() {
                         o := &Recursive{}
                         mgs := getMGS(o)
-                        So(mgs.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                        _, err := GetMetaDefault(mgs, "whozit", 10)
+                        So(err, ShouldErrLike, `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(o.ID, ShouldEqual, 200)
 
                 })
 
                 Convey("assigning to unsassiagnable fields is a simple error", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
                         err := mgs.SetMeta("kind", "hi")
-                        So(err.Error(), ShouldContainSubstring, "unexported field")
+                        So(err, ShouldErrLike, "unexported field")
 
                         err = mgs.SetMeta("noob", "hi")
                         So(err, ShouldEqual, ErrMetaFieldUnset)
                 })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
                 Convey("a simple struct has a default $kind", func() {
                         So(GetPLS(&Simple{}).GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$kind": []Property{mpNI("Simple")},
@@ skipping 70 matching lines @@
                         v, err = mgs.GetMeta("doit")
                         So(err, ShouldBeNil)
                         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(pls.Problem(), ShouldErrLike, "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)
@@ skipping 63 matching lines @@
                         So(mgs.SetMeta("foo", 20), ShouldBeNil)
                         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(pls.Problem(), ShouldErrLike, "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")
+                        v, err := GetMetaDefault(mgs, "id", "")
+                        So(err, ShouldBeNil)
+                        So(v, ShouldEqual, "moo|100")
+
+                        v, err = GetMetaDefault(mgs, "kind", "")
+                        So(err, ShouldBeNil)
+                        So(v, ShouldEqual, "CoolKind")
 
                         So(mgs.SetMeta("kind", "Something"), ShouldErrLike, "unexported field")
                         So(mgs.SetMeta("id", "happy|27"), ShouldBeNil)
 
                         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")
+                        v, err := GetMetaDefault(mgs, "kind", "")
+                        So(err, ShouldBeNil)
+                        So(v, ShouldEqual, "KindOverride")
 
                         ko.customKind = "something"
-                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "something")
+                        v, err = GetMetaDefault(mgs, "kind", "")
+                        So(err, ShouldBeNil)
+                        So(v, ShouldEqual, "something")
 
                         So(mgs.SetMeta("kind", "Nerp"), ShouldBeNil)
                         So(ko.customKind, ShouldEqual, "Nerp")
 
                         So(mgs.SetMeta("kind", "KindOverride"), ShouldBeNil)
                         So(ko.customKind, ShouldEqual, "")
 
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {mpNI(20)},
                                 "$kind": {mpNI("KindOverride")},
@@ skipping 22 matching lines @@
                         So(pls.SetMeta("id", "sup|1337"), ShouldBeNil)
                         So(ide.EmbeddedID, ShouldResemble, EmbeddedID{"sup", 1337})
 
                         So(pls.GetAllMeta(), ShouldResembleV, PropertyMap{
                                 "$id":   {mpNI("sup|1337")},
                                 "$kind": {mpNI("IDEmbedder")},
                         })
                 })
         })
 }