Differentiate between single- and multi- props.

impl/prod/everything_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.
 
 // +build appengine
 
 package prod
 
 import (
         "testing"
@@ skipping 10 matching lines @@
 )
 
 var (
         mp   = datastore.MkProperty
         mpNI = datastore.MkPropertyNI
 )
 
 type TestStruct struct {
         ID int64 `gae:"$id"`
 
-        ValueI  []int64
-        ValueB  []bool
-        ValueS  []string
-        ValueF  []float64
-        ValueBS [][]byte // "ByteString"
-        ValueK  []*datastore.Key
-        ValueBK []blobstore.Key
-        ValueGP []datastore.GeoPoint
+        ValueI           []int64
+        ValueB           []bool
+        ValueS           []string
+        ValueF           []float64
+        ValueBS          [][]byte // "ByteString"
+        ValueK           []*datastore.Key
+        ValueBK          []blobstore.Key
+        ValueGP          []datastore.GeoPoint
+        ValueSingle      string
+        ValueSingleSlice []string
 }
 
 func TestBasicDatastore(t *testing.T) {
         t.Parallel()
 
         Convey("basic", t, func() {
                 inst, err := aetest.NewInstance(&aetest.Options{
                         StronglyConsistentDatastore: true,
                 })
                 So(err, ShouldBeNil)
@@ skipping 73 matching lines @@
                                 ValueK: []*datastore.Key{
                                         ds.NewKey("Something", "Cool", 0, nil),
                                         ds.NewKey("Something", "", 1, nil),
                                         ds.NewKey("Something", "Recursive", 0,
                                                 ds.NewKey("Parent", "", 2, nil)),
                                 },
                                 ValueBK: []blobstore.Key{"bellow", "hello"},
                                 ValueGP: []datastore.GeoPoint{
                                         {Lat: 120.7, Lng: 95.5},
                                 },
+                                ValueSingle:      "ohai",
+                                ValueSingleSlice: []string{"kthxbye"},
                         }
                         So(ds.Put(&orig), ShouldBeNil)
 
                         ret := TestStruct{ID: orig.ID}
                         So(ds.Get(&ret), ShouldBeNil)
                         So(ret, ShouldResemble, orig)
 
+                        // make sure single- and multi- properties are preserved.
+                        pmap := datastore.PropertyMap{
+                                "$id":   mpNI(orig.ID),
+                                "$kind": mpNI("TestStruct"),
+                        }
+                        So(ds.Get(pmap), ShouldBeNil)
+                        So(pmap["ValueSingle"], ShouldHaveSameTypeAs, datastore.Property{})
+                        So(pmap["ValueSingleSlice"], ShouldHaveSameTypeAs, datastore.PropertySlice(nil))
+
                         // can't be sure the indexes have caught up... so sleep
                         time.Sleep(time.Second)
 
                         Convey("Can query", func() {
                                 q := datastore.NewQuery("TestStruct")
                                 ds.Run(q, func(ts *TestStruct) {
                                         So(*ts, ShouldResemble, orig)
                                 })
                                 count, err := ds.Count(q)
                                 So(err, ShouldBeNil)
                                 So(count, ShouldEqual, 1)
                         })
 
                         Convey("Can project", func() {
                                 q := datastore.NewQuery("TestStruct").Project("ValueS")
                                 rslts := []datastore.PropertyMap{}
                                 So(ds.GetAll(q, &rslts), ShouldBeNil)
                                 So(rslts, ShouldResemble, []datastore.PropertyMap{
                                         {
-                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueS": {mp("hello")},
+                                                "$key":   mpNI(ds.KeyForObj(&orig)),
+                                                "ValueS": mp("hello"),
                                         },
                                         {
-                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueS": {mp("world")},
+                                                "$key":   mpNI(ds.KeyForObj(&orig)),
+                                                "ValueS": mp("world"),
                                         },
                                 })
 
                                 q = datastore.NewQuery("TestStruct").Project("ValueBS")
                                 rslts = []datastore.PropertyMap{}
                                 So(ds.GetAll(q, &rslts), ShouldBeNil)
                                 So(rslts, ShouldResemble, []datastore.PropertyMap{
                                         {
-                                                "$key":    {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueBS": {mp("allo")},
+                                                "$key":    mpNI(ds.KeyForObj(&orig)),
+                                                "ValueBS": mp("allo"),
                                         },
                                         {
-                                                "$key":    {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueBS": {mp("hello")},
+                                                "$key":    mpNI(ds.KeyForObj(&orig)),
+                                                "ValueBS": mp("hello"),
                                         },
                                         {
-                                                "$key":    {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueBS": {mp("world")},
+                                                "$key":    mpNI(ds.KeyForObj(&orig)),
+                                                "ValueBS": mp("world"),
                                         },
                                         {
-                                                "$key":    {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueBS": {mp("zurple")},
+                                                "$key":    mpNI(ds.KeyForObj(&orig)),
+                                                "ValueBS": mp("zurple"),
                                         },
                                 })
 
                                 count, err := ds.Count(q)
                                 So(err, ShouldBeNil)
                                 So(count, ShouldEqual, 4)
 
                                 q = datastore.NewQuery("TestStruct").Lte("ValueI", 7).Project("ValueS").Distinct(true)
                                 rslts = []datastore.PropertyMap{}
                                 So(ds.GetAll(q, &rslts), ShouldBeNil)
                                 So(rslts, ShouldResemble, []datastore.PropertyMap{
                                         {
-                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueI": {mp(1)},
-                                                "ValueS": {mp("hello")},
+                                                "$key":   mpNI(ds.KeyForObj(&orig)),
+                                                "ValueI": mp(1),
+                                                "ValueS": mp("hello"),
                                         },
                                         {
-                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueI": {mp(1)},
-                                                "ValueS": {mp("world")},
+                                                "$key":   mpNI(ds.KeyForObj(&orig)),
+                                                "ValueI": mp(1),
+                                                "ValueS": mp("world"),
                                         },
                                         {
-                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueI": {mp(7)},
-                                                "ValueS": {mp("hello")},
+                                                "$key":   mpNI(ds.KeyForObj(&orig)),
+                                                "ValueI": mp(7),
+                                                "ValueS": mp("hello"),
                                         },
                                         {
-                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
-                                                "ValueI": {mp(7)},
-                                                "ValueS": {mp("world")},
+                                                "$key":   mpNI(ds.KeyForObj(&orig)),
+                                                "ValueI": mp(7),
+                                                "ValueS": mp("world"),
                                         },
                                 })
 
                                 count, err = ds.Count(q)
                                 So(err, ShouldBeNil)
                                 So(count, ShouldEqual, 4)
                         })
                 })
 
                 Convey("Can Put/Get (time)", func() {
                         // time comparisons in Go are wonky, so this is pulled out
                         pm := datastore.PropertyMap{
-                                "$key": {mpNI(ds.NewKey("Something", "value", 0, nil))},
-                                "Time": {
+                                "$key": mpNI(ds.NewKey("Something", "value", 0, nil)),
+                                "Time": datastore.PropertySlice{
                                         mp(time.Date(1938, time.January, 1, 1, 1, 1, 1, time.UTC)),
                                         mp(time.Time{}),
                                 },
                         }
                         So(ds.Put(&pm), ShouldBeNil)
 
                         rslt := datastore.PropertyMap{}
                         rslt.SetMeta("key", ds.KeyForObj(pm))
                         So(ds.Get(&rslt), ShouldBeNil)
 
-                        So(pm["Time"][0].Value(), ShouldResemble, rslt["Time"][0].Value())
+                        So(pm.Slice("Time")[0].Value(), ShouldResemble, rslt.Slice("Time")[0].Value())
 
                         q := datastore.NewQuery("Something").Project("Time")
                         all := []datastore.PropertyMap{}
                         So(ds.GetAll(q, &all), ShouldBeNil)
                         So(len(all), ShouldEqual, 2)
-                        prop := all[0]["Time"][0]
+                        prop := all[0].Slice("Time")[0]
                         So(prop.Type(), ShouldEqual, datastore.PTInt)
 
                         tval, err := prop.Project(datastore.PTTime)
                         So(err, ShouldBeNil)
                         So(tval, ShouldResemble, time.Time{}.UTC())
 
-                        tval, err = all[1]["Time"][0].Project(datastore.PTTime)
+                        tval, err = all[1].Slice("Time")[0].Project(datastore.PTTime)
                         So(err, ShouldBeNil)
-                        So(tval, ShouldResemble, pm["Time"][0].Value())
+                        So(tval, ShouldResemble, pm.Slice("Time")[0].Value())
 
                         ent := datastore.PropertyMap{
-                                "$key": {mpNI(ds.MakeKey("Something", "value"))},
+                                "$key": mpNI(ds.MakeKey("Something", "value")),
                         }
                         So(ds.Get(&ent), ShouldBeNil)
                         So(ent["Time"], ShouldResemble, pm["Time"])
                 })
 
                 Convey("memcache: Set (nil) is the same as Set ([]byte{})", func() {
                         So(mc.Set(mc.NewItem("bob")), ShouldBeNil) // normally would panic because Value is nil
 
                         bob, err := mc.Get("bob")
                         So(err, ShouldBeNil)
                         So(bob.Value(), ShouldResemble, []byte{})
                 })
         })
 }