Add testable interface for datastore.

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 (
         "testing"
         "time"
 
@@ skipping 54 matching lines @@
                                                 },
                                                 "nerd": {
                                                         cat(ds.PTFloat, 103.7),
                                                 },
                                         })
                                 })
                                 Convey("defaultIndicies", func() {
                                         idxs := defaultIndicies("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")
+                                        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 rowGenTestCases = []struct {
         name        string
         pmap        ds.PropertyMap
         withBuiltin bool
-        idxs        []*qIndex
+        idxs        []*ds.IndexDefinition
 
         // These are checked in TestIndexRowGen. nil to skip test case.
         expected []serializedPvals
 
         // just the collections you want to assert. These are checked in
         // TestIndexEntries. nil to skip test case.
         collections map[string][]kv
 }{
         {
                 name: "simple including builtins",
                 pmap: ds.PropertyMap{
                         "wat":  {propNI("thing"), prop("hat"), prop(100)},
                         "nerd": {prop(103.7)},
                         "spaz": {propNI(false)},
                 },
                 withBuiltin: true,
-                idxs: []*qIndex{
+                idxs: []*ds.IndexDefinition{
                         indx("knd", "-wat", "nerd"),
                 },
                 expected: []serializedPvals{
                         {{}}, // B:knd
+                        {cat(ds.PTFloat, 103.7)},                        // B:knd/nerd
+                        {cat(ds.PTInt, 100), cat(ds.PTString, "hat")},   // B:knd/wat
                         {icat(ds.PTFloat, 103.7)},                       // B:knd/-nerd
                         {icat(ds.PTString, "hat"), icat(ds.PTInt, 100)}, // B:knd/-wat
-                        {cat(ds.PTFloat, 103.7)},                        // B:knd/nerd
-                        {cat(ds.PTInt, 100), cat(ds.PTString, "hat")},   // B:knd/wat
-                        { // B:knd/-wat/nerd
+                        { // C:knd/-wat/nerd
                                 cat(icat(ds.PTString, "hat"), cat(ds.PTFloat, 103.7)),
                                 cat(icat(ds.PTInt, 100), cat(ds.PTFloat, 103.7)),
                         },
                 },
                 collections: map[string][]kv{
                         "idx": {
                                 // 0 == builtin, 1 == complex
-                                {cat(byte(0), "knd", byte(1), 0), []byte{}},
-                                {cat(byte(0), "knd", byte(1), 1, byte(0), "nerd"), []byte{}},
-                                {cat(byte(0), "knd", byte(1), 1, byte(0), "wat"), []byte{}},
-                                {cat(byte(0), "knd", byte(1), 1, byte(1), "nerd"), []byte{}},
-                                {cat(byte(0), "knd", byte(1), 1, byte(1), "wat"), []byte{}},
-                                {cat(byte(1), "knd", byte(1), 2, byte(1), "wat", byte(0), "nerd"), []byte{}},
+                                {cat(byte(0), "knd", byte(0), 0), []byte{}},
+                                {cat(byte(0), "knd", byte(0), 1, byte(0), "nerd"), []byte{}},
+                                {cat(byte(0), "knd", byte(0), 1, byte(0), "wat"), []byte{}},
+                                {cat(byte(0), "knd", byte(0), 1, byte(1), "nerd"), []byte{}},
+                                {cat(byte(0), "knd", byte(0), 1, byte(1), "wat"), []byte{}},
+                                {cat(byte(1), "knd", byte(0), 2, byte(1), "wat", byte(0), "nerd"), []byte{}},
                         },
                         "idx:ns:" + sat(indx("knd")): {
                                 {cat(fakeKey), []byte{}},
                         },
                         "idx:ns:" + sat(indx("knd", "wat")): {
                                 {cat(ds.PTInt, 100, fakeKey), []byte{}},
                                 {cat(ds.PTString, "hat", fakeKey), cat(ds.PTInt, 100)},
                         },
                         "idx:ns:" + sat(indx("knd", "-wat")): {
                                 {cat(icat(ds.PTString, "hat"), fakeKey), []byte{}},
                                 {cat(icat(ds.PTInt, 100), fakeKey), icat(ds.PTString, "hat")},
                         },
                 },
         },
         {
                 name: "complex",
                 pmap: ds.PropertyMap{
                         "yerp": {prop("hat"), prop(73.9)},
                         "wat": {
                                 prop(rgenComplexTime),
                                 prop(ds.ByteString("value")),
                                 prop(rgenComplexKey)},
                         "spaz": {prop(nil), prop(false), prop(true)},
                 },
-                idxs: []*qIndex{
+                idxs: []*ds.IndexDefinition{
                         indx("knd", "-wat", "nerd", "spaz"), // doesn't match, so empty
                         indx("knd", "yerp", "-wat", "spaz"),
                 },
                 expected: []serializedPvals{
                         {}, // 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(cat(ds.PTString, "hat"), icat(ds.PTKey, rgenComplexKey), cat(ds.PTNull)),
                                 cat(cat(ds.PTString, "hat"), icat(ds.PTKey, rgenComplexKey), cat(ds.PTBoolFalse)),
@@ skipping 15 matching lines @@
                                 cat(cat(ds.PTFloat, 73.9), icat(ds.PTTime, rgenComplexTime), cat(ds.PTBoolFalse)),
                                 cat(cat(ds.PTFloat, 73.9), icat(ds.PTTime, rgenComplexTime), cat(ds.PTBoolTrue)),
                         },
                 },
         },
         {
                 name: "ancestor",
                 pmap: ds.PropertyMap{
                         "wat": {prop("sup")},
                 },
-                idxs: []*qIndex{
+                idxs: []*ds.IndexDefinition{
                         indx("knd!", "wat"),
                 },
                 collections: map[string][]kv{
                         "idx:ns:" + sat(indx("knd!", "wat")): {
                                 {cat(fakeKey.Parent(), ds.PTString, "sup", fakeKey), []byte{}},
                                 {cat(fakeKey, ds.PTString, "sup", fakeKey), []byte{}},
                         },
                 },
         },
 }
 
 func TestIndexRowGen(t *testing.T) {
         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(tc.pmap)
-                                idxs := []*qIndex(nil)
+                                idxs := []*ds.IndexDefinition(nil)
                                 if tc.withBuiltin {
                                         idxs = append(defaultIndicies("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, mvals)
@@ skipping 47 matching lines @@
         })
 }
 
 type dumbItem struct {
         key   ds.Key
         props ds.PropertyMap
 }
 
 var updateIndiciesTests = []struct {
         name     string
-        idxs     []*qIndex
+        idxs     []*ds.IndexDefinition
         data     []dumbItem
         expected map[string][][]byte
 }{
         {
                 name: "basic",
                 data: []dumbItem{
                         {key("knd", 1), ds.PropertyMap{
                                 "wat":  {prop(10)},
                                 "yerp": {prop(10)}},
                         },
@@ skipping 16 matching lines @@
                                 cat(icat(ds.PTInt, 1), key("knd", 10)),
                         },
                         "idx:ns:" + sat(indx("knd", "yerp")): {
                                 cat(ds.PTInt, 200, key("knd", 10)),
                                 cat(ds.PTInt, 202, key("knd", 1)),
                         },
                 },
         },
         {
                 name: "compound",
-                idxs: []*qIndex{indx("knd", "yerp", "-wat")},
+                idxs: []*ds.IndexDefinition{indx("knd", "yerp", "-wat")},
                 data: []dumbItem{
                         {key("knd", 1), ds.PropertyMap{
                                 "wat":  {prop(10)},
                                 "yerp": {prop(100)}},
                         },
                         {key("knd", 10), ds.PropertyMap{
                                 "wat":  {prop(1)},
                                 "yerp": {prop(200)}},
                         },
                         {key("knd", 11), ds.PropertyMap{
@@ skipping 49 matching lines @@
                                                 So(data[i], ShouldResemble, itm.Key)
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(data))
                                 }
                         })
                 }
         })
 }