Fix error message from KeyForObj when passing an invalid struct.

filter/txnBuf/txnbuf_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 txnBuf
 
 import (
         "bytes"
         "fmt"
         "math/rand"
@@ skipping 477 matching lines @@
                                                 {2, 4},
                                                 {3, 4},
                                                 {2, 5},
                                                 {3, 5},
                                                 {4, 5},
                                                 {2, 6},
                                                 {3, 6},
                                         }
 
                                         for i, pm := range vals {
-                                                So(pm.GetMetaDefault("key", nil), ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
+                                                v, err := datastore.GetMetaDefault(pm, "key", nil)
+                                                So(err, ShouldBeNil)
+                                                So(v, ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
                                                 So(pm["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 {
                                                 id  int64
                                                 val int64
                                         }{
                                                 // note (3, 3) and (4, 3) are correctly missing because deleting
                                                 // 2 removed two entries which are hidden by the Offset(4).
                                                 {3, 4},
                                                 {3, 5},
                                                 {4, 5},
                                                 {3, 6},
                                                 {3, 7},
                                                 {4, 7},
                                                 {3, 8},
                                                 {3, 9},
                                                 {4, 9},
                                                 {4, 11},
                                         }
 
                                         for i, pm := range vals {
-                                                So(pm.GetMetaDefault("key", nil), ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
+                                                v, err := datastore.GetMetaDefault(pm, "key", nil)
+                                                So(err, ShouldBeNil)
+                                                So(v, ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
                                                 So(pm["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(pm.GetMetaDefault("key", nil), ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
+                                                v, err := datastore.GetMetaDefault(pm, "key", nil)
+                                                So(err, ShouldBeNil)
+                                                So(v, ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
                                                 So(pm["Value"][0].Value(), ShouldEqual, expect[i].val)
                                         }
 
                                         return nil
                                 }, nil), ShouldBeNil)
 
                         })
 
                         Convey("project+distinct", func() {
                                 _, _, ds := mkds([]*Foo{
@@ skipping 34 matching lines @@
                                                 {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.GetMetaDefault("key", nil), ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
+
+                                                v, err := datastore.GetMetaDefault(pm, "key", nil)
+                                                So(err, ShouldBeNil)
+                                                So(v, ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
                                         }
 
                                         return nil
                                 }, nil), ShouldBeNil)
                         })
 
                         Convey("overwrite", func() {
                                 data := []*Foo{
                                         {ID: 2, Parent: root, Value: []int64{1, 2, 3, 4, 5, 6, 7}},
                                         {ID: 3, Parent: root, Value: []int64{3, 4, 5, 6, 7, 8, 9}},
@@ skipping 86 matching lines @@
                                                 {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.GetMetaDefault("key", nil), ShouldResemble, ds.MakeKey("Parent", 1, "Foo", expect[i].id))
+
+                                                v, err := datastore.GetMetaDefault(pm, "key", nil)
+                                                So(err, ShouldBeNil)
+                                                So(v, 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
                                 // happen because we calculate the comparison string for each entity
                                 // based on the whole entity, but we forgot to limit the comparison
@@ skipping 136 matching lines @@
                                         So(val[len(val)-1].Value(), ShouldResemble, "wat")
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
 
         })
 
 }