GitHub #8: Seed indexes from index.yml

service/datastore/index_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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
+        "fmt"
         "strings"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
+        "gopkg.in/yaml.v2"
 )
 
 var indexDefinitionTests = []struct {
-        id       *IndexDefinition
-        builtin  bool
-        compound bool
-        str      string
-        yaml     []string
+        id         *IndexDefinition
+        builtin    bool
+        compound   bool
+        str        string
+        yaml       []string
+        serialized []string // without the leading hyphen, for instance

[iannucci, 2016/01/13 19:12:20]

I don't understand this comment

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

My bad. Meant: not inside an array (YAML arrays have the leading hyphen)". The
struct field and comment have both now been removed.

 }{
         {
                 id:      &IndexDefinition{Kind: "kind"},
                 builtin: true,
                 str:     "B:kind",
         },
 
         {
                 id: &IndexDefinition{
                         Kind:   "kind",
@@ skipping 24 matching lines @@
                 compound: true,
                 str:      "C:Kind|A/prop/-other",
                 yaml: []string{
                         "- kind: Kind",
                         "  ancestor: yes",
                         "  properties:",
                         "  - name: prop",
                         "  - name: other",
                         "    direction: desc",
                 },
+                serialized: []string{
+                        "  kind: Kind",

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

You should be able to avoid repeating "yaml" by Marshalling a []*IndexDefinition
instead of an *IndexDefinition.

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

Thanks! Much cleaner. :)

+                        "  ancestor: yes",
+                        "  properties:",
+                        "  - name: prop",
+                        "  - name: other",
+                        "    direction: desc",
+                },
         },
 }
 
 func TestIndexDefinition(t *testing.T) {
         t.Parallel()
 
         Convey("Test IndexDefinition", t, func() {
                 for _, tc := range indexDefinitionTests {
                         Convey(tc.str, func() {
                                 So(tc.id.String(), ShouldEqual, tc.str)
                                 So(tc.id.Builtin(), ShouldEqual, tc.builtin)
                                 So(tc.id.Compound(), ShouldEqual, tc.compound)
                                 yaml, _ := tc.id.YAMLString()
                                 So(yaml, ShouldEqual, strings.Join(tc.yaml, "\n"))
                         })
                 }
         })
+
+        Convey("Test MarshalYAML/UnmarshalYAML", t, func() {
+                for _, tc := range indexDefinitionTests {
+                        Convey(fmt.Sprintf("serializable index definition `%s` is marshaled and unmarshaled correctly", tc.str), func() {
+                                if tc.serialized != nil {
+                                        // marshal
+                                        _, err := yaml.Marshal(tc.id)
+                                        So(err, ShouldBeNil)
+
+                                        // unmarshal
+                                        var id IndexDefinition
+                                        yaml.Unmarshal([]byte(strings.Join(tc.serialized, "\n")), &id)
+                                        So(&id, ShouldResemble, tc.id)
+                                }
+                        })
+                }
+        })
 }