Differentiate between single- and multi- props.

service/datastore/datastore_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 64 matching lines @@
                 if v, ok := fq.eqFilts["$err_single"]; ok {
                         idx := fq.eqFilts["$err_single_idx"][0].Value().(int64)
                         if idx == int64(i) {
                                 return errors.New(v[0].Value().(string))
                         }
                 }
                 k := f.mkKey("Kind", i+1)
                 if i == 10 {
                         k = f.mkKey("Kind", "eleven")
                 }
-                pm := PropertyMap{"Value": {MkProperty(i)}}
+                pm := PropertyMap{"Value": MkProperty(i)}
                 if err := cb(k, pm, cursCB); err != nil {
                         if err == Stop {
                                 err = nil
                         }
                         return err
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) PutMulti(keys []*Key, vals []PropertyMap, cb NewKeyCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errFailAll
         }
         _, assertExtra := vals[0].GetMeta("assertExtra")
         for i, k := range keys {
                 err := error(nil)
                 if k.Kind() == "Fail" {
                         err = errFail
                 } else {
-                        So(vals[i]["Value"], ShouldResemble, []Property{MkProperty(i)})
+                        So(vals[i].Slice("Value"), ShouldResemble, PropertySlice{MkProperty(i)})
                         if assertExtra {
-                                So(vals[i]["Extra"], ShouldResemble, []Property{MkProperty("whoa")})
+                                So(vals[i].Slice("Extra"), ShouldResemble, PropertySlice{MkProperty("whoa")})
                         }
                         if k.IsIncomplete() {
                                 k = NewKey(k.AppID(), k.Namespace(), k.Kind(), "", int64(i+1), k.Parent())
                         }
                 }
                 cb(k, err)
         }
         return nil
 }
 
 const noSuchEntityID = 0xdead
 
 func (f *fakeDatastore) GetMulti(keys []*Key, _meta MultiMetaGetter, cb GetMultiCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errFailAll
         }
         for i, k := range keys {
                 if k.Kind() == "Fail" {
                         cb(nil, errFail)
                 } else if k.Kind() == "DNE" || k.IntID() == noSuchEntityID {
                         cb(nil, ErrNoSuchEntity)
                 } else {
-                        cb(PropertyMap{"Value": {MkProperty(i + 1)}}, nil)
+                        cb(PropertyMap{"Value": MkProperty(i + 1)}, nil)
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) DeleteMulti(keys []*Key, cb DeleteMultiCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errFailAll
         }
         for _, k := range keys {
@@ skipping 48 matching lines @@
         failSetMeta bool
 }
 
 var _ PropertyLoadSaver = (*FakePLS)(nil)
 
 func (f *FakePLS) Load(pm PropertyMap) error {
         if f.failLoad {
                 return errors.New("FakePLS.Load")
         }
         f.gotLoaded = true
-        f.Value = pm["Value"][0].Value().(int64)
+        f.Value = pm.Slice("Value")[0].Value().(int64)
         return nil
 }
 
 func (f *FakePLS) Save(withMeta bool) (PropertyMap, error) {
         if f.failSave {
                 return nil, errors.New("FakePLS.Save")
         }
         ret := PropertyMap{
-                "Value": {MkProperty(f.Value)},
-                "Extra": {MkProperty("whoa")},
+                "Value": MkProperty(f.Value),
+                "Extra": MkProperty("whoa"),
         }
         if withMeta {
                 id, _ := f.GetMeta("id")
                 So(ret.SetMeta("id", id), ShouldBeTrue)
                 if f.Kind == "" {
                         So(ret.SetMeta("kind", "FakePLS"), ShouldBeTrue)
                 } else {
                         So(ret.SetMeta("kind", f.Kind), ShouldBeTrue)
                 }
                 So(ret.SetMeta("assertExtra", true), ShouldBeTrue)
@@ skipping 73 matching lines @@
         case "kind":
                 return "plsChan", true
         case "id":
                 return "whyDoIExist", true
         }
         return nil, false
 }
 
 func (c plsChan) GetAllMeta() PropertyMap {
         return PropertyMap{
-                "kind": []Property{MkProperty("plsChan")},
-                "id":   []Property{MkProperty("whyDoIExist")},
+                "kind": MkProperty("plsChan"),
+                "id":   MkProperty("whyDoIExist"),
         }
 }
 
 type MGSWithNoKind struct {
         S string
 }
 
 func (s *MGSWithNoKind) GetMeta(key string) (interface{}, bool) {
         return nil, false
 }
 
 func (s *MGSWithNoKind) GetAllMeta() PropertyMap {
-        return PropertyMap{"$kind": []Property{MkProperty("ohai")}}
+        return PropertyMap{"$kind": MkProperty("ohai")}
 }
 
 func (s *MGSWithNoKind) SetMeta(key string, val interface{}) bool {
         return false
 }
 
 var _ MetaGetterSetter = (*MGSWithNoKind)(nil)
 
 func TestKeyForObj(t *testing.T) {
         t.Parallel()
@@ skipping 332 matching lines @@
                                         }
                                         So(ds.Put(fplss), ShouldBeNil)
                                         for i, fpls := range fplss {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
                                                 So(fpls.IntID, ShouldEqual, expect)
                                         }
 
-                                        pm := PropertyMap{"Value": {MkProperty(0)}, "$kind": {MkPropertyNI("Pmap")}}
+                                        pm := PropertyMap{"Value": MkProperty(0), "$kind": MkPropertyNI("Pmap")}
                                         So(ds.Put(pm), ShouldBeNil)
                                         So(ds.KeyForObj(pm).IntID(), ShouldEqual, 1)
                                 })
 
                                 Convey("[]P (map)", func() {
                                         pms := make([]PropertyMap, 7)
                                         for i := range pms {
                                                 pms[i] = PropertyMap{
-                                                        "$kind": {MkProperty("Pmap")},
-                                                        "Value": {MkProperty(i)},
+                                                        "$kind": MkProperty("Pmap"),
+                                                        "Value": MkProperty(i),
                                                 }
                                                 if i == 4 {
                                                         So(pms[i].SetMeta("id", int64(200)), ShouldBeTrue)
                                                 }
                                         }
                                         So(ds.Put(pms), ShouldBeNil)
                                         for i, pm := range pms {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
@@ skipping 17 matching lines @@
                                                         expect = 200
                                                 }
                                                 So(fpls.IntID, ShouldEqual, expect)
                                         }
                                 })
 
                                 Convey("[]*P (map)", func() {
                                         pms := make([]*PropertyMap, 7)
                                         for i := range pms {
                                                 pms[i] = &PropertyMap{
-                                                        "$kind": {MkProperty("Pmap")},
-                                                        "Value": {MkProperty(i)},
+                                                        "$kind": MkProperty("Pmap"),
+                                                        "Value": MkProperty(i),
                                                 }
                                                 if i == 4 {
                                                         So(pms[i].SetMeta("id", int64(200)), ShouldBeTrue)
                                                 }
                                         }
                                         So(ds.Put(pms), ShouldBeNil)
                                         for i, pm := range pms {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
                                                 So(ds.KeyForObj(*pm).String(), ShouldEqual, fmt.Sprintf("s~aid:ns:/Pmap,%d", expect))
                                         }
                                 })
 
                                 Convey("[]I", func() {
                                         ifs := []interface{}{
                                                 &CommonStruct{Value: 0},
                                                 &FakePLS{Value: 1},
-                                                PropertyMap{"Value": {MkProperty(2)}, "$kind": {MkPropertyNI("Pmap")}},
-                                                &PropertyMap{"Value": {MkProperty(3)}, "$kind": {MkPropertyNI("Pmap")}},
+                                                PropertyMap{"Value": MkProperty(2), "$kind": MkPropertyNI("Pmap")},
+                                                &PropertyMap{"Value": MkProperty(3), "$kind": MkPropertyNI("Pmap")},
                                         }
                                         So(ds.Put(ifs), ShouldBeNil)
                                         for i := range ifs {
                                                 switch i {
                                                 case 0:
                                                         So(ifs[i].(*CommonStruct).ID, ShouldEqual, 1)
                                                 case 1:
                                                         fpls := ifs[i].(*FakePLS)
                                                         So(fpls.IntID, ShouldEqual, 2)
                                                 case 2:
@@ skipping 265 matching lines @@
                                         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) error {
                                                 So(err, ShouldBeNil)
-                                                So(pm["Value"][0].Value(), ShouldEqual, 1)
+                                                So(pm.Slice("Value")[0].Value(), ShouldEqual, 1)
                                                 return nil
                                         }), ShouldBeNil)
                                 })
 
                                 Convey("but general failure to save is fine on a Get", func() {
                                         cs := &FakePLS{failSave: true, IntID: 7}
                                         So(ds.Get(cs), ShouldBeNil)
                                 })
 
                                 Convey("vararg", func() {
@@ skipping 100 matching lines @@
                         })
 
                         Convey("*[]P (map)", func() {
                                 output := []PropertyMap(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         k, ok := o.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
-                                        So(o["Value"][0].Value().(int64), ShouldEqual, i)
+                                        So(o.Slice("Value")[0].Value().(int64), ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]P (chan)", func() {
                                 output := []plsChan(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(output, ShouldHaveLength, 5)
                                 for _, o := range output {
                                         So(ds.KeyForObj(o).StringID(), ShouldEqual, "whyDoIExist")
                                 }
@@ skipping 12 matching lines @@
 
                         Convey("*[]*P (map)", func() {
                                 output := []*PropertyMap(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, op := range output {
                                         o := *op
                                         k, ok := o.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
-                                        So(o["Value"][0].Value().(int64), ShouldEqual, i)
+                                        So(o.Slice("Value")[0].Value().(int64), ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*P (chan)", func() {
                                 output := []*plsChan(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(output, ShouldHaveLength, 5)
                                 for _, o := range output {
                                         So(ds.KeyForObj(o).StringID(), ShouldEqual, "whyDoIExist")
                                 }
@@ skipping 139 matching lines @@
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P (map)", func() {
                                 i := 0
                                 So(ds.Run(q, func(pm *PropertyMap) {
                                         k, ok := pm.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
-                                        So((*pm)["Value"][0].Value(), ShouldEqual, i)
+                                        So((*pm).Slice("Value")[0].Value(), ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P (chan)", func() {
                                 So(ds.Run(q, func(c *plsChan) {
                                         So(ds.KeyForObj(c).StringID(), ShouldEqual, "whyDoIExist")
                                 }), ShouldBeNil)
                         })
 
@@ skipping 15 matching lines @@
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("P (map)", func() {
                                 i := 0
                                 So(ds.Run(q, func(pm PropertyMap) {
                                         k, ok := pm.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
-                                        So(pm["Value"][0].Value(), ShouldEqual, i)
+                                        So(pm.Slice("Value")[0].Value(), ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("P (chan)", func() {
                                 So(ds.Run(q, func(c plsChan) {
                                         So(ds.KeyForObj(c).StringID(), ShouldEqual, "whyDoIExist")
                                 }), ShouldBeNil)
                         })
 
@@ skipping 43 matching lines @@
 
 func TestSchemaChange(t *testing.T) {
         t.Parallel()
 
         Convey("Test changing schemas", t, func() {
                 fds := fixedDataDatastore{}
                 ds := &datastoreImpl{&fds, "", ""}
 
                 Convey("Can add fields", func() {
                         initial := PropertyMap{
-                                "$key": {mpNI(ds.MakeKey("Val", 10))},
-                                "Val":  {mp(100)},
+                                "$key": mpNI(ds.MakeKey("Val", 10)),
+                                "Val":  mp(100),
                         }
                         So(ds.Put(initial), ShouldBeNil)
 
                         type Val struct {
                                 ID int64 `gae:"$id"`
 
                                 Val    int64
                                 TwoVal int64 // whoa, TWO vals! amazing
                         }
                         tv := &Val{ID: 10, TwoVal: 2}
                         So(ds.Get(tv), ShouldBeNil)
                         So(tv, ShouldResemble, &Val{ID: 10, Val: 100, TwoVal: 2})
                 })
 
                 Convey("Removing fields", func() {
                         initial := PropertyMap{
-                                "$key":   {mpNI(ds.MakeKey("Val", 10))},
-                                "Val":    {mp(100)},
-                                "TwoVal": {mp(200)},
+                                "$key":   mpNI(ds.MakeKey("Val", 10)),
+                                "Val":    mp(100),
+                                "TwoVal": mp(200),
                         }
                         So(ds.Put(initial), ShouldBeNil)
 
                         Convey("is normally an error", func() {
                                 type Val struct {
                                         ID int64 `gae:"$id"`
 
                                         Val int64
                                 }
                                 tv := &Val{ID: 10}
                                 So(ds.Get(tv), ShouldErrLike,
                                         `gae: cannot load field "TwoVal" into a "datastore.Val`)
                                 So(tv, ShouldResemble, &Val{ID: 10, Val: 100})
                         })
 
                         Convey("Unless you have an ,extra field!", func() {
                                 type Val struct {
                                         ID int64 `gae:"$id"`
 
                                         Val   int64
                                         Extra PropertyMap `gae:",extra"`
                                 }
                                 tv := &Val{ID: 10}
                                 So(ds.Get(tv), ShouldBeNil)
                                 So(tv, ShouldResemble, &Val{
                                         ID:  10,
                                         Val: 100,
                                         Extra: PropertyMap{
-                                                "TwoVal": {mp(200)},
+                                                "TwoVal": PropertySlice{mp(200)},
                                         },
                                 })
                         })
                 })
 
                 Convey("Can round-trip extra fields", func() {
                         type Expando struct {
                                 ID int64 `gae:"$id"`
 
                                 Something int
                                 Extra     PropertyMap `gae:",extra"`
                         }
                         ex := &Expando{10, 17, PropertyMap{
-                                "Hello": {mp("Hello")},
-                                "World": {mp(true)},
+                                "Hello": mp("Hello"),
+                                "World": mp(true),
                         }}
                         So(ds.Put(ex), ShouldBeNil)
 
                         ex = &Expando{ID: 10}
                         So(ds.Get(ex), ShouldBeNil)
                         So(ex, ShouldResemble, &Expando{
                                 ID:        10,
                                 Something: 17,
                                 Extra: PropertyMap{
-                                        "Hello": {mp("Hello")},
-                                        "World": {mp(true)},
+                                        "Hello": PropertySlice{mp("Hello")},
+                                        "World": PropertySlice{mp(true)},
                                 },
                         })
                 })
 
                 Convey("Can read-but-not-write", func() {
                         initial := PropertyMap{
-                                "$key":   {mpNI(ds.MakeKey("Convert", 10))},
-                                "Val":    {mp(100)},
-                                "TwoVal": {mp(200)},
+                                "$key":   mpNI(ds.MakeKey("Convert", 10)),
+                                "Val":    mp(100),
+                                "TwoVal": mp(200),
                         }
                         So(ds.Put(initial), ShouldBeNil)
                         type Convert struct {
                                 ID int64 `gae:"$id"`
 
                                 Val    int64
                                 NewVal int64
                                 Extra  PropertyMap `gae:"-,extra"`
                         }
                         c := &Convert{ID: 10}
                         So(ds.Get(c), ShouldBeNil)
                         So(c, ShouldResemble, &Convert{
-                                ID: 10, Val: 100, NewVal: 0, Extra: PropertyMap{"TwoVal": {mp(200)}},
+                                ID: 10, Val: 100, NewVal: 0, Extra: PropertyMap{"TwoVal": PropertySlice{mp(200)}},
                         })
-                        c.NewVal = c.Extra["TwoVal"][0].Value().(int64)
+                        c.NewVal = c.Extra.Slice("TwoVal")[0].Value().(int64)
                         So(ds.Put(c), ShouldBeNil)
 
                         c = &Convert{ID: 10}
                         So(ds.Get(c), ShouldBeNil)
                         So(c, ShouldResemble, &Convert{
                                 ID: 10, Val: 100, NewVal: 200, Extra: nil,
                         })
                 })
 
                 Convey("Can black hole", func() {
                         initial := PropertyMap{
-                                "$key":   {mpNI(ds.MakeKey("BlackHole", 10))},
-                                "Val":    {mp(100)},
-                                "TwoVal": {mp(200)},
+                                "$key":   mpNI(ds.MakeKey("BlackHole", 10)),
+                                "Val":    mp(100),
+                                "TwoVal": mp(200),
                         }
                         So(ds.Put(initial), ShouldBeNil)
                         type BlackHole struct {
                                 ID int64 `gae:"$id"`
 
                                 NewStuff  string
                                 blackHole PropertyMap `gae:"-,extra"`
                         }
                         b := &BlackHole{ID: 10, NewStuff: "(╯°□°)╯︵ ┻━┻"}
                         So(ds.Get(b), ShouldBeNil)
                         So(b, ShouldResemble, &BlackHole{ID: 10, NewStuff: "(╯°□°)╯︵ ┻━┻"})
                 })
 
                 Convey("Can change field types", func() {
                         initial := PropertyMap{
-                                "$key": {mpNI(ds.MakeKey("IntChange", 10))},
-                                "Val":  {mp(100)},
+                                "$key": mpNI(ds.MakeKey("IntChange", 10)),
+                                "Val":  mp(100),
                         }
                         So(ds.Put(initial), ShouldBeNil)
 
                         type IntChange struct {
                                 ID    int64 `gae:"$id"`
                                 Val   string
                                 Extra PropertyMap `gae:"-,extra"`
                         }
                         i := &IntChange{ID: 10}
                         So(ds.Get(i), ShouldBeNil)
-                        So(i, ShouldResemble, &IntChange{ID: 10, Extra: PropertyMap{"Val": {mp(100)}}})
-                        i.Val = fmt.Sprint(i.Extra["Val"][0].Value())
+                        So(i, ShouldResemble, &IntChange{ID: 10, Extra: PropertyMap{"Val": PropertySlice{mp(100)}}})
+                        i.Val = fmt.Sprint(i.Extra.Slice("Val")[0].Value())
                         So(ds.Put(i), ShouldBeNil)
 
                         i = &IntChange{ID: 10}
                         So(ds.Get(i), ShouldBeNil)
                         So(i, ShouldResemble, &IntChange{ID: 10, Val: "100"})
                 })
 
                 Convey("Native fields have priority over Extra fields", func() {
                         type Dup struct {
                                 ID    int64 `gae:"$id"`
                                 Val   int64
                                 Extra PropertyMap `gae:",extra"`
                         }
                         d := &Dup{ID: 10, Val: 100, Extra: PropertyMap{
-                                "Val":   {mp(200)},
-                                "Other": {mp("other")},
+                                "Val":   PropertySlice{mp(200)},
+                                "Other": PropertySlice{mp("other")},
                         }}
                         So(ds.Put(d), ShouldBeNil)
 
                         d = &Dup{ID: 10}
                         So(ds.Get(d), ShouldBeNil)
                         So(d, ShouldResemble, &Dup{
-                                ID: 10, Val: 100, Extra: PropertyMap{"Other": {mp("other")}},
+                                ID: 10, Val: 100, Extra: PropertyMap{"Other": PropertySlice{mp("other")}},
                         })
                 })
 
                 Convey("Can change repeated field to non-repeating field", func() {
                         initial := PropertyMap{
-                                "$key": {mpNI(ds.MakeKey("NonRepeating", 10))},
-                                "Val":  {mp(100), mp(200), mp(400)},
+                                "$key": mpNI(ds.MakeKey("NonRepeating", 10)),
+                                "Val":  PropertySlice{mp(100), mp(200), mp(400)},
                         }
                         So(ds.Put(initial), ShouldBeNil)
 
                         type NonRepeating struct {
                                 ID    int64 `gae:"$id"`
                                 Val   int64
                                 Extra PropertyMap `gae:",extra"`
                         }
                         n := &NonRepeating{ID: 10}
                         So(ds.Get(n), ShouldBeNil)
                         So(n, ShouldResemble, &NonRepeating{
                                 ID: 10, Val: 0, Extra: PropertyMap{
-                                        "Val": {mp(100), mp(200), mp(400)},
+                                        "Val": PropertySlice{mp(100), mp(200), mp(400)},
                                 },
                         })
                 })
 
                 Convey("Deals correctly with recursive types", func() {
                         initial := PropertyMap{
-                                "$key": {mpNI(ds.MakeKey("Outer", 10))},
-                                "I.A":  {mp(1), mp(2), mp(4)},
-                                "I.B":  {mp(10), mp(20), mp(40)},
-                                "I.C":  {mp(100), mp(200), mp(400)},
+                                "$key": mpNI(ds.MakeKey("Outer", 10)),
+                                "I.A":  PropertySlice{mp(1), mp(2), mp(4)},
+                                "I.B":  PropertySlice{mp(10), mp(20), mp(40)},
+                                "I.C":  PropertySlice{mp(100), mp(200), mp(400)},
                         }
                         So(ds.Put(initial), ShouldBeNil)
                         type Inner struct {
                                 A int64
                                 B int64
                         }
                         type Outer struct {
                                 ID int64 `gae:"$id"`
 
                                 I     []Inner
                                 Extra PropertyMap `gae:",extra"`
                         }
                         o := &Outer{ID: 10}
                         So(ds.Get(o), ShouldBeNil)
                         So(o, ShouldResemble, &Outer{
                                 ID: 10,
                                 I: []Inner{
                                         {1, 10},
                                         {2, 20},
                                         {4, 40},
                                 },
                                 Extra: PropertyMap{
-                                        "I.C": {mp(100), mp(200), mp(400)},
+                                        "I.C": PropertySlice{mp(100), mp(200), mp(400)},
                                 },
                         })
                 })
 
                 Convey("Problems", func() {
                         Convey("multiple extra fields", func() {
                                 type Bad struct {
                                         A PropertyMap `gae:",extra"`
                                         B PropertyMap `gae:",extra"`
                                 }
@@ skipping 244 matching lines @@
                         if err != nil {
                                 panic(fmt.Errorf("failed to find absolute path for `%s`", sameLevelDir))
                         }
 
                         ids, err := FindAndParseIndexYAML(abs)
                         So(err, ShouldBeNil)
                         So(ids[1].Kind, ShouldEqual, "Test Foo")
                 })
         })
 }