Decouple PLS from MGS.

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 357 matching lines @@
                                 So(props[i].SetValue(v+v, props[i].IndexSetting()), ShouldBeNil)
                         case int64:
                                 // + means integer addition.
                                 So(props[i].SetValue(v+v, props[i].IndexSetting()), ShouldBeNil)
                         }
                 }
         }
         return propMap, nil
 }
 
-func (d *Doubler) GetAllMeta() PropertyMap                               { 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 }
+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) GetAllMeta() PropertyMap                               { 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 }
+func (d *Deriver) Problem() error { return nil }
 
 var _ PropertyLoadSaver = (*Deriver)(nil)
 
+type Augmenter struct {
+        S string
+
+        g string `gae:"-"`
+}
+
+func (a *Augmenter) Load(props PropertyMap) error {
+        if e := props["Extra"]; len(e) > 0 {
+                a.g = e[0].Value().(string)
+                delete(props, "Extra")
+        }
+        if err := GetPLS(a).Load(props); err != nil {
+                return err
+        }
+        return nil
+}
+
+func (a *Augmenter) Save(withMeta bool) (PropertyMap, error) {
+        props, err := GetPLS(a).Save(withMeta)
+        if err != nil {
+                return nil, err
+        }
+        props["Extra"] = []Property{MkProperty("ohai!")}
+        return props, nil
+}
+
+func (a *Augmenter) Problem() error { return nil }
+
+var _ PropertyLoadSaver = (*Augmenter)(nil)
+
 type BK struct {
         Key blobstore.Key
 }
 
 type Convertable []int64
 
 var _ PropertyConverter = (*Convertable)(nil)
 
 func (c *Convertable) ToProperty() (ret Property, err error) {
         buf := make([]string, len(*c))
@@ skipping 120 matching lines @@
         id     int64  `gae:"-"`
 }
 
 var _ MetaGetterSetter = (*IDParser)(nil)
 
 func (i *IDParser) getFullID() string {
         return fmt.Sprintf("%s|%d", i.parent, i.id)
 }
 
 func (i *IDParser) GetAllMeta() PropertyMap {
-        pm := PropertyMap{}
+        pm := GetPLS(i).GetAllMeta()
         pm.SetMeta("id", i.getFullID())
         return pm
 }
 
 func (i *IDParser) GetMeta(key string) (interface{}, error) {
         if key == "id" {
                 return i.getFullID(), nil
         }
-        return nil, ErrMetaFieldUnset
+        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 ErrMetaFieldUnset
+        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 := PropertyMap{}
+        pm := GetPLS(i).GetAllMeta()
         if i.customKind != "" {
                 pm.SetMeta("kind", i.customKind)
         }
         return pm
 }
 
 func (i *KindOverride) GetMeta(key string) (interface{}, error) {
         if key == "kind" && i.customKind != "" {
                 return i.customKind, nil
         }
-        return nil, ErrMetaFieldUnset
+        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
         }
         return ErrMetaFieldUnset
 }
 
+type Simple struct {
+}
+
 type testCase struct {
         desc       string
         src        interface{}
         want       interface{}
         plsErr     string
         saveErr    string
         plsLoadErr string
         loadErr    string
 }
 
@@ skipping 548 matching lines @@
         {
                 desc: "save struct load deriver",
                 src:  &X0{S: "s", I: 1},
                 want: &Deriver{S: "s", Derived: "derived+s"},
         },
         {
                 desc: "save deriver load struct",
                 src:  &Deriver{S: "s", Derived: "derived+s", Ignored: "ignored"},
                 want: &X0{S: "s"},
         },
+        {
+                desc: "augmenter save",
+                src:  &Augmenter{S: "s"},
+                want: PropertyMap{
+                        "S":     {mp("s")},
+                        "Extra": {mp("ohai!")},
+                },
+        },
+        {
+                desc: "augmenter load",
+                src: PropertyMap{
+                        "S":     {mp("s")},
+                        "Extra": {mp("kthxbye!")},
+                },
+                want: &Augmenter{S: "s", g: "kthxbye!"},
+        },
         // Regression: CL 25062824 broke handling of appengine.BlobKey fields.
         {
                 desc: "appengine.BlobKey",
                 src:  &BK{Key: "blah"},
                 want: &BK{Key: "blah"},
         },
         {
                 desc: "zero time.Time",
                 src:  &T{T: time.Time{}},
                 want: &T{T: time.Time{}},
@@ skipping 403 matching lines @@
                 }
         })
 }
 
 func TestMeta(t *testing.T) {
         t.Parallel()
 
         Convey("Test meta fields", t, func() {
                 Convey("Can retrieve from struct", func() {
                         o := &N0{ID: 100}
-                        pls := GetPLS(o)
-                        val, err := pls.GetMeta("id")
+                        mgs := getMGS(o)
+                        val, err := mgs.GetMeta("id")
                         So(err, ShouldBeNil)
                         So(val, ShouldEqual, 100)
 
-                        val, err = pls.GetMeta("kind")
+                        val, err = mgs.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)
+                        So(mgs.GetMetaDefault("kind", "zappo"), ShouldEqual, "whatnow")
+                        So(mgs.GetMetaDefault("id", "stringID"), ShouldEqual, "stringID")
+                        So(mgs.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")
+                        mgs := getMGS(o)
+                        _, err := mgs.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)
+                        mgs := getMGS(o)
+                        So(mgs.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")
+                        mgs := getMGS(o)
+                        _, err := mgs.GetMeta("wat")
                         So(err, ShouldNotBeNil)
 
-                        err = pls.SetMeta("wat", 100)
+                        err = mgs.SetMeta("wat", 100)
                         So(err, ShouldNotBeNil)
                 })
 
                 Convey("Default works for bad structs", func() {
                         o := &Recursive{}
-                        pls := GetPLS(o)
-                        So(pls.GetMetaDefault("whozit", 10), ShouldEqual, 10)
+                        mgs := getMGS(o)
+                        So(mgs.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))
+                        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}
-                        pls := GetPLS(o)
-                        err := pls.SetMeta("kind", "hi")
+                        mgs := getMGS(o)
+                        err := mgs.SetMeta("kind", "hi")
                         So(err.Error(), ShouldContainSubstring, "unexported field")
 
-                        err = pls.SetMeta("noob", "hi")
+                        err = mgs.SetMeta("noob", "hi")
                         So(err, ShouldEqual, ErrMetaFieldUnset)
                 })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
+                Convey("a simple struct has a default $kind", func() {
+                        pls := GetPLS(&Simple{})

[iannucci, 2015/10/30 21:47:07]

may be clearer to just put `type Simple struct{}` in this function. *shrug*

+                        So(pls.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)
                 })
 
                 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("")},
+                                })
+                        })
                 })
 
                 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 := pls.GetMeta("when")
+                        v, err := mgs.GetMeta("when")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, "tomorrow")
 
-                        v, err = pls.GetMeta("amt")
+                        v, err = mgs.GetMeta("amt")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(100))
 
                         So(okd.DoIt, ShouldEqual, Auto)
-                        v, err = pls.GetMeta("doit")
+                        v, err = mgs.GetMeta("doit")
                         So(err, ShouldBeNil)
                         So(v, ShouldBeTrue)
 
-                        err = pls.SetMeta("doit", false)
+                        err = mgs.SetMeta("doit", false)
                         So(err, ShouldBeNil)
-                        v, err = pls.GetMeta("doit")
+                        v, err = mgs.GetMeta("doit")
                         So(err, ShouldBeNil)
                         So(v, ShouldBeFalse)
                         So(okd.DoIt, ShouldEqual, Off)
 
-                        err = pls.SetMeta("doit", true)
+                        err = mgs.SetMeta("doit", true)
                         So(err, ShouldBeNil)
-                        v, err = pls.GetMeta("doit")
+                        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")
@@ skipping 21 matching lines @@
                         v, err = pm.GetMeta("amt")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(100))
                 })
 
                 Convey("default are optional", func() {
                         type OverrideDefault struct {
                                 Val int64 `gae:"$val"`
                         }
                         o := &OverrideDefault{}
-                        pls := GetPLS(o)
+                        mgs := getMGS(o)
 
-                        v, err := pls.GetMeta("val")
+                        v, err := mgs.GetMeta("val")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(0))
                 })
 
                 Convey("overridable defaults", func() {
                         type OverrideDefault struct {
                                 Val int64 `gae:"$val,100"`
                         }
                         o := &OverrideDefault{}
-                        pls := GetPLS(o)
+                        mgs := getMGS(o)
 
-                        v, err := pls.GetMeta("val")
+                        v, err := mgs.GetMeta("val")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(100))
 
                         o.Val = 10
-                        v, err = pls.GetMeta("val")
+                        v, err = mgs.GetMeta("val")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(10))
                 })
 
                 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")
                 })
 
                 Convey("MetaGetterSetter implementation (IDParser)", func() {
                         idp := &IDParser{parent: "moo", id: 100}
-                        pls := GetPLS(idp)
-                        So(pls.GetMetaDefault("id", ""), ShouldEqual, "moo|100")
-                        So(pls.GetMetaDefault("kind", ""), ShouldEqual, "CoolKind")
+                        mgs := getMGS(idp)
+                        So(mgs.GetMetaDefault("id", ""), ShouldEqual, "moo|100")
+                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "CoolKind")
 
-                        So(pls.SetMeta("kind", "Something"), ShouldErrLike, "unexported field")
-                        So(pls.SetMeta("id", "happy|27"), ShouldBeNil)
+                        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(pls.GetAllMeta(), ShouldResemble, PropertyMap{
+                        So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {MkPropertyNI("happy|27")},
                                 "$kind": {MkPropertyNI("CoolKind")},
                         })
                 })
 
                 Convey("MetaGetterSetter implementation (KindOverride)", func() {
                         ko := &KindOverride{ID: 20}
-                        pls := GetPLS(ko)
-                        So(pls.GetMetaDefault("kind", ""), ShouldEqual, "KindOverride")
+                        mgs := getMGS(ko)
+                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "KindOverride")
 
                         ko.customKind = "something"
-                        So(pls.GetMetaDefault("kind", ""), ShouldEqual, "something")
+                        So(mgs.GetMetaDefault("kind", ""), ShouldEqual, "something")
 
-                        So(pls.SetMeta("kind", "Nerp"), ShouldBeNil)
+                        So(mgs.SetMeta("kind", "Nerp"), ShouldBeNil)
                         So(ko.customKind, ShouldEqual, "Nerp")
 
-                        So(pls.SetMeta("kind", "KindOverride"), ShouldBeNil)
+                        So(mgs.SetMeta("kind", "KindOverride"), ShouldBeNil)
                         So(ko.customKind, ShouldEqual, "")
 
-                        So(pls.GetAllMeta(), ShouldResemble, PropertyMap{
+                        So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {MkPropertyNI(20)},
                                 "$kind": {MkPropertyNI("KindOverride")},
                         })
                         ko.customKind = "wut"
-                        So(pls.GetAllMeta(), ShouldResemble, PropertyMap{
+                        So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$id":   {MkPropertyNI(20)},
                                 "$kind": {MkPropertyNI("wut")},
                         })
                 })
         })
 }