Split off serialization and key functions to their own packages.

impl/memory/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.
 
 package memory
 
 import (
-        "bytes"
         "fmt"
         "testing"
 
         dsS "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/datastore/dskey"
+        "github.com/luci/gae/service/datastore/serialize"
         infoS "github.com/luci/gae/service/info"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 func TestDatastoreKinder(t *testing.T) {
         t.Parallel()
 
         Convey("Datastore keys", t, func() {
                 c := Use(context.Background())
                 ds := dsS.Get(c)
                 So(ds, ShouldNotBeNil)
 
                 Convey("implements DSNewKeyer", func() {
                         Convey("NewKey", func() {
                                 key := ds.NewKey("nerd", "stringID", 0, nil)
                                 So(key, ShouldNotBeNil)
                                 So(key.Kind(), ShouldEqual, "nerd")
                                 So(key.StringID(), ShouldEqual, "stringID")
                                 So(key.IntID(), ShouldEqual, 0)
                                 So(key.Parent(), ShouldBeNil)
                                 So(key.AppID(), ShouldEqual, "dev~app")
                                 So(key.Namespace(), ShouldEqual, "")
                                 So(key.String(), ShouldEqual, "/nerd,stringID")
-                                So(dsS.KeyIncomplete(key), ShouldBeFalse)
-                                So(dsS.KeyValid(key, false, "dev~app", ""), ShouldBeTrue)
+                                So(key.Incomplete(), ShouldBeFalse)
+                                So(key.Valid(false, "dev~app", ""), ShouldBeTrue)
                         })
                 })
 
         })
 }
 
 type MetaGroup struct {
         _id    int64   `gae:"$id,1"`
         _kind  string  `gae:"$kind,__entity_group__"`
         Parent dsS.Key `gae:"$parent"`
 
         Version int64 `gae:"__version__"`
 }
 
 func testGetMeta(c context.Context, k dsS.Key) int64 {
         ds := dsS.Get(c)
-        mg := &MetaGroup{Parent: dsS.KeyRoot(k)}
+        mg := &MetaGroup{Parent: dskey.Root(k)}
         if err := ds.Get(mg); err != nil {
                 panic(err)
         }
         return mg.Version
 }
 
 var pls = dsS.GetPLS
 
 type Foo struct {
         Id     int64   `gae:"$id"`
@@ skipping 352 matching lines @@
                                 })
                         })
                 })
 
         })
 }
 
 func TestCompoundIndexes(t *testing.T) {
         t.Parallel()
 
-        idxKey := func(def *dsS.IndexDefinition) string {
-                buf := &bytes.Buffer{}
-                buf.WriteString("idx::")
-                So(def.Write(buf), ShouldBeNil)
-                return buf.String()
+        idxKey := func(def dsS.IndexDefinition) string {
+                So(def, ShouldNotBeNil)
+                return "idx::" + string(serialize.ToBytes(def))
         }
 
         numItms := func(c *memCollection) uint64 {
                 ret, _ := c.GetTotals()
                 return ret
         }
 
         Convey("Test Compound indexes", t, func() {
                 type Model struct {
                         ID int64 `gae:"$id"`
 
                         Field1 []string
                         Field2 []int64
                 }
 
                 c := Use(context.Background())
                 ds := dsS.Get(c)
                 t := ds.Raw().Testable().(*dsImpl)
                 store := t.data.store
 
                 So(ds.Put(&Model{1, []string{"hello", "world"}, []int64{10, 11}}), ShouldBeNil)
 
-                idx := &dsS.IndexDefinition{
+                idx := dsS.IndexDefinition{
                         Kind: "Model",
                         SortBy: []dsS.IndexColumn{
                                 {Property: "Field2"},
                         },
                 }
 
                 coll := store.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 2)
 
                 idx.SortBy[0].Property = "Field1"
                 coll = store.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 2)
 
                 idx.SortBy = append(idx.SortBy, dsS.IndexColumn{Property: "Field1"})
                 So(store.GetCollection(idxKey(idx)), ShouldBeNil)
 
-                t.AddIndexes(idx)
+                t.AddIndexes(&idx)
                 coll = store.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 4)
         })
 }