Make impl/memory have an AppID.

impl/memory/datastore_query_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"
         "testing"
 
@@ skipping 98 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{
-                        "ns", "Foo", map[string]stringset.Set{}, []dstore.IndexColumn{
+                        "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() {
                 Convey("non-ancestor queries in a transaction", func() {
                         fq, err := nq().Finalize()
                         So(err, ShouldErrLike, nil)
-                        _, err = reduce(fq, "ns", true)
+                        _, err = reduce(fq, "dev~app", "ns", 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, "ns", false)
+                        _, err = reduce(fq, "dev~app", "ns", 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")
                                                 if err == nil {
-                                                        rq, err = reduce(fq, "ns", false)
+                                                        rq, err = reduce(fq, "dev~app", "ns", false)
                                                 }
                                         }
                                         So(err, ShouldErrLike, tc.err)
 
                                         if tc.equivalentQuery != nil {
                                                 So(rq, ShouldResemble, tc.equivalentQuery)
                                         }
                                 })
                         }
                 })
         })
 }