Don't filter "Stop" error in raw interface.

impl/memory/datastore_query_execution_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 (
         "fmt"
         "strings"
         "testing"
@@ skipping 344 matching lines @@
                                         err := data.Run(q, func(pm ds.PropertyMap, gc ds.CursorCB) error {
                                                 So(pm, ShouldResemble, pmap(
                                                         "$key", key("Kind", 2, "__entity_group__", 1), Next,
                                                         "__version__", 1))
 
                                                 err := error(nil)
                                                 curs, err = gc()
                                                 So(err, ShouldBeNil)
                                                 return ds.Stop
                                         })
-                                        So(err, ShouldBeNil)
+                                        So(err, shouldBeSuccessful)
 
                                         err = data.Run(q.Start(curs), func(pm ds.PropertyMap) error {
                                                 So(pm, ShouldResemble, stage1Data[2])
                                                 return ds.Stop
                                         })
-                                        So(err, ShouldBeNil)
+                                        So(err, shouldBeSuccessful)
                                 },
 
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         q := nq("Something").Eq("Does", 2).Order("Not", "-Work")
                                         So(data.Run(q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
                                                 "Consider adding:",
                                                 "- kind: Something",
                                                 "  properties:",
                                                 "  - name: Does",
@@ skipping 130 matching lines @@
                                                                 } else {
                                                                         expect.count = len(expect.get)
                                                                 }
                                                         }
 
                                                         if expect.keys != nil {
                                                                 Convey(fmt.Sprintf("expect %d (keys)", j), func() {
                                                                         err := runner(func(c context.Context) error {
                                                                                 data := ds.Get(c)
                                                                                 count, err := data.Count(expect.q)
-                                                                                So(err, ShouldBeNil)
+                                                                                So(err, shouldBeSuccessful)
                                                                                 So(count, ShouldEqual, expect.count)
 
                                                                                 rslt := []*ds.Key(nil)
-                                                                                So(data.GetAll(expect.q, &rslt), ShouldBeNil)
+                                                                                So(data.GetAll(expect.q, &rslt), shouldBeSuccessful)
                                                                                 So(len(rslt), ShouldEqual, len(expect.keys))
                                                                                 for i, r := range rslt {
                                                                                         So(r, ShouldResemble, expect.keys[i])
                                                                                 }
                                                                                 return nil
                                                                         }, &ds.TransactionOptions{XG: true})
-                                                                        So(err, ShouldBeNil)
+                                                                        So(err, shouldBeSuccessful)
                                                                 })
                                                         }
 
                                                         if expect.get != nil {
                                                                 Convey(fmt.Sprintf("expect %d (data)", j), func() {
                                                                         err := runner(func(c context.Context) error {
                                                                                 data := ds.Get(c)
                                                                                 count, err := data.Count(expect.q)
-                                                                                So(err, ShouldBeNil)
+                                                                                So(err, shouldBeSuccessful)
                                                                                 So(count, ShouldEqual, expect.count)
 
                                                                                 rslt := []ds.PropertyMap(nil)
-                                                                                So(data.GetAll(expect.q, &rslt), ShouldBeNil)
+                                                                                So(data.GetAll(expect.q, &rslt), shouldBeSuccessful)
                                                                                 So(len(rslt), ShouldEqual, len(expect.get))
                                                                                 for i, r := range rslt {
                                                                                         So(r, ShouldResemble, expect.get[i])
                                                                                 }
                                                                                 return nil
                                                                         }, &ds.TransactionOptions{XG: true})
-                                                                        So(err, ShouldBeNil)
+                                                                        So(err, shouldBeSuccessful)
                                                                 })
                                                         }
                                                 }
 
                                                 for j, fn := range stage.extraFns {
                                                         Convey(fmt.Sprintf("extraFn %d", j), func() {
                                                                 fn(c)
                                                         })
                                                 }
                                         })
                                 }
                         })
                 }
         })
 
         Convey("Test AutoIndex", t, func() {
                 c, err := info.Get(Use(context.Background())).Namespace("ns")
                 if err != nil {
                         panic(err)
                 }
 
                 data := ds.Get(c)
                 testing := data.Testable()
                 testing.Consistent(true)
 
                 So(data.Put(pmap("$key", key("Kind", 1), Next,
                         "Val", 1, 2, 3, Next,
                         "Extra", "hello",
-                )), ShouldBeNil)
+                )), shouldBeSuccessful)
 
                 So(data.Put(pmap("$key", key("Kind", 2), Next,
                         "Val", 2, 3, 9, Next,
                         "Extra", "ace", "hello", "there",
-                )), ShouldBeNil)
+                )), shouldBeSuccessful)
 
                 q := nq("Kind").Gt("Val", 2).Order("Val", "Extra")
 
                 count, err := data.Count(q)
                 So(err, ShouldErrLike, "Insufficient indexes")
 
                 testing.AutoIndex(true)
 
                 count, err = data.Count(q)
-                So(err, ShouldBeNil)
+                So(err, shouldBeSuccessful)
                 So(count, ShouldEqual, 2)
         })
 }
+
+func shouldBeSuccessful(actual interface{}, expected ...interface{}) string {
+        if len(expected) != 0 {
+                return "no expected values permitted"
+        }
+        if actual == nil {
+                return ""
+        }
+
+        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)
+}