Fix a bug where deletions weren't updating the raw Kind index.

impl/memory/datastore_query_execution_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         "strings"
         "testing"
@@ skipping 348 matching lines @@
                                         pmap("$key", mkKey("dev~app", "", "__namespace__", "bob")),
                                         pmap("$key", mkKey("dev~app", "", "__namespace__", "ns")),
                                 }},
                                 {q: nq("__namespace__").Offset(1), get: []ds.PropertyMap{
                                         pmap("$key", mkKey("dev~app", "", "__namespace__", "bob")),
                                         pmap("$key", mkKey("dev~app", "", "__namespace__", "ns")),
                                 }},
                                 {q: nq("__namespace__").Offset(1).Limit(1), get: []ds.PropertyMap{
                                         pmap("$key", mkKey("dev~app", "", "__namespace__", "bob")),
                                 }},
+                                //
+                                // eventual consistency; Unique/1 is deleted at HEAD. Keysonly finds it,
+                                // but 'normal' doesn't.
+                                {q: nq("Unique").Gt("__key__", key("AKind", 5)).Lte("__key__", key("Zeta", "prime")),
+                                        keys: []*ds.Key{key("Unique", 1)},
+                                        get:  []ds.PropertyMap{}},
                         },
 
                         extraFns: []func(context.Context){
                                 func(c context.Context) {
                                         curs := ds.Cursor(nil)
 
                                         q := nq("").Gt("__key__", key("Kind", 2))
 
                                         err := ds.Run(c, q, func(pm ds.PropertyMap, gc ds.CursorCB) error {
                                                 So(pm, ShouldResemble, pmap(
@@ skipping 35 matching lines @@
                                                 "  ancestor: yes",
                                                 "  properties:",
                                                 "  - name: Val",
                                         }, "\n"))
                                 },
                         },
                 },
 
                 {
                         expect: []qExpect{
-                                // eventual consistency; Unique/1 is deleted at HEAD. Keysonly finds it,
-                                // but 'normal' doesn't.
-                                {q: nq("Unique").Gt("__key__", key("AKind", 5)).Lte("__key__", key("Zeta", "prime")),
-                                        keys: []*ds.Key{key("Unique", 1)},
-                                        get:  []ds.PropertyMap{}},
-
                                 {q: nq("Kind").Eq("Val", 1, 3), get: []ds.PropertyMap{
                                         stage1Data[0], stage2Data[2],
                                 }},
                         },
                 },
         }},
+
         {"collapsed types", []qExStage{
                 {
                         putEnts: collapsedData,
                 },
                 {
                         expect: []qExpect{
                                 // PTTime
                                 {
                                         q: nq("Kind").Lte("Date", time.Date(2000, time.February, 1, 1, 1, 1, 1, time.UTC)),
                                         get: []ds.PropertyMap{
@@ skipping 30 matching lines @@
                                 },
                                 {
                                         q: nq("Kind").Eq("Val", []byte("uwutm8")),
                                         get: []ds.PropertyMap{
                                                 collapsedData[5],
                                         },
                                 },
                         },
                 },
         }},
+
+        {"regression: tombstones and limit/offset queries", []qExStage{
+                {
+                        putEnts: []ds.PropertyMap{
+                                pmap("$key", key("Kind", 1)),
+                                pmap("$key", key("Kind", 2)),
+                                pmap("$key", key("Kind", 3)),
+                        },
+                        delEnts: []*ds.Key{key("Kind", 2)},
+                },
+                {
+                        expect: []qExpect{
+                                {
+                                        q: nq("Kind").Limit(2),
+                                        get: []ds.PropertyMap{
+                                                pmap("$key", key("Kind", 1)),
+                                                pmap("$key", key("Kind", 3)),
+                                        },
+                                },
+
+                                {
+                                        q:   nq("Kind").Offset(2),
+                                        get: []ds.PropertyMap{},
+                                },
+                        },
+                },
+        }},
 }
 
 func TestQueryExecution(t *testing.T) {
         t.Parallel()
 
         Convey("Test query execution", t, func() {
                 c, err := info.Namespace(Use(context.Background()), "ns")
                 if err != nil {
                         panic(err)
                 }
@@ skipping 17 matching lines @@
                                         }
                                         for ns, ents := range byNs {
                                                 c := info.MustNamespace(c, ns)
                                                 if err := ds.Put(c, ents); err != nil {
                                                         // prevent Convey from thinking this assertion should show up in
                                                         // every test loop.
                                                         panic(err)
                                                 }
                                         }
 
+                                        if len(stage.delEnts) > 0 {
+                                                //fmt.Println("DELETING", stage.delEnts)
+                                        }

[iannucci, 2016/11/12 00:05:47]

derp

                                         if err := ds.Delete(c, stage.delEnts); err != nil {
                                                 panic(err)
                                         }
 
                                         Convey(fmt.Sprintf("stage %d", i), func() {
                                                 for j, expect := range stage.expect {
                                                         runner := func(c context.Context, f func(ic context.Context) error, _ *ds.TransactionOptions) error {
                                                                 return f(c)
                                                         }
                                                         if expect.inTxn {
@@ skipping 100 matching lines @@
 
         v, ok := actual.(error)
         if !ok {
                 return fmt.Sprintf("type of 'actual' must be error, not %T", actual)
         }
         if v == nil || v == ds.Stop {
                 return ""
         }
         return fmt.Sprintf("expected success value, not %v", v)
 }