Differentiate between single- and multi- props.

impl/cloud/datastore_test.go

 // Copyright 2016 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 cloud
 
 import (
         "crypto/rand"
         "encoding/hex"
         "fmt"
         "os"
         "testing"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
 
         "cloud.google.com/go/datastore"
         "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
-func mkProperties(index bool, vals ...interface{}) []ds.Property {
+func mkProperties(index bool, forceMulti bool, vals ...interface{}) ds.PropertyData {
         indexSetting := ds.ShouldIndex
         if !index {
                 indexSetting = ds.NoIndex
         }
 
-        result := make([]ds.Property, len(vals))
+        if len(vals) == 1 && !forceMulti {
+                var prop ds.Property
+                prop.SetValue(vals[0], indexSetting)
+                return prop
+        }
+
+        result := make(ds.PropertySlice, len(vals))
         for i, v := range vals {
                 result[i].SetValue(v, indexSetting)
         }
         return result
 }
 
-func mkp(vals ...interface{}) []ds.Property   { return mkProperties(true, vals...) }
-func mkpNI(vals ...interface{}) []ds.Property { return mkProperties(false, vals...) }
+func mkp(vals ...interface{}) ds.PropertyData   { return mkProperties(true, false, vals...) }
+func mkpNI(vals ...interface{}) ds.PropertyData { return mkProperties(false, false, vals...) }
 
 // TestDatastore tests the cloud datastore implementation.
 //
 // This test uses the gcloud datastore emulator. Like the Go datastore package,
 // the emulator must use the gRPC interface. At the time of writing, the
 // emulator included with the "gcloud" tool is an older emulator that does NOT
 // support gRPC.
 //
 // Download the emulator linked here:
 // https://code.google.com/p/google-cloud-sdk/issues/detail?id=719#c3
@@ skipping 17 matching lines @@
                 return
         }
 
         Convey(fmt.Sprintf(`A cloud installation using datastore emulator %q`, emulatorHost), t, func() {
                 c := context.Background()
                 client, err := datastore.NewClient(c, "luci-gae-test")
                 So(err, ShouldBeNil)
                 defer client.Close()
 
                 testTime := ds.RoundTime(time.Date(2016, 1, 1, 0, 0, 0, 0, time.UTC))
+                _ = testTime
 
                 c = Use(c, client)
 
                 Convey(`Supports namespaces`, func() {
                         namespaces := []string{"foo", "bar", "baz"}
 
                         // Clear all used entities from all namespaces.
                         for _, ns := range namespaces {
                                 nsCtx := info.Get(c).MustNamespace(ns)
                                 di := ds.Get(nsCtx)
@@ skipping 97 matching lines @@
                                 So(merr[1], ShouldEqual, ds.ErrNoSuchEntity)
                                 So(merr[2], ShouldBeNil)
 
                                 // put[1] will not be retrieved (delete)
                                 put[1] = get[1]
                                 So(get, ShouldResemble, put)
                         })
 
                         Convey(`Can put and get all supported entity fields.`, func() {
                                 put := ds.PropertyMap{
-                                        "$id":    mkpNI("foo"),
-                                        "$kind":  mkpNI("FooType"),
-                                        "Number": mkp(1337),
-                                        "String": mkpNI("hello"),
-                                        "Bytes":  mkp([]byte("world")),
-                                        "Time":   mkp(testTime),
-                                        "Float":  mkpNI(3.14),
-                                        "Key":    mkp(di.MakeKey("Parent", "ParentID", "Child", 1337)),
+                                        "$id":   mkpNI("foo"),
+                                        "$kind": mkpNI("FooType"),
+
+                                        "Number":    mkp(1337),
+                                        "String":    mkpNI("hello"),
+                                        "Bytes":     mkp([]byte("world")),
+                                        "Time":      mkp(testTime),
+                                        "Float":     mkpNI(3.14),
+                                        "Key":       mkp(di.MakeKey("Parent", "ParentID", "Child", 1337)),
+                                        "Null":      mkp(nil),
+                                        "NullSlice": mkp(nil, nil),
 
                                         "ComplexSlice": mkp(1337, "string", []byte("bytes"), testTime, float32(3.14),
-                                                float64(2.71), true, di.MakeKey("SomeKey", "SomeID")),
+                                                float64(2.71), true, nil, di.MakeKey("SomeKey", "SomeID")),
+
+                                        "Single":      mkp("single"),
+                                        "SingleSlice": mkProperties(true, true, "single"), // Force a single "multi" value.
+                                        "EmptySlice":  ds.PropertySlice(nil),
                                 }
                                 So(di.Put(put), ShouldBeNil)
                                 delete(put, "$key")
 
                                 get := ds.PropertyMap{
                                         "$id":   mkpNI("foo"),
                                         "$kind": mkpNI("FooType"),
                                 }
                                 So(di.Get(get), ShouldBeNil)
                                 So(get, ShouldResemble, put)
@@ skipping 70 matching lines @@
                                         pmap := ds.PropertyMap{"$kind": mkp("Test"), "$id": mkp("quux")}
                                         err = di.RunInTransaction(func(c context.Context) error {
                                                 return ds.Get(c).Get(pmap)
                                         }, nil)
                                         So(err, ShouldEqual, ds.ErrNoSuchEntity)
                                 })
                         })
                 })
         })
 }