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
}