Fix error message from KeyForObj when passing an invalid struct.

service/datastore/properties_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "math"
         "testing"
         "time"
@@ skipping 125 matching lines @@
                         err := pm.Load(PropertyMap{"hello": {Property{}}})
                         So(err, ShouldBeNil)
                         So(pm, ShouldResemble, PropertyMap{"hello": {Property{}}})
 
                         npm, _ := pm.Save(false)
                         So(npm, ShouldResemble, pm)
                 })
                 Convey("meta", func() {
                         Convey("working", func() {
                                 pm := PropertyMap{"": {MkProperty("trap!")}}
-                                _, err := pm.GetMeta("foo")
-                                So(err, ShouldEqual, ErrMetaFieldUnset)
+                                _, ok := pm.GetMeta("foo")
+                                So(ok, ShouldBeFalse)
 
-                                err = pm.SetMeta("foo", 100)
-                                So(err, ShouldBeNil)
+                                So(pm.SetMeta("foo", 100), ShouldBeTrue)
 
-                                v, err := pm.GetMeta("foo")
-                                So(err, ShouldBeNil)
+                                v, ok := pm.GetMeta("foo")
+                                So(ok, ShouldBeTrue)
                                 So(v, ShouldEqual, 100)
-                                So(pm.GetMetaDefault("foo", 100), ShouldEqual, 100)
-                                So(pm.GetMetaDefault("bar", 100), ShouldEqual, 100)
+
+                                So(GetMetaDefault(pm, "foo", 100), ShouldEqual, 100)
+
+                                So(GetMetaDefault(pm, "bar", 100), ShouldEqual, 100)
 
                                 npm, err := pm.Save(false)
                                 So(err, ShouldBeNil)
                                 So(len(npm), ShouldEqual, 0)
                         })
 
+                        Convey("too many values picks the first one", func() {
+                                pm := PropertyMap{
+                                        "$thing": {MkProperty(100), MkProperty(200)},
+                                }
+                                v, ok := pm.GetMeta("thing")
+                                So(ok, ShouldBeTrue)
+                                So(v, ShouldEqual, 100)
+                        })
+
                         Convey("errors", func() {
-                                Convey("too many values", func() {
-                                        pm := PropertyMap{
-                                                "$bad": {MkProperty(100), MkProperty(200)},
-                                        }
-                                        _, err := pm.GetMeta("bad")
-                                        So(err.Error(), ShouldContainSubstring, "too many values")
-                                })
 
                                 Convey("weird value", func() {
                                         pm := PropertyMap{}
-                                        err := pm.SetMeta("sup", complex(100, 20))
-                                        So(err.Error(), ShouldContainSubstring, "bad type")
+                                        So(pm.SetMeta("sup", complex(100, 20)), ShouldBeFalse)
                                 })
                         })
                 })
         })
 }