Split off serialization and key functions to their own packages.

filter/dscache/dscache_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 dscache
 
 import (
         "bytes"
         "encoding/binary"
         "errors"
         "math/rand"
         "testing"
         "time"
 
         "github.com/luci/gae/filter/featureBreaker"
         "github.com/luci/gae/impl/memory"
         "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/gae/service/memcache"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/common/mathrand"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 type object struct {
         ID int64 `gae:"$id"`
 
         Value   string
         BigData []byte
 }
 
 type shardObj struct { // see shardsForKey() at top
         ID int64 `gae:"$id"`
 
         Value string
 }
 
 type noCacheObj struct { // see shardsForKey() at top
         ID string `gae:"$id"`
 
         Value bool
 }
 
 func init() {
-        datastore.WritePropertyMapDeterministic = true
+        serialize.WritePropertyMapDeterministic = true
 
         internalValueSizeLimit = 2048
 }
 
 func TestDSCache(t *testing.T) {
         t.Parallel()
 
         zeroTime, err := time.Parse("2006-01-02T15:04:05.999999999Z", "2006-01-02T15:04:05.999999999Z")
         if err != nil {
                 panic(err)
@@ skipping 33 matching lines @@
                         ds := datastore.Get(c)
                         So(dsUnder, ShouldNotBeNil)
                         So(ds, ShouldNotBeNil)
                         So(mc, ShouldNotBeNil)
 
                         Convey("basically works", func() {
                                 pm := datastore.PropertyMap{
                                         "BigData": {datastore.MkProperty([]byte(""))},
                                         "Value":   {datastore.MkProperty("hi")},
                                 }
-                                buf := &bytes.Buffer{}
-                                So(pm.Write(buf, datastore.WithoutContext), ShouldBeNil)
-                                encoded := append([]byte{0}, buf.Bytes()...)
+                                encoded := append([]byte{0}, serialize.ToBytes(pm)...)
 
                                 o := object{ID: 1, Value: "hi"}
                                 So(ds.Put(&o), ShouldBeNil)
 
                                 o = object{ID: 1}
                                 So(dsUnder.Get(&o), ShouldBeNil)
                                 So(o.Value, ShouldEqual, "hi")
 
                                 itm := itmFor(0, ds.KeyForObj(&o))
                                 So(mc.Get(itm), ShouldEqual, memcache.ErrCacheMiss)
@@ skipping 335 matching lines @@
                 InstanceEnabledStatic = false
                 defer func() {
                         InstanceEnabledStatic = true
                 }()
 
                 c := context.Background()
                 newC := FilterRDS(c, nil)
                 So(newC, ShouldEqual, c)
         })
 }