Differentiate between single- and multi- props.

filter/txnBuf/txnbuf_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.
 
 package txnBuf
 
 import (
         "bytes"
         "fmt"
         "math/rand"
@@ skipping 512 matching lines @@
                                                 {2, 5},
                                                 {3, 5},
                                                 {4, 5},
                                                 {2, 6},
                                                 {3, 6},
                                         }
 
                                         for i, pm := range vals {
                                                 So(datastore.GetMetaDefault(pm, "key", nil), ShouldResemble,
                                                         ds.MakeKey("Parent", 1, "Foo", expect[i].id))
-                                                So(pm["Value"][0].Value(), ShouldEqual, expect[i].val)
+                                                So(pm.Slice("Value")[0].Value(), ShouldEqual, expect[i].val)
                                         }
 
                                         // should remove 4 entries, but there are plenty more to fill
                                         So(ds.Delete(ds.MakeKey("Parent", 1, "Foo", 2)), ShouldBeNil)
 
                                         vals = []datastore.PropertyMap{}
                                         So(ds.GetAll(q, &vals), ShouldBeNil)
                                         So(len(vals), ShouldEqual, 10)
 
                                         expect = []struct {
@@ skipping 10 matching lines @@
                                                 {4, 7},
                                                 {3, 8},
                                                 {3, 9},
                                                 {4, 9},
                                                 {4, 11},
                                         }
 
                                         for i, pm := range vals {
                                                 So(datastore.GetMetaDefault(pm, "key", nil), ShouldResemble,
                                                         ds.MakeKey("Parent", 1, "Foo", expect[i].id))
-                                                So(pm["Value"][0].Value(), ShouldEqual, expect[i].val)
+                                                So(pm.Slice("Value")[0].Value(), ShouldEqual, expect[i].val)
                                         }
 
                                         So(ds.Put(&Foo{ID: 1, Parent: root, Value: []int64{3, 9}}), ShouldBeNil)
 
                                         vals = []datastore.PropertyMap{}
                                         So(ds.GetAll(q, &vals), ShouldBeNil)
                                         So(len(vals), ShouldEqual, 10)
 
                                         expect = []struct {
                                                 id  int64
                                                 val int64
                                         }{
                                                 // 'invisible' {1, 3} entry bumps the {4, 3} into view.
                                                 {4, 3},
                                                 {3, 4},
                                                 {3, 5},
                                                 {4, 5},
                                                 {3, 6},
                                                 {3, 7},
                                                 {4, 7},
                                                 {3, 8},
                                                 {1, 9},
                                                 {3, 9},
                                                 {4, 9},
                                         }
 
                                         for i, pm := range vals {
                                                 So(datastore.GetMetaDefault(pm, "key", nil), ShouldResemble,
                                                         ds.MakeKey("Parent", 1, "Foo", expect[i].id))
-                                                So(pm["Value"][0].Value(), ShouldEqual, expect[i].val)
+                                                So(pm.Slice("Value")[0].Value(), ShouldEqual, expect[i].val)
                                         }
 
                                         return nil
                                 }, nil), ShouldBeNil)
 
                         })
 
                         Convey("project+distinct", func() {
                                 _, _, ds := mkds([]*Foo{
                                         {ID: 2, Parent: root, Value: []int64{1, 2, 3, 4, 5, 6, 7}},
@@ skipping 32 matching lines @@
                                                 {2, 7},
                                                 {3, 8},
                                                 {3, 9},
                                                 {4, 11},
                                                 {5, 70},
                                                 {4, 100},
                                                 {5, 101},
                                         }
 
                                         for i, pm := range vals {
-                                                So(pm["Value"][0].Value(), ShouldEqual, expect[i].val)
+                                                So(pm.Slice("Value")[0].Value(), ShouldEqual, expect[i].val)
                                                 So(datastore.GetMetaDefault(pm, "key", nil), ShouldResemble,
                                                         ds.MakeKey("Parent", 1, "Foo", expect[i].id))
                                         }
 
                                         return nil
                                 }, nil), ShouldBeNil)
                         })
 
                         Convey("overwrite", func() {
                                 data := []*Foo{
@@ skipping 87 matching lines @@
                                                 {2, 2},
                                                 {5, 101},
                                                 {5, 70},
                                                 {3, 9},
                                                 {3, 8},
                                                 {4, 100},
                                                 {4, 11},
                                         }
 
                                         for i, pm := range vals {
-                                                So(pm["Value"][0].Value(), ShouldEqual, expect[i].val)
+                                                So(pm.Slice("Value")[0].Value(), ShouldEqual, expect[i].val)
                                                 So(datastore.GetMetaDefault(pm, "key", nil), ShouldResemble,
                                                         ds.MakeKey("Parent", 1, "Foo", expect[i].id))
                                         }
 
                                         return nil
                                 }, nil), ShouldBeNil)
                         })
 
                         Convey("buffered entity sorts before ineq, but after first parent entity", func() {
                                 // If we got this wrong, we'd see Foo,3 come before Foo,2. This might
@@ skipping 119 matching lines @@
 
                         Convey("start transaction from inside query", func() {
                                 _, _, ds := mkds(projectData)
                                 So(ds.RunInTransaction(func(c context.Context) error {
                                         ds := datastore.Get(c)
 
                                         q := datastore.NewQuery("Foo").Ancestor(root)
                                         return ds.Run(q, func(pm datastore.PropertyMap) {
                                                 So(ds.RunInTransaction(func(c context.Context) error {
                                                         ds := datastore.Get(c)
-                                                        pm["Value"] = append(pm["Value"], datastore.MkProperty("wat"))
+                                                        pm["Value"] = append(pm.Slice("Value"), datastore.MkProperty("wat"))
                                                         return ds.Put(pm)
                                                 }, nil), ShouldBeNil)
                                         })
                                 }, &datastore.TransactionOptions{XG: true}), ShouldBeNil)
 
                                 So(ds.Run(datastore.NewQuery("Foo"), func(pm datastore.PropertyMap) {
-                                        val := pm["Value"]
+                                        val := pm.Slice("Value")
                                         So(val[len(val)-1].Value(), ShouldResemble, "wat")
                                 }), ShouldBeNil)
                         })
 
                 })
 
         })
 
 }