func TestGetEntityGroupVersion(t *testing.T) {
t.Parallel()
Convey("GetEntityGroupVersion", t, func() {
c := memory.Use(context.Background())
c, fb := featureBreaker.FilterRDS(c, errors.New("INTERNAL_ERROR"))
rds := rawdatastore.Get(c)
aKey, err := rds.Put(rds.NewKey("A", "", 0, nil), rawdatastore.PropertyMap{
"Val": {rawdatastore.MkProperty(10)},
})
So(err, ShouldBeNil)
v, err := GetEntityGroupVersion(c, aKey)
So(err, ShouldBeNil)
So(v, ShouldEqual, 1)
So(rds.Delete(aKey), ShouldBeNil)
v, err = GetEntityGroupVersion(c, rds.NewKey("madeUp", "thing", 0, aKey))
So(err, ShouldBeNil)
So(v, ShouldEqual, 2)
v, err = GetEntityGroupVersion(c, rds.NewKey("madeUp", "thing", 0, nil))
So(err, ShouldBeNil)
So(v, ShouldEqual, 0)
fb.BreakFeatures(nil, "Get")
v, err = GetEntityGroupVersion(c, aKey)
So(err.Error(), ShouldContainSubstring, "INTERNAL_ERROR")
})
}
func TestGetEntityGroupVersion(t *testing.T) {
t.Parallel()
Convey("GetEntityGroupVersion", t, func() {
c := memory.Use(context.Background())
c, fb := featureBreaker.FilterRDS(c, errors.New("INTERNAL_ERROR"))
ds := dstore.Get(c)
pm := dstore.PropertyMap{
"$key": {dstore.MkPropertyNI(ds.NewKey("A", "", 0, nil))},
"Val": {dstore.MkProperty(10)},
}
So(ds.Put(pm), ShouldBeNil)
aKey, ok := pm.GetMetaDefault("key", nil).(dstore.Key)
So(ok, ShouldBeTrue)
So(aKey, ShouldNotBeNil)
v, err := GetEntityGroupVersion(c, aKey)
So(err, ShouldBeNil)
So(v, ShouldEqual, 1)
So(ds.Delete(aKey), ShouldBeNil)
v, err = GetEntityGroupVersion(c, ds.NewKey("madeUp", "thing", 0, aKey))
So(err, ShouldBeNil)
So(v, ShouldEqual, 2)
v, err = GetEntityGroupVersion(c, ds.NewKey("madeUp", "thing", 0, nil))
So(err, ShouldBeNil)
So(v, ShouldEqual, 0)
fb.BreakFeatures(nil, "GetMulti")
v, err = GetEntityGroupVersion(c, aKey)
So(err.Error(), ShouldContainSubstring, "INTERNAL_ERROR")
})
}
func TestCount(t *testing.T) {
t.Parallel()
Convey("Test Count filter", t, func() {
c, fb := featureBreaker.FilterRDS(memory.Use(context.Background()), nil)
c, ctr := FilterRDS(c)
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
ds := datastore.Get(c)
vals := []datastore.PropertyMap{{
"Val": {datastore.MkProperty(100)},
"$key": {datastore.MkPropertyNI(ds.NewKey("Kind", "", 1, nil))},
}}
Convey("Calling a ds function should reflect in counter", func() {
So(ds.PutMulti(vals), ShouldBeNil)
So(ctr.PutMulti.Successes(), ShouldEqual, 1)
Convey("effects are cumulative", func() {
So(ds.PutMulti(vals), ShouldBeNil)
So(ctr.PutMulti.Successes(), ShouldEqual, 2)
Convey("even within transactions", func() {
die(ds.RunInTransaction(func(c context.Context) error {
ds := datastore.Get(c)
So(ds.PutMulti(append(vals, vals[0])), ShouldBeNil)
return nil
}, nil))
})
})
})
Convey("errors count against errors", func() {
fb.BreakFeatures(nil, "GetMulti")
So(ds.GetMulti(vals), ShouldErrLike, `"GetMulti" is broken`)
So(ctr.GetMulti.Errors(), ShouldEqual, 1)
fb.UnbreakFeatures("GetMulti")
So(ds.PutMulti(vals), ShouldBeNil)
die(ds.GetMulti(vals))
So(ctr.GetMulti.Errors(), ShouldEqual, 1)
So(ctr.GetMulti.Successes(), ShouldEqual, 1)
So(ctr.GetMulti.Total(), ShouldEqual, 2)
})
})
Convey("works for memcache", t, func() {
c, ctr := FilterMC(memory.Use(context.Background()))
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
mc := memcache.Get(c)
die(mc.Set(mc.NewItem("hello").SetValue([]byte("sup"))))
_, err := mc.Get("Wat")
So(err, ShouldNotBeNil)
_, err = mc.Get("hello")
die(err)
So(ctr.SetMulti, shouldHaveSuccessesAndErrors, 1, 0)
So(ctr.GetMulti, shouldHaveSuccessesAndErrors, 2, 0)
So(ctr.NewItem, shouldHaveSuccessesAndErrors, 3, 0)
})
Convey("works for taskqueue", t, func() {
c, ctr := FilterTQ(memory.Use(context.Background()))
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
tq := taskqueue.Get(c)
die(tq.Add(&taskqueue.Task{Name: "wat"}, ""))
So(tq.Add(&taskqueue.Task{Name: "wat"}, "DNE_QUEUE"),
ShouldErrLike, "UNKNOWN_QUEUE")
So(ctr.AddMulti, shouldHaveSuccessesAndErrors, 1, 1)
})
Convey("works for global info", t, func() {
c, fb := featureBreaker.FilterGI(memory.Use(context.Background()), nil)
c, ctr := FilterGI(c)
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
gi := info.Get(c)
_, err := gi.Namespace("foo")
die(err)
fb.BreakFeatures(nil, "Namespace")
_, err = gi.Namespace("boom")
So(err, ShouldErrLike, `"Namespace" is broken`)
So(ctr.Namespace, shouldHaveSuccessesAndErrors, 1, 1)
})
Convey("works for user", t, func() {
c, fb := featureBreaker.FilterUser(memory.Use(context.Background()), nil)
c, ctr := FilterUser(c)
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
u := user.Get(c)
_, err := u.CurrentOAuth("foo")
die(err)
fb.BreakFeatures(nil, "CurrentOAuth")
_, err = u.CurrentOAuth("foo")
So(err, ShouldErrLike, `"CurrentOAuth" is broken`)
So(ctr.CurrentOAuth, shouldHaveSuccessesAndErrors, 1, 1)
})
Convey("works for mail", t, func() {
c, fb := featureBreaker.FilterMail(memory.Use(context.Background()), nil)
c, ctr := FilterMail(c)
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
m := mail.Get(c)
err := m.Send(&mail.Message{
Sender: "*****@*****.**",
To: []string{"*****@*****.**"},
Body: "hi",
})
die(err)
fb.BreakFeatures(nil, "Send")
err = m.Send(&mail.Message{
Sender: "*****@*****.**",
To: []string{"*****@*****.**"},
Body: "hi",
})
So(err, ShouldErrLike, `"Send" is broken`)
So(ctr.Send, shouldHaveSuccessesAndErrors, 1, 1)
})
}
func TestCount(t *testing.T) {
t.Parallel()
Convey("Test Count filter", t, func() {
c, fb := featureBreaker.FilterRDS(memory.Use(context.Background()), nil)
c, ctr := FilterRDS(c)
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
ds := datastore.Get(c)
vals := []datastore.PropertyMap{{
"Val": {datastore.MkProperty(100)},
"$key": {datastore.MkPropertyNI(ds.NewKey("Kind", "", 1, nil))},
}}
Convey("Calling a ds function should reflect in counter", func() {
So(ds.PutMulti(vals), ShouldBeNil)
So(ctr.NewKey.Successes(), ShouldEqual, 1)
So(ctr.PutMulti.Successes(), ShouldEqual, 1)
Convey("effects are cumulative", func() {
So(ds.PutMulti(vals), ShouldBeNil)
So(ctr.PutMulti.Successes(), ShouldEqual, 2)
Convey("even within transactions", func() {
ds.RunInTransaction(func(c context.Context) error {
ds := datastore.Get(c)
So(ds.PutMulti(append(vals, vals[0])), ShouldBeNil)
return nil
}, nil)
})
})
})
Convey("errors count against errors", func() {
fb.BreakFeatures(nil, "GetMulti")
ds.GetMulti(vals)
So(ctr.GetMulti.Errors(), ShouldEqual, 1)
fb.UnbreakFeatures("GetMulti")
So(ds.PutMulti(vals), ShouldBeNil)
ds.GetMulti(vals)
So(ctr.GetMulti.Errors(), ShouldEqual, 1)
So(ctr.GetMulti.Successes(), ShouldEqual, 1)
So(ctr.GetMulti.Total(), ShouldEqual, 2)
})
})
Convey("works for memcache", t, func() {
c, ctr := FilterMC(memory.Use(context.Background()))
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
mc := memcache.Get(c)
mc.Set(mc.NewItem("hello").SetValue([]byte("sup")))
So(mc.Get(mc.NewItem("Wat")), ShouldNotBeNil)
mc.Get(mc.NewItem("hello"))
So(ctr.SetMulti, shouldHaveSuccessesAndErrors, 1, 0)
So(ctr.GetMulti, shouldHaveSuccessesAndErrors, 2, 0)
So(ctr.NewItem, shouldHaveSuccessesAndErrors, 3, 0)
})
Convey("works for taskqueue", t, func() {
c, ctr := FilterTQ(memory.Use(context.Background()))
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
tq := taskqueue.Get(c)
tq.Add(&taskqueue.Task{Name: "wat"}, "")
tq.Add(&taskqueue.Task{Name: "wat"}, "DNE_QUEUE")
So(ctr.AddMulti, shouldHaveSuccessesAndErrors, 1, 1)
})
Convey("works for global info", t, func() {
c, fb := featureBreaker.FilterGI(memory.Use(context.Background()), nil)
c, ctr := FilterGI(c)
So(c, ShouldNotBeNil)
So(ctr, ShouldNotBeNil)
gi := info.Get(c)
gi.Namespace("foo")
fb.BreakFeatures(nil, "Namespace")
gi.Namespace("boom")
So(ctr.Namespace, shouldHaveSuccessesAndErrors, 1, 1)
})
}