Add testable interface for datastore.

impl/memory/testing_utils_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"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/cmpbin"
 )
 
 type kv struct{ k, v []byte }
 
-func indx(kind string, orders ...string) *qIndex {
+func indx(kind string, orders ...string) *ds.IndexDefinition {
         ancestor := false
         if kind[len(kind)-1] == '!' {
                 ancestor = true
                 kind = kind[:len(kind)-1]
         }
-        ret := &qIndex{kind, ancestor, nil}
+        ret := &ds.IndexDefinition{Kind: kind, Ancestor: ancestor}
         for _, o := range orders {
-                dir := qASC
+                dir := ds.ASCENDING
                 if o[0] == '-' {
-                        dir = qDEC
+                        dir = ds.DESCENDING
                         o = o[1:]
                 }
-                ret.sortby = append(ret.sortby, qSortBy{o, dir})
+                ret.SortBy = append(ret.SortBy, ds.IndexColumn{Property: o, Direction: dir})
         }
         return ret
 }
 
 var (
         prop   = ds.MkProperty
         propNI = ds.MkPropertyNI
 )
 
 func key(kind string, id interface{}, parent ...ds.Key) ds.Key {
@@ skipping 32 matching lines @@
                 case ds.PropertyType:
                         buf.WriteByte(byte(x))
                 case string:
                         cmpbin.WriteString(buf, x)
                 case []byte:
                         buf.Write(x)
                 case time.Time:
                         ds.WriteTime(buf, x)
                 case ds.Key:
                         ds.WriteKey(buf, ds.WithoutContext, x)
-                case *qIndex:
-                        x.WriteBinary(buf)
+                case *ds.IndexDefinition:
+                        x.Write(buf)
                 default:
                         panic(fmt.Errorf("I don't know how to deal with %T: %#v", thing, thing))
                 }
         }
         ret := buf.Bytes()
         if ret == nil {
                 ret = []byte{}
         }
         return ret
 }
 
 func icat(bytethings ...interface{}) []byte {
         ret := cat(bytethings...)
         for i := range ret {
                 ret[i] ^= 0xFF
         }
         return ret
 }
 
 func sat(bytethings ...interface{}) string {
         return string(cat(bytethings...))
 }