Add "MkKeyContext" KeyContext generation function.

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"
 
@@ skipping 100 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{
-                        dstore.KeyContext{"dev~app", "ns"},
+                        dstore.MkKeyContext("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"}
+                kc := dstore.MkKeyContext("dev~app", "ns")
 
                 Convey("non-ancestor queries in a transaction", func() {
                         fq, err := nq().Finalize()
                         So(err, ShouldErrLike, nil)
                         _, 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"))
@@ skipping 20 matching lines @@
                                         So(err, ShouldErrLike, tc.err)
 
                                         if tc.equivalentQuery != nil {
                                                 So(rq, ShouldResemble, tc.equivalentQuery)
                                         }
                                 })
                         }
                 })
         })
 }