Clean up callback interfaces.

service/datastore/datastore_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"
@@ skipping 20 matching lines @@
         ns  string
 }
 
 func (f *fakeDatastore) mkKey(elems ...interface{}) *Key {
         return MakeKey(f.aid, f.ns, elems...)
 }
 
 func (f *fakeDatastore) Run(fq *FinalizedQuery, cb RawRunCB) error {
         lim, _ := fq.Limit()
 
+        cursCB := func() (Cursor, error) {
+                return fakeCursor("CURSOR"), nil
+        }
+
         for i := int32(0); i < lim; i++ {
                 if v, ok := fq.eqFilts["$err_single"]; ok {
                         idx := fq.eqFilts["$err_single_idx"][0].Value().(int64)
                         if idx == int64(i) {
                                 return errors.New(v[0].Value().(string))
                         }
                 }
                 k := f.mkKey("Kind", i+1)
                 if i == 10 {
                         k = f.mkKey("Kind", "eleven")
                 }
                 pm := PropertyMap{"Value": {MkProperty(i)}}
-                if !cb(k, pm, nil) {
-                        break
+                if err := cb(k, pm, cursCB); err != nil {
+                        if err == Stop {
+                                err = nil
+                        }
+                        return err
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) PutMulti(keys []*Key, vals []PropertyMap, cb PutMultiCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errors.New("PutMulti fail all")
         }
         _, assertExtra := vals[0].GetMeta("assertExtra")
@@ skipping 579 matching lines @@
                 Convey("ok", func() {
                         Convey("Get", func() {
                                 cs := &CommonStruct{ID: 1}
                                 So(ds.Get(cs), ShouldBeNil)
                                 So(cs.Value, ShouldEqual, 1)
                         })
 
                         Convey("Raw access too", func() {
                                 rds := ds.Raw()
                                 keys := []*Key{ds.MakeKey("Kind", 1)}
-                                So(rds.GetMulti(keys, nil, func(pm PropertyMap, err error) {
+                                So(rds.GetMulti(keys, nil, func(pm PropertyMap, err error) error {
                                         So(err, ShouldBeNil)
                                         So(pm["Value"][0].Value(), ShouldEqual, 1)
+                                        return nil
                                 }), ShouldBeNil)
                         })
 
                         Convey("but general failure to save is fine on a Get", func() {
                                 cs := &FakePLS{failSave: true, IntID: 7}
                                 So(ds.Get(cs), ShouldBeNil)
                         })
                 })
 
         })
@@ skipping 126 matching lines @@
                 Convey("bad", func() {
                         assertBadTypePanics := func(cb interface{}) {
                                 So(func() { ds.Run(q, cb) }, ShouldPanicLike,
                                         "cb does not match the required callback signature")
                         }
 
                         Convey("not a function", func() {
                                 assertBadTypePanics("I am a potato")
                         })
 
+                        Convey("nil", func() {
+                                assertBadTypePanics(nil)
+                        })
+
+                        Convey("interface", func() {
+                                assertBadTypePanics(func(pls PropertyLoadSaver) {})
+                        })
+
                         Convey("bad proto type", func() {
-                                cb := func(v int, _ CursorCB) bool {
+                                cb := func(v int) {
                                         panic("never here!")
                                 }
                                 So(func() { ds.Run(q, cb) }, ShouldPanicLike,
                                         "invalid argument type: int")
                         })
 
                         Convey("wrong # args", func() {
-                                assertBadTypePanics(func(v CommonStruct, _ CursorCB) {
+                                assertBadTypePanics(func(v CommonStruct, _ CursorCB, _ int) {
                                         panic("never here!")
                                 })
                         })
 
                         Convey("wrong ret type", func() {
-                                assertBadTypePanics(func(v CommonStruct, _ CursorCB) error {
+                                assertBadTypePanics(func(v CommonStruct) bool {
+                                        panic("never here!")
+                                })
+                        })
+
+                        Convey("wrong # rets", func() {
+                                assertBadTypePanics(func(v CommonStruct) (int, error) {
                                         panic("never here!")
                                 })
                         })
 
                         Convey("bad 2nd arg", func() {
-                                assertBadTypePanics(func(v CommonStruct, _ Cursor) bool {
+                                assertBadTypePanics(func(v CommonStruct, _ Cursor) error {
                                         panic("never here!")
                                 })
                         })
 
                         Convey("early abort on error", func() {
                                 q = q.Eq("$err_single", "Query fail").Eq("$err_single_idx", 3)
                                 i := 0
-                                So(ds.Run(q, func(c CommonStruct, _ CursorCB) bool {
+                                So(ds.Run(q, func(c CommonStruct) {
                                         i++
-                                        return true
                                 }), ShouldErrLike, "Query fail")
                                 So(i, ShouldEqual, 3)
                         })
 
                         Convey("return error on serialization failure", func() {
-                                So(ds.Run(q, func(_ permaBad, _ CursorCB) bool {
+                                So(ds.Run(q, func(_ permaBad) {
                                         panic("never here")
                                 }).Error(), ShouldEqual, "permaBad")
                         })
                 })
 
                 Convey("ok", func() {
+                        Convey("can return error to stop", func() {
+                                i := 0
+                                So(ds.Run(q, func(c CommonStruct) error {
+                                        i++
+                                        return Stop
+                                }), ShouldBeNil)
+                                So(i, ShouldEqual, 1)
+
+                                i = 0
+                                So(ds.Run(q, func(c CommonStruct, _ CursorCB) error {
+                                        i++
+                                        return fmt.Errorf("my error")
+                                }), ShouldErrLike, "my error")
+                                So(i, ShouldEqual, 1)
+                        })
+
+                        Convey("Can optionally get cursor function", func() {
+                                i := 0
+                                So(ds.Run(q, func(c CommonStruct, ccb CursorCB) {
+                                        i++
+                                        curs, err := ccb()
+                                        So(err, ShouldBeNil)
+                                        So(curs.String(), ShouldEqual, "CURSOR")
+                                }), ShouldBeNil)
+                                So(i, ShouldEqual, 5)
+                        })
+
                         Convey("*S", func() {
                                 i := 0
-                                So(ds.Run(q, func(cs *CommonStruct, _ CursorCB) bool {
+                                So(ds.Run(q, func(cs *CommonStruct) {
                                         So(cs.ID, ShouldEqual, i+1)
                                         So(cs.Value, ShouldEqual, i)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P", func() {
                                 i := 0
-                                So(ds.Run(q.Limit(12), func(fpls *FakePLS, _ CursorCB) bool {
+                                So(ds.Run(q.Limit(12), func(fpls *FakePLS) {
                                         So(fpls.gotLoaded, ShouldBeTrue)
                                         if i == 10 {
                                                 So(fpls.StringID, ShouldEqual, "eleven")
                                         } else {
                                                 So(fpls.IntID, ShouldEqual, i+1)
                                         }
                                         So(fpls.Value, ShouldEqual, i)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P (map)", func() {
                                 i := 0
-                                So(ds.Run(q, func(pm *PropertyMap, _ CursorCB) bool {
+                                So(ds.Run(q, func(pm *PropertyMap) {
                                         k, ok := pm.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So((*pm)["Value"][0].Value(), ShouldEqual, i)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("S", func() {
                                 i := 0
-                                So(ds.Run(q, func(cs CommonStruct, _ CursorCB) bool {
+                                So(ds.Run(q, func(cs CommonStruct) {
                                         So(cs.ID, ShouldEqual, i+1)
                                         So(cs.Value, ShouldEqual, i)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("P", func() {
                                 i := 0
-                                So(ds.Run(q, func(fpls FakePLS, _ CursorCB) bool {
+                                So(ds.Run(q, func(fpls FakePLS) {
                                         So(fpls.gotLoaded, ShouldBeTrue)
                                         So(fpls.IntID, ShouldEqual, i+1)
                                         So(fpls.Value, ShouldEqual, i)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("P (map)", func() {
                                 i := 0
-                                So(ds.Run(q, func(pm PropertyMap, _ CursorCB) bool {
+                                So(ds.Run(q, func(pm PropertyMap) {
                                         k, ok := pm.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(pm["Value"][0].Value(), ShouldEqual, i)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                         Convey("Key", func() {
                                 i := 0
-                                So(ds.Run(q, func(k *Key, _ CursorCB) bool {
+                                So(ds.Run(q, func(k *Key) {
                                         So(k.IntID(), ShouldEqual, i+1)
                                         i++
-                                        return true
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }
 
 type fixedDataDatastore struct {
         RawInterface
 
@@ skipping 279 matching lines @@
                         Convey("extra field with bad type", func() {
                                 type Bad struct {
                                         A int64 `gae:",extra"`
                                 }
                                 So(func() { GetPLS(&Bad{}) }, ShouldPanicLike,
                                         "struct 'extra' field has invalid type int64")
                         })
                 })
         })
 }