Add __namespace__ metadata query support to impl/memory.

impl/memory/datastore_query_execution_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 (
         "fmt"
         "strings"
         "testing"
@@ skipping 67 matching lines @@
                 "Extra", "hello", "waffle",
         ),
         pmap("$key", key("Kind", 3, "Kind", 2), Next,
                 "Val", 3, 4, Next,
                 "Extra", "hello", "waffle",
         ),
         pmap("$key", key("Kind", 3, "Kind", 3), Next,
                 "Val", 3, 4, 2, 1, Next,
                 "Extra", "nuts",
         ),
+        pmap("$key", ds.MakeKey("dev~app", "", "Kind", "id")),
+        pmap("$key", ds.MakeKey("dev~app", "bob", "Kind", "id")),
 }
 
 var collapsedData = []ds.PropertyMap{
         // PTTime
         pmap("$key", key("Kind", 1), Next,
                 "Date", time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC), Next,
         ),
         pmap("$key", key("Kind", 2), Next,
                 "Date", time.Date(2000, time.March, 1, 1, 1, 1, 1, time.UTC), Next,
         ),
@@ skipping 41 matching lines @@
                                 {q: nq("Child").Ancestor(key("Kind", 3)), keys: []*ds.Key{
                                         key("Kind", 3, "Child", "seven"),
                                 }},
                                 {q: nq("Child").Ancestor(key("Kind", 3)).EventualConsistency(true), keys: []*ds.Key{}},
                                 {q: nq("Child").Ancestor(key("Kind", 3)).EventualConsistency(true), keys: []*ds.Key{
                                         key("Kind", 3, "Child", "seven"),
                                 }, inTxn: true},
                                 {q: nq("Child").Ancestor(key("Kind", 3)), keys: []*ds.Key{
                                         key("Kind", 3, "Child", "seven"),
                                 }, inTxn: true},
+                                {q: nq("__namespace__"), get: []ds.PropertyMap{
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "ns")),
+                                }},
+                                {q: nq("__namespace__").Offset(1), get: []ds.PropertyMap{}},
+                                {q: nq("__namespace__").Offset(1).Limit(1), get: []ds.PropertyMap{}},
                         },
                 },
 
                 {
                         putEnts: stage2Data,
                         delEnts: []*ds.Key{key("Unique", 1)},
                         addIdxs: []*ds.IndexDefinition{
                                 indx("Kind!", "-Extra", "-Val"),
                                 indx("Kind!", "-Extra", "-Val", "-__key__"),
                                 indx("Kind!", "Bogus", "Extra", "-Val"),
@@ skipping 177 matching lines @@
                                         pmap("$key", key("Kind", 3), Next,
                                                 "When", 996688461000000),
                                 }},
 
                                 // Original (complex) types are retained when getting the full value.
                                 {q: nq("Kind").Order("When"), get: []ds.PropertyMap{
                                         stage1Data[1],
                                         stage1Data[3],
                                         stage1Data[2],
                                 }},
+                                {q: nq("__namespace__"), get: []ds.PropertyMap{
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", 1)),
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "bob")),
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "ns")),
+                                }},
+                                {q: nq("__namespace__").Offset(1), get: []ds.PropertyMap{
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "bob")),
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "ns")),
+                                }},
+                                {q: nq("__namespace__").Offset(1).Limit(1), get: []ds.PropertyMap{
+                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "bob")),
+                                }},
                         },
 
                         extraFns: []func(context.Context){
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         curs := ds.Cursor(nil)
 
                                         q := nq("").Gt("__key__", key("Kind", 2))
 
                                         err := data.Run(q, func(pm ds.PropertyMap, gc ds.CursorCB) error {
@@ skipping 124 matching lines @@
                 data := ds.Get(c)
                 testing := data.Testable()
 
                 for _, tc := range queryExecutionTests {
                         Convey(tc.name, func() {
                                 for i, stage := range tc.test {
                                         // outside of Convey, since these must always happen
                                         testing.CatchupIndexes()
 
                                         testing.AddIndexes(stage.addIdxs...)
-                                        if err := data.PutMulti(stage.putEnts); err != nil {
-                                                // prevent Convey from thinking this assertion should show up in
-                                                // every test loop.
-                                                panic(err)
+                                        byNs := map[string][]ds.PropertyMap{}
+                                        for _, ent := range stage.putEnts {
+                                                k := ds.GetMetaDefault(ent, "key", nil).(*ds.Key)
+                                                byNs[k.Namespace()] = append(byNs[k.Namespace()], ent)
+                                        }
+                                        for ns, ents := range byNs {
+                                                c := info.Get(c).MustNamespace(ns)
+                                                data := ds.Get(c)
+                                                if err := data.PutMulti(ents); err != nil {
+                                                        // prevent Convey from thinking this assertion should show up in
+                                                        // every test loop.
+                                                        panic(err)
+                                                }
                                         }
 
                                         if err := data.DeleteMulti(stage.delEnts); err != nil {
                                                 panic(err)
                                         }
 
                                         Convey(fmt.Sprintf("stage %d", i), func() {
                                                 for j, expect := range stage.expect {
                                                         runner := func(f func(ic context.Context) error, _ *ds.TransactionOptions) error {
                                                                 return f(c)
@@ skipping 105 matching lines @@
 
         v, ok := actual.(error)
         if !ok {
                 return fmt.Sprintf("type of 'actual' must be error, not %T", actual)
         }
         if v == nil || v == ds.Stop {
                 return ""
         }
         return fmt.Sprintf("expected success value, not %v", v)
 }