Add Kind/StringID/IntID back to Key.

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 (
         "fmt"
@@ skipping 40 matching lines @@
                 }
                 pm := PropertyMap{"Value": {MkProperty(i)}}
                 if !cb(k, pm, nil) {
                         break
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) PutMulti(keys []*Key, vals []PropertyMap, cb PutMultiCB) error {
-        if keys[0].Last().Kind == "FailAll" {
+        if keys[0].Kind() == "FailAll" {
                 return errors.New("PutMulti fail all")
         }
         assertExtra := false
         if _, err := vals[0].GetMeta("assertExtra"); err == nil {
                 assertExtra = true
         }
         for i, k := range keys {
                 err := error(nil)
-                if k.Last().Kind == "Fail" {
+                if k.Kind() == "Fail" {
                         err = errors.New("PutMulti fail")
                 } else {
                         So(vals[i]["Value"], ShouldResemble, []Property{MkProperty(i)})
                         if assertExtra {
                                 So(vals[i]["Extra"], ShouldResemble, []Property{MkProperty("whoa")})
                         }
                         if k.Incomplete() {
-                                k = NewKey(k.AppID(), k.Namespace(), k.Last().Kind, "", int64(i+1), k.Parent())
+                                k = NewKey(k.AppID(), k.Namespace(), k.Kind(), "", int64(i+1), k.Parent())
                         }
                 }
                 cb(k, err)
         }
         return nil
 }
 
 func (f *fakeDatastore) GetMulti(keys []*Key, _meta MultiMetaGetter, cb GetMultiCB) error {
-        if keys[0].Last().Kind == "FailAll" {
+        if keys[0].Kind() == "FailAll" {
                 return errors.New("GetMulti fail all")
         }
         for i, k := range keys {
-                if k.Last().Kind == "Fail" {
+                if k.Kind() == "Fail" {
                         cb(nil, errors.New("GetMulti fail"))
                 } else {
                         cb(PropertyMap{"Value": {MkProperty(i + 1)}}, nil)
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) DeleteMulti(keys []*Key, cb DeleteMultiCB) error {
-        if keys[0].Last().Kind == "FailAll" {
+        if keys[0].Kind() == "FailAll" {
                 return errors.New("DeleteMulti fail all")
         }
         for _, k := range keys {
-                if k.Last().Kind == "Fail" {
+                if k.Kind() == "Fail" {
                         cb(errors.New("DeleteMulti fail"))
                 } else {
                         cb(nil)
                 }
         }
         return nil
 }
 
 type badStruct struct {
         ID    int64     `gae:"$id"`
@@ skipping 300 matching lines @@
                                 for i, fpls := range fplss {
                                         expect := int64(i + 1)
                                         if i == 4 {
                                                 expect = 200
                                         }
                                         So(fpls.IntID, ShouldEqual, expect)
                                 }
 
                                 pm := PropertyMap{"Value": {MkProperty(0)}, "$kind": {MkPropertyNI("Pmap")}}
                                 So(ds.Put(pm), ShouldBeNil)
-                                So(ds.KeyForObj(pm).Last().IntID, ShouldEqual, 1)
+                                So(ds.KeyForObj(pm).IntID(), ShouldEqual, 1)
                         })
 
                         Convey("[]P (map)", func() {
                                 pms := make([]PropertyMap, 7)
                                 for i := range pms {
                                         pms[i] = PropertyMap{
                                                 "$kind": {MkProperty("Pmap")},
                                                 "Value": {MkProperty(i)},
                                         }
                                         if i == 4 {
@@ skipping 244 matching lines @@
                                 }
                         })
 
                         Convey("*[]P (map)", func() {
                                 output := []PropertyMap(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         k, err := o.GetMeta("key")
                                         So(err, ShouldBeNil)
-                                        So(k.(*Key).Last().IntID, ShouldEqual, i+1)
+                                        So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(o["Value"][0].Value().(int64), ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*P", func() {
                                 output := []*FakePLS(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         So(o.gotLoaded, ShouldBeTrue)
                                         So(o.IntID, ShouldEqual, i+1)
                                         So(o.Value, ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*P (map)", func() {
                                 output := []*PropertyMap(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, op := range output {
                                         o := *op
                                         k, err := o.GetMeta("key")
                                         So(err, ShouldBeNil)
-                                        So(k.(*Key).Last().IntID, ShouldEqual, i+1)
+                                        So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(o["Value"][0].Value().(int64), ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*Key", func() {
                                 output := []*Key(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, k := range output {
-                                        So(k.Last().IntID, ShouldEqual, i+1)
+                                        So(k.IntID(), ShouldEqual, i+1)
                                 }
                         })
 
                 })
         })
 }
 
 func TestRun(t *testing.T) {
         t.Parallel()
 
@@ skipping 85 matching lines @@
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P (map)", func() {
                                 i := 0
                                 So(ds.Run(q, func(pm *PropertyMap, _ CursorCB) bool {
                                         k, err := pm.GetMeta("key")
                                         So(err, ShouldBeNil)
-                                        So(k.(*Key).Last().IntID, ShouldEqual, i+1)
+                                        So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So((*pm)["Value"][0].Value(), ShouldEqual, i)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("S", func() {
                                 i := 0
                                 So(ds.Run(q, func(cs CommonStruct, _ CursorCB) bool {
                                         So(cs.ID, ShouldEqual, i+1)
@@ skipping 12 matching lines @@
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("P (map)", func() {
                                 i := 0
                                 So(ds.Run(q, func(pm PropertyMap, _ CursorCB) bool {
                                         k, err := pm.GetMeta("key")
                                         So(err, ShouldBeNil)
-                                        So(k.(*Key).Last().IntID, ShouldEqual, i+1)
+                                        So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(pm["Value"][0].Value(), ShouldEqual, i)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("Key", func() {
                                 i := 0
                                 So(ds.Run(q, func(k *Key, _ CursorCB) bool {
-                                        So(k.Last().IntID, ShouldEqual, i+1)
+                                        So(k.IntID(), ShouldEqual, i+1)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }