func TestBrokenFeatures(t *testing.T) {
t.Parallel()
e := errors.New("default err")
Convey("BrokenFeatures", t, func() {
c := memory.Use(context.Background())
Convey("Can break ds", func() {
Convey("without a default", func() {
c, bf := FilterRDS(c, nil)
ds := datastore.Get(c)
vals := []datastore.PropertyMap{{
"$key": {datastore.MkPropertyNI(ds.NewKey("Wut", "", 1, nil))},
}}
Convey("by specifying an error", func() {
bf.BreakFeatures(e, "GetMulti", "PutMulti")
So(ds.GetMulti(vals), ShouldEqual, e)
Convey("and you can unbreak them as well", func() {
bf.UnbreakFeatures("GetMulti")
So(errors.SingleError(ds.GetMulti(vals)), ShouldEqual, datastore.ErrNoSuchEntity)
Convey("no broken features at all is a shortcut", func() {
bf.UnbreakFeatures("PutMulti")
So(errors.SingleError(ds.GetMulti(vals)), ShouldEqual, datastore.ErrNoSuchEntity)
})
})
})
Convey("Not specifying an error gets you a generic error", func() {
bf.BreakFeatures(nil, "GetMulti")
So(ds.GetMulti(vals).Error(), ShouldContainSubstring, `feature "GetMulti" is broken`)
})
})
Convey("with a default", func() {
c, bf := FilterRDS(c, e)
ds := datastore.Get(c)
vals := []datastore.PropertyMap{{
"$key": {datastore.MkPropertyNI(ds.NewKey("Wut", "", 1, nil))},
}}
bf.BreakFeatures(nil, "GetMulti")
So(ds.GetMulti(vals), ShouldEqual, e)
})
})
})
}
func (d *datastoreImpl) Delete(key Key) (err error) {
return errors.SingleError(d.DeleteMulti([]Key{key}))
}
func (d *datastoreImpl) Put(src interface{}) (err error) {
if !isOkType(reflect.TypeOf(src)) {
return fmt.Errorf("invalid Put input type: %T", src)
}
return errors.SingleError(d.PutMulti([]interface{}{src}))
}
func (d *datastoreImpl) Get(dst interface{}) (err error) {
if !isOkType(reflect.TypeOf(dst)) {
return fmt.Errorf("invalid Get input type: %T", dst)
}
return errors.SingleError(d.GetMulti([]interface{}{dst}))
}
func (t *taskqueueImpl) Delete(task *Task, queueName string) error {
return errors.SingleError(t.DeleteMulti([]*Task{task}, queueName))
}
func (t *taskqueueImpl) Add(task *Task, queueName string) error {
return errors.SingleError(t.AddMulti([]*Task{task}, queueName))
}
func (m *memcacheImpl) CompareAndSwap(item Item) error {
return errors.SingleError(m.CompareAndSwapMulti([]Item{item}))
}
func (m *memcacheImpl) Get(item Item) error {
return errors.SingleError(m.GetMulti([]Item{item}))
}
func (m *memcacheImpl) Delete(key string) error {
return errors.SingleError(m.DeleteMulti([]string{key}))
}
func (m *memcacheImpl) Add(item Item) error {
return errors.SingleError(m.AddMulti([]Item{item}))
}
func (d *datastoreImpl) Put(src interface{}) (err error) {
if err := isOkType(reflect.TypeOf(src)); err != nil {
panic(fmt.Errorf("invalid Put input type (%T): %s", src, err))
}
return errors.SingleError(d.PutMulti([]interface{}{src}))
}
func (d *datastoreImpl) Get(dst interface{}) (err error) {
if err := isOkType(reflect.TypeOf(dst)); err != nil {
panic(fmt.Errorf("invalid Get input type (%T): %s", dst, err))
}
return errors.SingleError(d.GetMulti([]interface{}{dst}))
}
func (d *datastoreImpl) Exists(k *Key) (bool, error) {
ret, err := d.ExistsMulti([]*Key{k})
return ret[0], errors.SingleError(err)
}
func (m *memcacheImpl) Get(key string) (Item, error) {
ret := m.NewItem(key)
err := errors.SingleError(m.GetMulti([]Item{ret}))
return ret, err
}