Refactor serialization helpers from impl/memory -> service/datastore/serialize

impl/memory/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.
 
 package memory
 
 import (
         "sort"
         "testing"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/gkvlite"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 var fakeKey = key("parentKind", "sid", "knd", 10)
 
-func TestCollated(t *testing.T) {
-        t.Parallel()
-
-        Convey("TestCollated", t, func() {
-                Convey("nil list", func() {
-                        pm := ds.PropertyMap(nil)
-                        sip := partiallySerialize(fakeKey, pm)
-
-                        Convey("nil collated", func() {
-                                Convey("defaultIndexes", func() {
-                                        idxs := defaultIndexes("knd", pm)
-                                        So(len(idxs), ShouldEqual, 1)
-                                        So(idxs[0].String(), ShouldEqual, "B:knd")
-                                })
-                                Convey("indexEntries", func() {
-                                        s := sip.indexEntries("ns", defaultIndexes("knd", pm))
-                                        numItems, _ := s.GetCollection("idx").GetTotals()
-                                        So(numItems, ShouldEqual, 1)
-                                        itm := s.GetCollection("idx").MinItem(false)
-                                        So(itm.Key, ShouldResemble, cat(indx("knd").PrepForIdxTable()))
-                                        numItems, _ = s.GetCollection("idx:ns:" + string(itm.Key)).GetTotals()
-                                        So(numItems, ShouldEqual, 1)
-                                })
-                        })
-                })
-
-                Convey("list", func() {
-                        pm := ds.PropertyMap{
-                                "wat":  {propNI("thing"), prop("hat"), prop(100)},
-                                "nerd": {prop(103.7)},
-                                "spaz": {propNI(false)},
-                        }
-                        sip := partiallySerialize(fakeKey, pm)
-                        So(len(sip), ShouldEqual, 4)
-
-                        Convey("single collated", func() {
-                                Convey("indexableMap", func() {
-                                        So(sip, ShouldResemble, serializedIndexablePmap{
-                                                "wat": {
-                                                        cat(prop("hat")),
-                                                        cat(prop(100)),
-                                                        // 'thing' is skipped, because it's not NoIndex
-                                                },
-                                                "nerd": {
-                                                        cat(prop(103.7)),
-                                                },
-                                                "__key__": {
-                                                        cat(prop(fakeKey)),
-                                                },
-                                                "__ancestor__": {
-                                                        cat(prop(fakeKey)),
-                                                        cat(prop(fakeKey.Parent())),
-                                                },
-                                        })
-                                })
-                                Convey("defaultIndexes", func() {
-                                        idxs := defaultIndexes("knd", pm)
-                                        So(len(idxs), ShouldEqual, 5)
-                                        So(idxs[0].String(), ShouldEqual, "B:knd")
-                                        So(idxs[1].String(), ShouldEqual, "B:knd/nerd")
-                                        So(idxs[2].String(), ShouldEqual, "B:knd/wat")
-                                        So(idxs[3].String(), ShouldEqual, "B:knd/-nerd")
-                                        So(idxs[4].String(), ShouldEqual, "B:knd/-wat")
-                                })
-                        })
-                })
-        })
-}
-
 var rgenComplexTime = time.Date(
         1986, time.October, 26, 1, 20, 00, 00, time.UTC)
 var rgenComplexKey = key("kind", "id")
 var rgenComplexTimeIdx = prop(rgenComplexTime).ForIndex()
 
 var rowGenTestCases = []struct {
         name        string
         pmap        ds.PropertyMap
         withBuiltin bool
         idxs        []*ds.IndexDefinition
 
         // These are checked in TestIndexRowGen. nil to skip test case.
-        expected []serializedPvals
+        expected []serialize.SerializedPslice
 
         // just the collections you want to assert. These are checked in
         // TestIndexEntries. nil to skip test case.
         collections map[string][][]byte
 }{
 
         {
                 name: "simple including builtins",
                 pmap: ds.PropertyMap{
                         "wat":  {propNI("thing"), prop("hat"), prop(100)},
                         "nerd": {prop(103.7)},
                         "spaz": {propNI(false)},
                 },
                 withBuiltin: true,
                 idxs: []*ds.IndexDefinition{
                         indx("knd", "-wat", "nerd"),
                 },
-                expected: []serializedPvals{
+                expected: []serialize.SerializedPslice{
                         {cat(prop(fakeKey))},              // B:knd
                         {cat(prop(103.7), prop(fakeKey))}, // B:knd/nerd
                         { // B:knd/wat
                                 cat(prop(100), prop(fakeKey)),
                                 cat(prop("hat"), prop(fakeKey)),
                         },
                         { // B:knd/-nerd
                                 cat(icat(prop(103.7)), prop(fakeKey)),
                         },
                         { // B:knd/-wat
@@ skipping 36 matching lines @@
                         "wat": {
                                 prop(rgenComplexTime),
                                 prop([]byte("value")),
                                 prop(rgenComplexKey)},
                         "spaz": {prop(nil), prop(false), prop(true)},
                 },
                 idxs: []*ds.IndexDefinition{
                         indx("knd", "-wat", "nerd", "spaz"), // doesn't match, so empty
                         indx("knd", "yerp", "-wat", "spaz"),
                 },
-                expected: []serializedPvals{
+                expected: []serialize.SerializedPslice{
                         {}, // C:knd/-wat/nerd/spaz, no match
                         { // C:knd/yerp/-wat/spaz
                                 // thank goodness the binary serialization only happens 1/val in the
                                 // real code :).
                                 cat(prop("hat"), icat(prop(rgenComplexKey)), prop(nil), prop(fakeKey)),
                                 cat(prop("hat"), icat(prop(rgenComplexKey)), prop(false), prop(fakeKey)),
                                 cat(prop("hat"), icat(prop(rgenComplexKey)), prop(true), prop(fakeKey)),
                                 cat(prop("hat"), icat(prop("value")), prop(nil), prop(fakeKey)),
                                 cat(prop("hat"), icat(prop("value")), prop(false), prop(fakeKey)),
                                 cat(prop("hat"), icat(prop("value")), prop(true), prop(fakeKey)),
@@ skipping 35 matching lines @@
         t.Parallel()
 
         Convey("Test Index Row Generation", t, func() {
                 for _, tc := range rowGenTestCases {
                         if tc.expected == nil {
                                 Convey(tc.name, nil) // shows up as 'skipped'
                                 continue
                         }
 
                         Convey(tc.name, func() {
-                                mvals := partiallySerialize(fakeKey, tc.pmap)
+                                mvals := serialize.PropertyMapPartially(fakeKey, tc.pmap)
                                 idxs := []*ds.IndexDefinition(nil)
                                 if tc.withBuiltin {
                                         idxs = append(defaultIndexes("coolKind", tc.pmap), tc.idxs...)
                                 } else {
                                         idxs = tc.idxs
                                 }
 
                                 m := matcher{}
                                 for i, idx := range idxs {
                                         Convey(idx.String(), func() {
                                                 iGen, ok := m.match(idx.GetFullSortOrder(), mvals)
                                                 if len(tc.expected[i]) > 0 {
                                                         So(ok, ShouldBeTrue)
-                                                        actual := make(serializedPvals, 0, len(tc.expected[i]))
+                                                        actual := make(serialize.SerializedPslice, 0, len(tc.expected[i]))
                                                         iGen.permute(func(row, _ []byte) {
                                                                 actual = append(actual, row)
                                                         })
                                                         So(len(actual), ShouldEqual, len(tc.expected[i]))
                                                         sort.Sort(actual)
                                                         for j, act := range actual {
                                                                 So(act, ShouldResemble, tc.expected[i][j])
                                                         }
                                                 } else {
                                                         So(ok, ShouldBeFalse)
                                                 }
                                         })
                                 }
                         })
                 }
         })
+
+        Convey("default indexes", t, func() {
+                Convey("nil collated", func() {
+                        Convey("defaultIndexes (nil)", func() {
+                                idxs := defaultIndexes("knd", ds.PropertyMap(nil))
+                                So(len(idxs), ShouldEqual, 1)
+                                So(idxs[0].String(), ShouldEqual, "B:knd")
+                        })
+
+                        Convey("indexEntries", func() {
+                                sip := serialize.PropertyMapPartially(fakeKey, nil)
+                                s := indexEntries(sip, "ns", defaultIndexes("knd", ds.PropertyMap(nil)))
+                                numItems, _ := s.GetCollection("idx").GetTotals()
+                                So(numItems, ShouldEqual, 1)
+                                itm := s.GetCollection("idx").MinItem(false)
+                                So(itm.Key, ShouldResemble, cat(indx("knd").PrepForIdxTable()))
+                                numItems, _ = s.GetCollection("idx:ns:" + string(itm.Key)).GetTotals()
+                                So(numItems, ShouldEqual, 1)
+                        })
+
+                        Convey("defaultIndexes", func() {
+                                pm := ds.PropertyMap{
+                                        "wat":  {propNI("thing"), prop("hat"), prop(100)},
+                                        "nerd": {prop(103.7)},
+                                        "spaz": {propNI(false)},
+                                }
+                                idxs := defaultIndexes("knd", pm)
+                                So(len(idxs), ShouldEqual, 5)
+                                So(idxs[0].String(), ShouldEqual, "B:knd")
+                                So(idxs[1].String(), ShouldEqual, "B:knd/nerd")
+                                So(idxs[2].String(), ShouldEqual, "B:knd/wat")
+                                So(idxs[3].String(), ShouldEqual, "B:knd/-nerd")
+                                So(idxs[4].String(), ShouldEqual, "B:knd/-wat")
+                        })
+
+                })
+        })
 }
 
 func TestIndexEntries(t *testing.T) {
         t.Parallel()
 
         Convey("Test indexEntriesWithBuiltins", t, func() {
                 for _, tc := range rowGenTestCases {
                         if tc.collections == nil {
                                 Convey(tc.name, nil) // shows up as 'skipped'
                                 continue
                         }
 
                         Convey(tc.name, func() {
                                 store := (*memStore)(nil)
                                 if tc.withBuiltin {
                                         store = indexEntriesWithBuiltins(fakeKey, tc.pmap, tc.idxs)
                                 } else {
-                                        store = partiallySerialize(fakeKey, tc.pmap).indexEntries(fakeKey.Namespace(), tc.idxs)
+                                        sip := serialize.PropertyMapPartially(fakeKey, tc.pmap)
+                                        store = indexEntries(sip, fakeKey.Namespace(), tc.idxs)
                                 }
                                 for colName, vals := range tc.collections {
                                         i := 0
                                         coll := store.GetCollection(colName)
                                         numItems, _ := coll.GetTotals()
                                         So(numItems, ShouldEqual, len(tc.collections[colName]))
                                         coll.VisitItemsAscend(nil, true, func(itm *gkvlite.Item) bool {
                                                 So(itm.Key, ShouldResemble, vals[i])
                                                 i++
                                                 return true
@@ skipping 114 matching lines @@
                                                 So(data[i], ShouldResemble, itm.Key)
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(data))
                                 }
                         })
                 }
         })
 }