GitHub #8: Seed indexes from index.yml

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 (
+        "bytes"
         "fmt"
         "testing"
         "time"
 
         dsS "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         infoS "github.com/luci/gae/service/info"
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
@@ skipping 503 matching lines @@
                         So(ds.Put(&Foo{}), ShouldErrLike, "allocateIDs is disabled")
 
                         So(ds.Put(&Foo{ID: 1}), ShouldBeNil)
 
                         ds.Testable().CatchupIndexes()
 
                         count, err := ds.Count(dsS.NewQuery(""))
                         So(err, ShouldBeNil)
                         So(count, ShouldEqual, 1) // normally this would include __entity_group__
                 })
+
+                Convey("Testable.ParseIndexYAML", func() {
+                        yaml := `
+indexes:
+
+- kind: Cat
+  ancestor: no
+  properties:
+  - name: name
+  - name: age
+    direction: desc
+
+- kind: Cat
+  properties:
+  - name: name
+    direction: asc
+  - name: whiskers
+    direction: desc
+
+- kind: Store
+  ancestor: yes
+  properties:
+  - name: business
+    direction: asc
+  - name: owner
+    direction: asc
+`
+                        idxs := ds.Testable().ParseIndexYAML(bytes.NewBufferString(yaml))
+                        expected := []*dsS.IndexDefinition{
+                                {
+                                        Kind:     "Cat",
+                                        Ancestor: false,
+                                        SortBy: []dsS.IndexColumn{
+                                                {
+                                                        Property:   "name",
+                                                        Descending: false,
+                                                },
+                                                {
+                                                        Property:   "age",
+                                                        Descending: true,
+                                                },
+                                        },
+                                },
+                                {
+                                        Kind:     "Cat",
+                                        Ancestor: false,
+                                        SortBy: []dsS.IndexColumn{
+                                                {
+                                                        Property:   "name",
+                                                        Descending: false,
+                                                },
+                                                {
+                                                        Property:   "whiskers",
+                                                        Descending: true,
+                                                },
+                                        },
+                                },
+                                {
+                                        Kind:     "Store",
+                                        Ancestor: true,
+                                        SortBy: []dsS.IndexColumn{
+                                                {
+                                                        Property:   "business",
+                                                        Descending: false,
+                                                },
+                                                {
+                                                        Property:   "owner",
+                                                        Descending: false,
+                                                },
+                                        },
+                                },
+                        }
+                        So(idxs, ShouldResembleV, expected)
+                })
         })

[dnj, 2016/01/13 16:16:40]

Also test filesystem walking using a tempdir.

[nishanths (utexas), 2016/01/14 21:15:14]

Done. :) The tests are now in service/datastore/datastore_test.go.

 }
 
 func TestCompoundIndexes(t *testing.T) {
         t.Parallel()
 
         idxKey := func(def dsS.IndexDefinition) string {
                 So(def, ShouldNotBeNil)
                 return "idx::" + string(serialize.ToBytes(*def.PrepForIdxTable()))
         }
 
@@ skipping 82 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)
         })
 }