Split off serialization and key functions to their own packages.

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 43 matching lines @@
         return q
 }
 
 type fakeDatastore struct {
         RawInterface
         aid string
         ns  string
 }
 
 func (f *fakeDatastore) NewKey(kind, stringID string, intID int64, parent Key) Key {
-        return NewKey(f.aid, f.ns, kind, stringID, intID, parent)
+        id := interface{}(stringID)
+        if stringID == "" {
+                id = intID
+        }
+        return mkKey(f.aid, f.ns, kind, id, parent)
 }
 
 func (f *fakeDatastore) NewQuery(string) Query {
         return &fakeQuery{}
 }
 
 func (f *fakeDatastore) Run(q Query, cb RawRunCB) error {
         rq := q.(*fakeQuery)
         if rq.err != nil {
                 return rq.err
@@ skipping 25 matching lines @@
         }
         for i, k := range keys {
                 err := error(nil)
                 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 KeyIncomplete(k) {
-                                k = NewKey(k.AppID(), k.Namespace(), k.Kind(), "", int64(i+1), k.Parent())
+                        if k.Incomplete() {
+                                k = mkKey(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].Kind() == "FailAll" {
                 return errors.New("GetMulti fail all")
@@ skipping 419 matching lines @@
 
         Convey("Test Delete/DeleteMulti", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
                 ds := Get(c)
                 So(ds, ShouldNotBeNil)
 
                 Convey("bad", func() {
                         Convey("get single error for RPC failure", func() {
                                 keys := []Key{
-                                        NewKey("aid", "ns", "FailAll", "", 1, nil),
-                                        NewKey("aid", "ns", "Ok", "", 1, nil),
+                                        mkKey("aid", "ns", "FailAll", 1, nil),
+                                        mkKey("aid", "ns", "Ok", 1, nil),
                                 }
                                 So(ds.DeleteMulti(keys).Error(), ShouldEqual, "DeleteMulti fail all")
                         })
 
                         Convey("get multi error for individual failure", func() {
                                 keys := []Key{
                                         ds.NewKey("Ok", "", 1, nil),
                                         ds.NewKey("Fail", "", 2, nil),
                                 }
                                 So(ds.DeleteMulti(keys).Error(), ShouldEqual, "DeleteMulti fail")
@@ skipping 327 matching lines @@
                                 So(ds.Run(q, func(k Key, _ CursorCB) bool {
                                         So(k.IntID(), ShouldEqual, i+1)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }