datastore: Fix AddIndexes with existing namespaces

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 (
         "fmt"
         "testing"
         "time"
@@ skipping 22 matching lines @@
         }
         return mg.Version
 }
 
 var pls = dsS.GetPLS
 
 type Foo struct {
         ID     int64    `gae:"$id"`
         Parent *dsS.Key `gae:"$parent"`
 
-        Val int
+        Val  int
+        Name string
 }
 
 func TestDatastoreSingleReadWriter(t *testing.T) {
         t.Parallel()
 
         Convey("Datastore single reads and writes", t, func() {
                 c := Use(context.Background())
                 ds := dsS.Get(c)
                 So(ds, ShouldNotBeNil)
 
@@ skipping 91 matching lines @@
                                         vals := make([]dsS.PropertyMap, len(keys))
                                         for i := range vals {
                                                 vals[i] = dsS.PropertyMap{}
                                                 So(vals[i].SetMeta("key", keys[i]), ShouldBeTrue)
                                         }
                                         So(ds.GetMulti(vals), ShouldBeNil)
 
                                         for i, val := range vals {
                                                 So(val, ShouldResemble, dsS.PropertyMap{
                                                         "Val":  {dsS.MkProperty(10)},
+                                                        "Name": {dsS.MkProperty("")},
                                                         "$key": {dsS.MkPropertyNI(keys[i])},
                                                 })
                                         }
                                 })
 
                         })
 
                         Convey("allocating ids prevents their use", func() {
                                 start, err := ds.AllocateIDs(ds.MakeKey("Foo", 0), 100)
                                 So(err, ShouldBeNil)
@@ skipping 459 matching lines @@
                 So(ds.Put(&Model{ID: 1, Value: []int64{20, 30}}), ShouldBeNil)
 
                 vals := []dsS.PropertyMap{}
                 So(ds.GetAll(dsS.NewQuery("Model").Project("Value"), &vals), ShouldBeNil)
                 So(len(vals), ShouldEqual, 2)
 
                 So(vals[0]["Value"][0].Value(), ShouldEqual, 20)
                 So(vals[1]["Value"][0].Value(), ShouldEqual, 30)
         })
 }
+
+func TestAddIndexes(t *testing.T) {
+        t.Parallel()
+
+        Convey("Test Testable.AddIndexes", t, func() {
+                ctx := UseWithAppID(context.Background(), "aid")
+                namespaces := []string{"", "good", "news", "everyone"}
+
+                Convey("After adding datastore entries, can query against indexes in various namespaces", func() {
+                        foos := []*Foo{
+                                {ID: 1, Val: 1, Name: "foo"},
+                                {ID: 2, Val: 2, Name: "bar"},
+                                {ID: 3, Val: 2, Name: "baz"},
+                        }
+                        for _, ns := range namespaces {
+                                So(dsS.Get(infoS.Get(ctx).MustNamespace(ns)).PutMulti(foos), ShouldBeNil)
+                        }
+
+                        // Initial query, no indexes, will fail.
+                        dsS.Get(ctx).Testable().CatchupIndexes()
+
+                        var results []*Foo
+                        q := dsS.NewQuery("Foo").Eq("Val", 2).Gte("Name", "bar")
+                        So(dsS.Get(ctx).GetAll(q, &results), ShouldErrLike, "Insufficient indexes")
+
+                        // Add index for default namespace.
+                        dsS.Get(ctx).Testable().AddIndexes(&dsS.IndexDefinition{
+                                Kind: "Foo",
+                                SortBy: []dsS.IndexColumn{
+                                        {Property: "Val"},
+                                        {Property: "Name"},
+                                },
+                        })
+                        dsS.Get(ctx).Testable().CatchupIndexes()
+
+                        for _, ns := range namespaces {
+                                results = nil
+                                So(dsS.Get(infoS.Get(ctx).MustNamespace(ns)).GetAll(q, &results), ShouldBeNil)
+                                So(len(results), ShouldEqual, 2)
+                        }
+
+                        // Add "foos" to a new namesapce, then confirm that it gets indexed.
+                        So(dsS.Get(infoS.Get(ctx).MustNamespace("qux")).PutMulti(foos), ShouldBeNil)
+                        dsS.Get(ctx).Testable().CatchupIndexes()
+
+                        results = nil
+                        So(dsS.Get(infoS.Get(ctx).MustNamespace("qux")).GetAll(q, &results), ShouldBeNil)
+                        So(len(results), ShouldEqual, 2)
+                })
+        })
+}