Refactor keys and queries in datastore service and implementation.

service/datastore/serialize/serialize_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 serialize
 
 import (
         "bytes"
         "fmt"
         "io"
         "testing"
         "time"
 
         "github.com/luci/gae/service/blobstore"
         ds "github.com/luci/gae/service/datastore"
-        "github.com/luci/gae/service/datastore/dskey"
         "github.com/luci/luci-go/common/cmpbin"
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func init() {
         WritePropertyMapDeterministic = true
 }
 
 var (
         mp   = ds.MkProperty
         mpNI = ds.MkPropertyNI
 )
 
 type dspmapTC struct {
         name  string
         props ds.PropertyMap
 }
 
-// TODO(riannucci): dedup with datastore/key testing file.
-func mkKey(aid, ns string, elems ...interface{}) ds.Key {
-        if len(elems)%2 != 0 {
-                panic("odd number of tokens")
-        }
-        toks := make([]ds.KeyTok, len(elems)/2)
-        for i := 0; i < len(elems); i += 2 {
-                toks[i/2].Kind = elems[i].(string)
-                switch x := elems[i+1].(type) {
-                case string:
-                        toks[i/2].StringID = x
-                case int:
-                        toks[i/2].IntID = int64(x)
-                default:
-                        panic("bad token id")
-                }
-        }
-        return dskey.NewToks(aid, ns, toks)
-}
+var mkKey = ds.MakeKey
 
 func mkBuf(data []byte) Buffer {
         return Invertible(bytes.NewBuffer(data))
 }
 
 // TODO(riannucci): dedup with datastore/key testing file
 func ShouldEqualKey(actual interface{}, expected ...interface{}) string {
         if len(expected) != 1 {
                 return fmt.Sprintf("Assertion requires 1 expected value, got %d", len(expected))
         }
-        if dskey.Equal(actual.(ds.Key), expected[0].(ds.Key)) {
+        if actual.(*ds.Key).Equal(expected[0].(*ds.Key)) {
                 return ""
         }
         return fmt.Sprintf("Expected: %q\nActual: %q", actual, expected[0])
 }
 
 func TestPropertyMapSerialization(t *testing.T) {
         t.Parallel()
 
         tests := []dspmapTC{
                 {
@@ skipping 377 matching lines @@
                                 for i := 0; i < MaxIndexColumns+1; i++ {
                                         id.SortBy = append(id.SortBy, ds.IndexColumn{Property: "Hi", Direction: ds.ASCENDING})
                                 }
                                 data := ToBytes(*id.PrepForIdxTable())
                                 newID, err = ReadIndexDefinition(mkBuf(data))
                                 So(err, ShouldErrLike, "over 64 sort orders")
                         })
                 })
         })
 }