Interface update, per-method Contexts.

impl/memory/datastore_query_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "bytes"
         "testing"
 
         dstore "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
+
         "github.com/luci/luci-go/common/data/cmpbin"
         "github.com/luci/luci-go/common/data/stringset"
+
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 type sillyCursor string
 
 func (s sillyCursor) String() string { return string(s) }
 
 func curs(pairs ...interface{}) queryCursor {
         if len(pairs)%2 != 0 {
@@ skipping 84 matching lines @@
         {"silly inequality (=> v <=)",
                 nq().Gte("bob", 10).Lte("bob", 10),
                 nil, nil},
 
         {"cursors get smooshed into the inquality range",
                 (nq().Gt("Foo", 3).Lt("Foo", 10).
                         Start(curs("Foo", 2, "__key__", key("Something", 1))).
                         End(curs("Foo", 20, "__key__", key("Something", 20)))),
                 nil,
                 &reducedQuery{
-                        "dev~app", "ns", "Foo", map[string]stringset.Set{}, []dstore.IndexColumn{
+                        dstore.KeyContext{"dev~app", "ns"},
+                        "Foo", map[string]stringset.Set{}, []dstore.IndexColumn{
                                 {Property: "Foo"},
                                 {Property: "__key__"},
                         },
                         increment(serialize.ToBytes(dstore.MkProperty(3))),
                         serialize.ToBytes(dstore.MkProperty(10)),
                         2,
                 }},
 
         {"cursors could cause the whole query to be useless",
                 (nq().Gt("Foo", 3).Lt("Foo", 10).
                         Start(curs("Foo", 200, "__key__", key("Something", 1))).
                         End(curs("Foo", 1, "__key__", key("Something", 20)))),
                 dstore.ErrNullQuery,
                 nil},
 }
 
 func TestQueries(t *testing.T) {
         t.Parallel()
 
         Convey("queries have tons of condition checking", t, func() {
+                kc := dstore.KeyContext{"dev~app", "ns"}
+
                 Convey("non-ancestor queries in a transaction", func() {
                         fq, err := nq().Finalize()
                         So(err, ShouldErrLike, nil)
-                        _, err = reduce(fq, "dev~app", "ns", true)
+                        _, err = reduce(fq, kc, true)
                         So(err, ShouldErrLike, "must include an Ancestor")
                 })
 
                 Convey("absurd numbers of filters are prohibited", func() {
                         q := nq().Ancestor(key("thing", "wat"))
                         for i := 0; i < 100; i++ {
                                 q = q.Eq("something", i)
                         }
                         fq, err := q.Finalize()
                         So(err, ShouldErrLike, nil)
-                        _, err = reduce(fq, "dev~app", "ns", false)
+                        _, err = reduce(fq, kc, false)
                         So(err, ShouldErrLike, "query is too large")
                 })
 
                 Convey("bulk check", func() {
                         for _, tc := range queryTests {
                                 Convey(tc.name, func() {
                                         rq := (*reducedQuery)(nil)
                                         fq, err := tc.q.Finalize()
                                         if err == nil {
-                                                err = fq.Valid("s~aid", "ns")
+                                                err = fq.Valid(kc)
                                                 if err == nil {
-                                                        rq, err = reduce(fq, "dev~app", "ns", false)
+                                                        rq, err = reduce(fq, kc, false)
                                                 }
                                         }
                                         So(err, ShouldErrLike, tc.err)
 
                                         if tc.equivalentQuery != nil {
                                                 So(rq, ShouldResemble, tc.equivalentQuery)
                                         }
                                 })
                         }
                 })
         })
 }