Differentiate between single- and multi- props.

impl/memory/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.
 
 package memory
 
 import (
         "fmt"
         "testing"
         "time"
@@ skipping 22 matching lines @@
         }
         return mg.Version
 }
 
 var pls = dsS.GetPLS
 
 type Foo struct {
         ID     int64    `gae:"$id"`
         Parent *dsS.Key `gae:"$parent"`
 
-        Val  int
-        Name string
+        Val   int
+        Name  string
+        Multi []string
 }
 
 func TestDatastoreSingleReadWriter(t *testing.T) {
         t.Parallel()
 
         Convey("Datastore single reads and writes", t, func() {
                 c := Use(context.Background())
                 ds := dsS.Get(c)
                 So(ds, ShouldNotBeNil)
 
                 Convey("getting objects that DNE is an error", func() {
                         So(ds.Get(&Foo{ID: 1}), ShouldEqual, dsS.ErrNoSuchEntity)
                 })
 
                 Convey("bad namespaces fail", func() {
                         _, err := infoS.Get(c).Namespace("$$blzyall")
                         So(err.Error(), ShouldContainSubstring, "namespace \"$$blzyall\" does not match")
                 })
 
                 Convey("Can Put stuff", func() {
                         // with an incomplete key!
-                        f := &Foo{Val: 10}
+                        f := &Foo{Val: 10, Multi: []string{"foo", "bar"}}
                         So(ds.Put(f), ShouldBeNil)
                         k := ds.KeyForObj(f)
                         So(k.String(), ShouldEqual, "dev~app::/Foo,1")
 
                         Convey("and Get it back", func() {
                                 newFoo := &Foo{ID: 1}
                                 So(ds.Get(newFoo), ShouldBeNil)
                                 So(newFoo, ShouldResemble, f)
 
                                 Convey("but it's hidden from a different namespace", func() {
                                         c, err := infoS.Get(c).Namespace("whombat")
                                         So(err, ShouldBeNil)
                                         ds = dsS.Get(c)
                                         So(ds.Get(f), ShouldEqual, dsS.ErrNoSuchEntity)
                                 })
 
                                 Convey("and we can Delete it", func() {
                                         So(ds.Delete(k), ShouldBeNil)
                                         So(ds.Get(newFoo), ShouldEqual, dsS.ErrNoSuchEntity)
                                 })
 
                         })
+                        Convey("Can Get it back as a PropertyMap", func() {
+                                pmap := dsS.PropertyMap{
+                                        "$id":   propNI(1),
+                                        "$kind": propNI("Foo"),
+                                }
+                                So(ds.Get(pmap), ShouldBeNil)
+                                So(pmap, ShouldResemble, dsS.PropertyMap{
+                                        "$id":   propNI(1),
+                                        "$kind": propNI("Foo"),
+                                        "Name":  prop(""),
+                                        "Val":   prop(10),
+                                        "Multi": dsS.PropertySlice{prop("foo"), prop("bar")},
+                                })
+                        })
                         Convey("Deleteing with a bogus key is bad", func() {
                                 So(ds.Delete(ds.NewKey("Foo", "wat", 100, nil)), ShouldEqual, dsS.ErrInvalidKey)
                         })
                         Convey("Deleteing a DNE entity is fine", func() {
                                 So(ds.Delete(ds.NewKey("Foo", "wat", 0, nil)), ShouldBeNil)
                         })
 
                         Convey("Deleting entities from a nonexistant namespace works", func() {
                                 aid := infoS.Get(c).FullyQualifiedAppID()
                                 keys := make([]*dsS.Key, 10)
@@ skipping 46 matching lines @@
                                 Convey("can Get", func() {
                                         vals := make([]dsS.PropertyMap, len(keys))
                                         for i := range vals {
                                                 vals[i] = dsS.PropertyMap{}
                                                 So(vals[i].SetMeta("key", keys[i]), ShouldBeTrue)
                                         }
                                         So(ds.GetMulti(vals), ShouldBeNil)
 
                                         for i, val := range vals {
                                                 So(val, ShouldResemble, dsS.PropertyMap{
-                                                        "Val":  {dsS.MkProperty(10)},
-                                                        "Name": {dsS.MkProperty("")},
-                                                        "$key": {dsS.MkPropertyNI(keys[i])},
+                                                        "Val":  dsS.MkProperty(10),
+                                                        "Name": dsS.MkProperty(""),
+                                                        "$key": dsS.MkPropertyNI(keys[i]),
                                                 })
                                         }
                                 })
 
                         })
 
                         Convey("allocating ids prevents their use", func() {
                                 keys := ds.NewIncompleteKeys(100, "Foo", nil)
                                 So(ds.AllocateIDs(keys), ShouldBeNil)
                                 So(len(keys), ShouldEqual, 100)
@@ skipping 531 matching lines @@
                 type Model struct {
                         ID    int64 `gae:"$id"`
                         Value []int64
                 }
                 So(ds.Put(&Model{ID: 1, Value: []int64{20, 30}}), ShouldBeNil)
 
                 vals := []dsS.PropertyMap{}
                 So(ds.GetAll(dsS.NewQuery("Model").Project("Value"), &vals), ShouldBeNil)
                 So(len(vals), ShouldEqual, 2)
 
-                So(vals[0]["Value"][0].Value(), ShouldEqual, 20)
-                So(vals[1]["Value"][0].Value(), ShouldEqual, 30)
+                So(vals[0].Slice("Value")[0].Value(), ShouldEqual, 20)
+                So(vals[1].Slice("Value")[0].Value(), ShouldEqual, 30)
         })
 }
 
 func TestAddIndexes(t *testing.T) {
         t.Parallel()
 
         Convey("Test Testable.AddIndexes", t, func() {
                 ctx := UseWithAppID(context.Background(), "aid")
                 namespaces := []string{"", "good", "news", "everyone"}
 
@@ skipping 38 matching lines @@
                         // Add "foos" to a new namespace, then confirm that it gets indexed.
                         So(dsS.Get(infoS.Get(ctx).MustNamespace("qux")).PutMulti(foos), ShouldBeNil)
                         dsS.Get(ctx).Testable().CatchupIndexes()
 
                         results = nil
                         So(dsS.Get(infoS.Get(ctx).MustNamespace("qux")).GetAll(q, &results), ShouldBeNil)
                         So(len(results), ShouldEqual, 2)
                 })
         })
 }