Add PopulateKey method to datastore.

service/datastore/datastore_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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 124 matching lines @@
 }
 
 type permaBad struct {
         PropertyLoadSaver
 }
 
 func (f *permaBad) Load(pm PropertyMap) error {
         return errors.New("permaBad")
 }
 
+type SingletonStruct struct {
+        id int64 `gae:"$id,1"`
+}
+
 type FakePLS struct {
         IntID    int64
         StringID string
         Kind     string
 
         Value     int64
         gotLoaded bool
 
         failGetMeta bool
         failLoad    bool
@@ skipping 215 matching lines @@
                                         NonSerializableField complex64
                                 }
 
                                 So(func() { ds.KeyForObjErr(&BadObj{ID: 1}) }, ShouldPanicLike,
                                         `field "NonSerializableField" has invalid type: complex64`)
                         })
                 })
         })
 }
 
+func TestPopulateKey(t *testing.T) {
+        t.Parallel()
+
+        Convey("Test PopulateKey", t, func() {
+                k := NewKey("app", "namespace", "kind", "", 1337, nil)
+
+                Convey("Can set the key of a common struct.", func() {
+                        var cs CommonStruct
+
+                        PopulateKey(&cs, k)
+                        So(cs.ID, ShouldEqual, 1337)
+                })
+
+                Convey("Will not set the value of a singleton struct.", func() {
+                        var ss SingletonStruct
+
+                        PopulateKey(&ss, k)
+                        So(ss.id, ShouldEqual, 0)
+                })
+
+                Convey("Will panic when setting the key of a bad struct.", func() {
+                        var bs badStruct
+
+                        So(func() { PopulateKey(&bs, k) }, ShouldPanic)
+                })
+
+                Convey("Will panic when setting the key of a broken PLS struct.", func() {
+                        var broken permaBad
+
+                        So(func() { PopulateKey(&broken, k) }, ShouldPanic)
+                })
+        })
+}
+
 func TestPut(t *testing.T) {
         t.Parallel()
 
         Convey("Test Put/PutMulti", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
                 ds := Get(c)
 
                 Convey("bad", func() {
                         Convey("static can't serialize", func() {
@@ skipping 1149 matching lines @@
                         if err != nil {
                                 panic(fmt.Errorf("failed to find absolute path for `%s`", sameLevelDir))
                         }
 
                         ids, err := FindAndParseIndexYAML(abs)
                         So(err, ShouldBeNil)
                         So(ids[1].Kind, ShouldEqual, "Test Foo")
                 })
         })
 }