Add testable interface for datastore.

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"
         "math"
         "testing"
 
         dsS "github.com/luci/gae/service/datastore"
         infoS "github.com/luci/gae/service/info"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
@@ skipping 424 matching lines @@
                 })
 
                 Convey("normalize ensures orders make sense", func() {
                         q := ds.NewQuery("Cool")
                         q = q.Filter("cat =", 19).Filter("bob =", 10).Order("bob").Order("bob")
 
                         Convey("removes dups and equality orders", func() {
                                 q = q.Order("wat")
                                 qi := q.(*queryImpl).normalize().checkCorrectness("", false)
                                 So(qi.err, ShouldBeNil)
-                                So(qi.order, ShouldResemble, []queryOrder{{"wat", qASC}})
+                                So(qi.order, ShouldResemble, []dsS.IndexColumn{{Property: "wat"}})
                         })
 
                         Convey("keeps inequality orders", func() {
                                 q = q.Order("wat")
                                 q := q.Filter("bob >", 10).Filter("wat <", 29)
                                 qi := q.(*queryImpl).normalize().checkCorrectness("", false)
-                                So(qi.order, ShouldResemble, []queryOrder{{"bob", qASC}, {"wat", qASC}})
+                                So(qi.order, ShouldResemble, []dsS.IndexColumn{{Property: "bob"}, {Property: "wat"}})
                                 So(qi.err.Error(), ShouldContainSubstring, "Only one inequality")
                         })
 
                         Convey("if we equality-filter on __key__, order is ditched", func() {
                                 q = q.Order("wat")
                                 q := q.Filter("__key__ =", ds.NewKey("Foo", "wat", 0, nil))
                                 qi := q.(*queryImpl).normalize().checkCorrectness("", false)
-                                So(qi.order, ShouldResemble, []queryOrder(nil))
+                                So(qi.order, ShouldResemble, []dsS.IndexColumn(nil))
                                 So(qi.err, ShouldBeNil)
                         })
 
                         Convey("if we order by key and something else, key dominates", func() {
                                 q := q.Order("__key__").Order("wat")
                                 qi := q.(*queryImpl).normalize().checkCorrectness("", false)
-                                So(qi.order, ShouldResemble, []queryOrder{{"__key__", qASC}})
+                                So(qi.order, ShouldResemble, []dsS.IndexColumn{{Property: "__key__"}})
                                 So(qi.err, ShouldBeNil)
                         })
                 })
 
                 Convey("can create bad queries", func() {
                         q := ds.NewQuery("Foo")
 
                         Convey("bad filter ops", func() {
                                 q := q.Filter("Bob !", "value")
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "invalid operator \"!\"")
@@ skipping 86 matching lines @@
                         })
                         Convey("kindless with decending-__key__ orders", func() {
                                 q := ds.NewQuery("").Order("-__key__")
                                 qi := q.(*queryImpl).checkCorrectness("", false)
                                 So(qi.err.Error(), ShouldContainSubstring, "kind is required for all orders")
                         })
                 })
 
         })
 }
+
+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()
+        }
+
+        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{
+                        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)
+                coll = store.GetCollection(idxKey(idx))
+                So(coll, ShouldNotBeNil)
+                So(numItms(coll), ShouldEqual, 4)
+        })
+}