Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(117)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: go/src/infra/gae/libs/wrapper/memory/datastore_test.go

Issue 1230303003: Revert "Refactor current GAE abstraction library to be free of the SDK*" (Closed) Base URL: https://chromium.googlesource.com/infra/infra.git@master
Patch Set: Created 5 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « go/src/infra/gae/libs/wrapper/memory/datastore_query.go ('k') | go/src/infra/gae/libs/wrapper/memory/doc.go » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: go/src/infra/gae/libs/wrapper/memory/datastore_test.go
diff --git a/go/src/infra/gae/libs/gae/memory/raw_datstore_test.go b/go/src/infra/gae/libs/wrapper/memory/datastore_test.go
similarity index 56%
rename from go/src/infra/gae/libs/gae/memory/raw_datstore_test.go
rename to go/src/infra/gae/libs/wrapper/memory/datastore_test.go
index d0c5100c806bc9aaf304cbcb88d3dbe232ae2339..8ca4bd7db7e3434a62021050297837245ebb8319 100644
--- a/go/src/infra/gae/libs/gae/memory/raw_datstore_test.go
+++ b/go/src/infra/gae/libs/wrapper/memory/datastore_test.go
@@ -6,136 +6,224 @@ package memory
import (
"fmt"
- "infra/gae/libs/gae"
- "infra/gae/libs/gae/helper"
+ "infra/gae/libs/meta"
+ "infra/gae/libs/wrapper"
"math"
"testing"
. "github.com/smartystreets/goconvey/convey"
"golang.org/x/net/context"
+
+ "appengine/datastore"
)
func TestDatastoreKinder(t *testing.T) {
t.Parallel()
- Convey("Datastore keys", t, func() {
+ Convey("Datastore kinds and keys", t, func() {
c := Use(context.Background())
- rds := gae.GetRDS(c)
- So(rds, ShouldNotBeNil)
+ ds := wrapper.GetDS(c)
+ So(ds, ShouldNotBeNil)
+
+ Convey("implements DSKinder", func() {
+ type Foo struct{}
+ So(ds.Kind(&Foo{}), ShouldEqual, "Foo")
+
+ Convey("which can be tweaked by DSKindSetter", func() {
+ ds.SetKindNameResolver(func(interface{}) string { return "spam" })
+ So(ds.Kind(&Foo{}), ShouldEqual, "spam")
+
+ Convey("and it retains the function so you can stack them", func() {
+ cur := ds.KindNameResolver()
+ ds.SetKindNameResolver(func(o interface{}) string { return "wat" + cur(o) })
+ So(ds.Kind(&Foo{}), ShouldEqual, "watspam")
+ })
+ })
+ })
Convey("implements DSNewKeyer", func() {
Convey("NewKey", func() {
- key := rds.NewKey("nerd", "stringID", 0, nil)
+ key := ds.NewKey("nerd", "stringID", 0, nil)
So(key, ShouldNotBeNil)
So(key.Kind(), ShouldEqual, "nerd")
So(key.StringID(), ShouldEqual, "stringID")
So(key.IntID(), ShouldEqual, 0)
So(key.Parent(), ShouldBeNil)
- So(key.AppID(), ShouldEqual, "dev~app")
+ So(key.AppID(), ShouldEqual, "dev~my~app")
So(key.Namespace(), ShouldEqual, "")
So(key.String(), ShouldEqual, "/nerd,stringID")
- So(helper.DSKeyIncomplete(key), ShouldBeFalse)
- So(helper.DSKeyValid(key, "", false), ShouldBeTrue)
+ So(key.Incomplete(), ShouldBeFalse)
+ So(keyValid("", key, userKeyOnly), ShouldBeTrue)
+
+ chkey := ds.NewKey("wat", "", 100, key)
+ So(chkey, ShouldNotBeNil)
+ So(chkey.Kind(), ShouldEqual, "wat")
+ So(chkey.StringID(), ShouldEqual, "")
+ So(chkey.IntID(), ShouldEqual, 100)
+ So(chkey.Parent(), ShouldEqual, key)
+ So(chkey.AppID(), ShouldEqual, "dev~my~app")
+ So(chkey.Namespace(), ShouldEqual, "")
+ So(chkey.String(), ShouldEqual, "/nerd,stringID/wat,100")
+ So(key.Incomplete(), ShouldBeFalse)
+ So(keyValid("", chkey, userKeyOnly), ShouldBeTrue)
+
+ incompl := ds.NewKey("sup", "", 0, key)
+ So(incompl, ShouldNotBeNil)
+ So(incompl.Incomplete(), ShouldBeTrue)
+ So(keyValid("", incompl, userKeyOnly), ShouldBeTrue)
+ So(incompl.String(), ShouldEqual, "/nerd,stringID/sup,0")
+
+ bad := ds.NewKey("nooo", "", 10, incompl)
+ So(bad, ShouldNotBeNil)
+ So(bad.Incomplete(), ShouldBeFalse)
+ So(keyValid("", bad, userKeyOnly), ShouldBeFalse)
+ So(bad.String(), ShouldEqual, "/nerd,stringID/sup,0/nooo,10")
+
+ So(rootKey(bad), ShouldEqual, key)
+
+ Convey("other key validation", func() {
+ So(keyValid("", nil, userKeyOnly), ShouldBeFalse)
+
+ key := ds.NewKey("", "", 0, nil)
+ So(key, ShouldNotBeNil)
+
+ So(keyValid("", key, userKeyOnly), ShouldBeFalse)
+
+ key = ds.NewKey("noop", "power level", 9000, nil)
+ So(key, ShouldNotBeNil)
+
+ So(keyValid("", key, userKeyOnly), ShouldBeFalse)
+ })
+ })
+
+ Convey("NewKeyObj", func() {
+ type Foo struct {
+ _knd string `goon:"kind,coool"`
+ ID int64 `goon:"id"`
+ Parent *datastore.Key `goon:"parent"`
+ }
+ f := &Foo{ID: 100}
+ k := ds.NewKeyObj(f)
+ So(k.String(), ShouldEqual, "/coool,100")
+
+ f.Parent = k
+ f._knd = "weevils"
+ f.ID = 19
+ k = ds.NewKeyObj(f)
+ So(k.String(), ShouldEqual, "/coool,100/weevils,19")
+
+ Convey("panics when you do a dumb thing", func() {
+ type Foo struct {
+ ID []byte `goon:"id"`
+ }
+ So(func() { ds.NewKeyObj(&Foo{}) }, ShouldPanic)
+ })
+ })
+
+ Convey("NewKeyObjError", func() {
+ type Foo struct {
+ ID []byte `goon:"id"`
+ }
+ _, err := ds.NewKeyObjError(&Foo{})
+ So(err.Error(), ShouldContainSubstring, "must be int64 or string")
})
})
})
}
-func testGetMeta(c context.Context, k gae.DSKey) int64 {
- rds := gae.GetRDS(c)
- k = rds.NewKey("__entity_group__", "", 1, helper.DSKeyRoot(k))
- pmap := gae.DSPropertyMap{}
- rds.Get(k, &pmap)
- return pmap["__version__"][0].Value().(int64)
-}
-
func TestDatastoreSingleReadWriter(t *testing.T) {
t.Parallel()
Convey("Datastore single reads and writes", t, func() {
c := Use(context.Background())
- rds := gae.GetRDS(c)
- So(rds, ShouldNotBeNil)
+ ds := wrapper.GetDS(c)
+ So(ds, ShouldNotBeNil)
Convey("implements DSSingleReadWriter", func() {
type Foo struct {
- Val int
+ ID int64 `goon:"id" datastore:"-"`
+ Parent *datastore.Key `goon:"parent" datastore:"-"`
+ Val int
}
Convey("invalid keys break", func() {
- k := rds.NewKey("Foo", "", 0, nil)
- So(rds.Get(k, nil), ShouldEqual, gae.ErrDSInvalidKey)
+ k := ds.NewKeyObj(&Foo{})
+ f := &Foo{Parent: k}
+ So(ds.Get(f), ShouldEqual, datastore.ErrInvalidKey)
- _, err := rds.Put(rds.NewKey("Foo", "", 0, k), &Foo{})
- So(err, ShouldEqual, gae.ErrDSInvalidKey)
+ _, err := ds.Put(f)
+ So(err, ShouldEqual, datastore.ErrInvalidKey)
})
Convey("getting objects that DNE is an error", func() {
- k := rds.NewKey("Foo", "", 1, nil)
- So(rds.Get(k, nil), ShouldEqual, gae.ErrDSNoSuchEntity)
+ So(ds.Get(&Foo{ID: 1}), ShouldEqual, datastore.ErrNoSuchEntity)
})
Convey("Can Put stuff", func() {
// with an incomplete key!
- k := rds.NewKey("Foo", "", 0, nil)
f := &Foo{Val: 10}
- k, err := rds.Put(k, f)
+ k, err := ds.Put(f)
So(err, ShouldBeNil)
So(k.String(), ShouldEqual, "/Foo,1")
+ So(ds.NewKeyObj(f), ShouldResemble, k)
Convey("and Get it back", func() {
- newFoo := &Foo{}
- err := rds.Get(k, newFoo)
+ newFoo := &Foo{ID: 1}
+ err := ds.Get(newFoo)
So(err, ShouldBeNil)
So(newFoo, ShouldResemble, f)
Convey("and we can Delete it", func() {
- err := rds.Delete(k)
+ err := ds.Delete(ds.NewKey("Foo", "", 1, nil))
So(err, ShouldBeNil)
- err = rds.Get(k, newFoo)
- So(err, ShouldEqual, gae.ErrDSNoSuchEntity)
+ err = ds.Get(newFoo)
+ So(err, ShouldEqual, datastore.ErrNoSuchEntity)
})
})
Convey("Deleteing with a bogus key is bad", func() {
- err := rds.Delete(rds.NewKey("Foo", "wat", 100, nil))
- So(err, ShouldEqual, gae.ErrDSInvalidKey)
+ err := ds.Delete(ds.NewKey("Foo", "wat", 100, nil))
+ So(err, ShouldEqual, datastore.ErrInvalidKey)
})
Convey("Deleteing a DNE entity is fine", func() {
- err := rds.Delete(rds.NewKey("Foo", "wat", 0, nil))
+ err := ds.Delete(ds.NewKey("Foo", "wat", 0, nil))
So(err, ShouldBeNil)
})
Convey("serialization breaks in the normal ways", func() {
type BadFoo struct {
- Val uint8
+ _kind string `goon:"kind,Foo"`
+ ID int64 `goon:"id" datastore:"-"`
+ Val uint8
}
- _, err := rds.Put(k, &BadFoo{})
- So(err.Error(), ShouldContainSubstring, "invalid type: uint8")
+ _, err := ds.Put(&BadFoo{})
+ So(err.Error(), ShouldContainSubstring,
+ "unsupported struct field type: uint8")
- err = rds.Get(k, &BadFoo{})
- So(err.Error(), ShouldContainSubstring, "invalid type: uint8")
+ err = ds.Get(&BadFoo{ID: 1})
+ So(err.Error(), ShouldContainSubstring,
+ "type mismatch: int versus uint8")
})
Convey("check that metadata works", func() {
- So(testGetMeta(c, k), ShouldEqual, 1)
+ val, _ := meta.GetEntityGroupVersion(c, k)
+ So(val, ShouldEqual, 1)
- pkey := k
for i := 0; i < 10; i++ {
- k := rds.NewKey("Foo", "", 0, pkey)
- _, err = rds.Put(k, &Foo{Val: 10})
+ _, err = ds.Put(&Foo{Val: 10, Parent: k})
So(err, ShouldBeNil)
}
- So(testGetMeta(c, k), ShouldEqual, 11)
+ val, _ = meta.GetEntityGroupVersion(c, k)
+ So(val, ShouldEqual, 11)
Convey("ensure that group versions persist across deletes", func() {
- So(rds.Delete(k), ShouldBeNil)
+ So(ds.Delete(k), ShouldBeNil)
for i := int64(1); i < 11; i++ {
- So(rds.Delete(rds.NewKey("Foo", "", i, k)), ShouldBeNil)
+ So(ds.Delete(ds.NewKey("Foo", "", i, k)), ShouldBeNil)
}
// TODO(riannucci): replace with a Count query instead of this cast
- ents := rds.(*dsImpl).data.store.GetCollection("ents:")
+ ents := ds.(*dsImpl).data.store.GetCollection("ents:")
num, _ := ents.GetTotals()
// /__entity_root_ids__,Foo
// /Foo,1/__entity_group__,1
@@ -146,9 +234,10 @@ func TestDatastoreSingleReadWriter(t *testing.T) {
So(err, ShouldBeNil)
So(version, ShouldEqual, 22)
- k, err := rds.Put(k, f)
+ k, err := ds.Put(f)
So(err, ShouldBeNil)
- So(testGetMeta(c, k), ShouldEqual, 23)
+ val, _ := meta.GetEntityGroupVersion(c, k)
+ So(val, ShouldEqual, 23)
})
})
})
@@ -156,57 +245,57 @@ func TestDatastoreSingleReadWriter(t *testing.T) {
Convey("implements DSTransactioner", func() {
type Foo struct {
- Val int
+ ID int64 `goon:"id" datastore:"-"`
+ Parent *datastore.Key `goon:"parent" datastore:"-"`
+ Val int
}
Convey("Put", func() {
- k := rds.NewKey("Foo", "", 0, nil)
f := &Foo{Val: 10}
- k, err := rds.Put(k, f)
+ k, err := ds.Put(f)
So(err, ShouldBeNil)
So(k.String(), ShouldEqual, "/Foo,1")
+ So(ds.NewKeyObj(f), ShouldResemble, k)
Convey("can Put new entity groups", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- So(rds, ShouldNotBeNil)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ So(ds, ShouldNotBeNil)
f1 := &Foo{Val: 100}
- k, err := rds.Put(rds.NewKey("Foo", "", 0, nil), f1)
+ k, err := ds.Put(f1)
So(err, ShouldBeNil)
So(k.String(), ShouldEqual, "/Foo,2")
f2 := &Foo{Val: 200}
- k, err = rds.Put(rds.NewKey("Foo", "", 0, nil), f2)
+ k, err = ds.Put(f2)
So(err, ShouldBeNil)
So(k.String(), ShouldEqual, "/Foo,3")
return nil
- }, &gae.DSTransactionOptions{XG: true})
+ }, &datastore.TransactionOptions{XG: true})
So(err, ShouldBeNil)
- f := &Foo{}
- So(rds.Get(rds.NewKey("Foo", "", 2, nil), f), ShouldBeNil)
+ f := &Foo{ID: 2}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 100)
- f = &Foo{}
- So(rds.Get(rds.NewKey("Foo", "", 3, nil), f), ShouldBeNil)
+ f = &Foo{ID: 3}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 200)
})
Convey("can Put new entities in a current group", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- So(rds, ShouldNotBeNil)
-
- par := k
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ So(ds, ShouldNotBeNil)
- f1 := &Foo{Val: 100}
- k, err := rds.Put(rds.NewKey("Foo", "", 0, par), f1)
+ f1 := &Foo{Val: 100, Parent: ds.NewKeyObj(f)}
+ k, err := ds.Put(f1)
So(err, ShouldBeNil)
So(k.String(), ShouldEqual, "/Foo,1/Foo,1")
- f2 := &Foo{Val: 200}
- k, err = rds.Put(rds.NewKey("Foo", "", 0, par), f2)
+ f2 := &Foo{Val: 200, Parent: ds.NewKeyObj(f)}
+ k, err = ds.Put(f2)
So(err, ShouldBeNil)
So(k.String(), ShouldEqual, "/Foo,1/Foo,2")
@@ -214,113 +303,115 @@ func TestDatastoreSingleReadWriter(t *testing.T) {
}, nil)
So(err, ShouldBeNil)
- f1 := &Foo{}
- So(rds.Get(rds.NewKey("Foo", "", 1, k), f1), ShouldBeNil)
+ f1 := &Foo{ID: 1, Parent: ds.NewKeyObj(&Foo{ID: 1})}
+ So(ds.Get(f1), ShouldBeNil)
So(f1.Val, ShouldEqual, 100)
- f2 := &Foo{}
- So(rds.Get(rds.NewKey("Foo", "", 2, k), f2), ShouldBeNil)
+ f2 := &Foo{ID: 2, Parent: f1.Parent}
+ So(ds.Get(f2), ShouldBeNil)
So(f2.Val, ShouldEqual, 200)
})
Convey("Deletes work too", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- So(rds, ShouldNotBeNil)
- So(rds.Delete(k), ShouldBeNil)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ So(ds, ShouldNotBeNil)
+ So(ds.Delete(ds.NewKeyObj(f)), ShouldBeNil)
return nil
}, nil)
So(err, ShouldBeNil)
- So(rds.Get(k, f), ShouldEqual, gae.ErrDSNoSuchEntity)
+ So(ds.Get(f), ShouldEqual, datastore.ErrNoSuchEntity)
})
Convey("A Get counts against your group count", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- f := &Foo{}
- So(rds.Get(rds.NewKey("Foo", "", 20, nil), f), ShouldEqual, gae.ErrDSNoSuchEntity)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ f := &Foo{ID: 20}
+ So(ds.Get(f), ShouldEqual, datastore.ErrNoSuchEntity)
- So(rds.Get(k, f).Error(), ShouldContainSubstring, "cross-group")
+ f.ID = 1
+ So(ds.Get(f).Error(), ShouldContainSubstring, "cross-group")
return nil
}, nil)
So(err, ShouldBeNil)
})
Convey("Get takes a snapshot", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- txnDS := gae.GetRDS(c)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ txnDS := wrapper.GetDS(c)
So(txnDS, ShouldNotBeNil)
- So(txnDS.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(txnDS.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10)
// Don't ever do this in a real program unless you want to guarantee
// a failed transaction :)
f.Val = 11
- _, err := rds.Put(k, f)
+ _, err := ds.Put(f)
So(err, ShouldBeNil)
- So(txnDS.Get(k, f), ShouldBeNil)
+ So(txnDS.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10)
return nil
}, nil)
So(err, ShouldBeNil)
- f := &Foo{}
- So(rds.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 11)
+
})
Convey("and snapshots are consistent even after Puts", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- txnDS := gae.GetRDS(c)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ txnDS := wrapper.GetDS(c)
So(txnDS, ShouldNotBeNil)
- f := &Foo{}
- So(txnDS.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(txnDS.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10)
// Don't ever do this in a real program unless you want to guarantee
// a failed transaction :)
f.Val = 11
- _, err := rds.Put(k, f)
+ _, err := ds.Put(f)
So(err, ShouldBeNil)
- So(txnDS.Get(k, f), ShouldBeNil)
+ So(txnDS.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10)
f.Val = 20
- _, err = txnDS.Put(k, f)
+ _, err = txnDS.Put(f)
So(err, ShouldBeNil)
- So(txnDS.Get(k, f), ShouldBeNil)
+ So(txnDS.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10) // still gets 10
return nil
}, nil)
So(err.Error(), ShouldContainSubstring, "concurrent")
- f := &Foo{}
- So(rds.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 11)
})
Convey("Reusing a transaction context is bad news", func() {
- k := rds.NewKey("Foo", "", 1, nil)
- txnDS := gae.RawDatastore(nil)
- err := rds.RunInTransaction(func(c context.Context) error {
- txnDS = gae.GetRDS(c)
- So(txnDS.Get(k, &Foo{}), ShouldBeNil)
+ txnDS := wrapper.Datastore(nil)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ txnDS = wrapper.GetDS(c)
+ So(txnDS.Get(&Foo{ID: 1}), ShouldBeNil)
return nil
}, nil)
So(err, ShouldBeNil)
- So(txnDS.Get(k, &Foo{}).Error(), ShouldContainSubstring, "expired")
+ So(txnDS.Get(&Foo{ID: 1}).Error(), ShouldContainSubstring, "expired")
})
Convey("Nested transactions are rejected", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- err := gae.GetRDS(c).RunInTransaction(func(c context.Context) error {
+ err := ds.RunInTransaction(func(c context.Context) error {
+ err := wrapper.GetDS(c).RunInTransaction(func(c context.Context) error {
panic("noooo")
}, nil)
So(err.Error(), ShouldContainSubstring, "nested transactions")
@@ -337,16 +428,16 @@ func TestDatastoreSingleReadWriter(t *testing.T) {
// entity group as soon as something observes/affects it.
//
// That said... I'm not sure if there's really a semantic difference.
- err := rds.RunInTransaction(func(c context.Context) error {
- txnDS := gae.GetRDS(c)
- f := &Foo{Val: 21}
- _, err = txnDS.Put(k, f)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ txnDS := wrapper.GetDS(c)
+ f := &Foo{ID: 1, Val: 21}
+ _, err = txnDS.Put(f)
So(err, ShouldBeNil)
- err := rds.RunInTransaction(func(c context.Context) error {
- txnDS := gae.GetRDS(c)
- f := &Foo{Val: 27}
- _, err := txnDS.Put(k, f)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ txnDS := wrapper.GetDS(c)
+ f := &Foo{ID: 1, Val: 27}
+ _, err := txnDS.Put(f)
So(err, ShouldBeNil)
return nil
}, nil)
@@ -356,20 +447,21 @@ func TestDatastoreSingleReadWriter(t *testing.T) {
}, nil)
So(err.Error(), ShouldContainSubstring, "concurrent")
- f := &Foo{}
- So(rds.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 27)
})
Convey("XG", func() {
Convey("Modifying two groups with XG=false is invalid", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- f := &Foo{Val: 200}
- _, err := rds.Put(k, f)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ f := &Foo{ID: 1, Val: 200}
+ _, err := ds.Put(f)
So(err, ShouldBeNil)
- _, err = rds.Put(rds.NewKey("Foo", "", 2, nil), f)
+ f.ID = 2
+ _, err = ds.Put(f)
So(err.Error(), ShouldContainSubstring, "cross-group")
return err
}, nil)
@@ -377,53 +469,52 @@ func TestDatastoreSingleReadWriter(t *testing.T) {
})
Convey("Modifying >25 groups with XG=true is invald", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
for i := int64(1); i < 26; i++ {
- k := rds.NewKey("Foo", "", i, nil)
- f := &Foo{Val: 200}
- _, err := rds.Put(k, f)
+ f := &Foo{ID: i, Val: 200}
+ _, err := ds.Put(f)
So(err, ShouldBeNil)
}
- f := &Foo{Val: 200}
- _, err := rds.Put(rds.NewKey("Foo", "", 27, nil), f)
+ f := &Foo{ID: 27, Val: 200}
+ _, err := ds.Put(f)
So(err.Error(), ShouldContainSubstring, "too many entity groups")
return err
- }, &gae.DSTransactionOptions{XG: true})
+ }, &datastore.TransactionOptions{XG: true})
So(err.Error(), ShouldContainSubstring, "too many entity groups")
})
})
Convey("Errors and panics", func() {
Convey("returning an error aborts", func() {
- err := rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- f := &Foo{Val: 200}
- _, err := rds.Put(k, f)
+ err := ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ f := &Foo{ID: 1, Val: 200}
+ _, err := ds.Put(f)
So(err, ShouldBeNil)
return fmt.Errorf("thingy")
}, nil)
So(err.Error(), ShouldEqual, "thingy")
- f := &Foo{}
- So(rds.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10)
})
Convey("panicing aborts", func() {
So(func() {
- rds.RunInTransaction(func(c context.Context) error {
- rds := gae.GetRDS(c)
- f := &Foo{Val: 200}
- _, err := rds.Put(k, f)
+ ds.RunInTransaction(func(c context.Context) error {
+ ds := wrapper.GetDS(c)
+ f := &Foo{ID: 1, Val: 200}
+ _, err := ds.Put(f)
So(err, ShouldBeNil)
panic("wheeeeee")
}, nil)
}, ShouldPanic)
- f := &Foo{}
- So(rds.Get(k, f), ShouldBeNil)
+ f := &Foo{ID: 1}
+ So(ds.Get(f), ShouldBeNil)
So(f.Val, ShouldEqual, 10)
})
})
@@ -440,11 +531,11 @@ const IntIs32Bits = int64(MaxInt) < math.MaxInt64
func TestDatastoreQueryer(t *testing.T) {
Convey("Datastore Query suport", t, func() {
c := Use(context.Background())
- rds := gae.GetRDS(c)
- So(rds, ShouldNotBeNil)
+ ds := wrapper.GetDS(c)
+ So(ds, ShouldNotBeNil)
Convey("can create good queries", func() {
- q := rds.NewQuery("Foo").KeysOnly().Limit(10).Offset(39)
+ q := ds.NewQuery("Foo").KeysOnly().Limit(10).Offset(39)
q = q.Start(queryCursor("kosmik")).End(queryCursor("krabs"))
So(q, ShouldNotBeNil)
So(q.(*queryImpl).err, ShouldBeNil)
@@ -453,7 +544,7 @@ func TestDatastoreQueryer(t *testing.T) {
})
Convey("normalize ensures orders make sense", func() {
- q := rds.NewQuery("Cool")
+ q := ds.NewQuery("Cool")
q = q.Filter("cat =", 19).Filter("bob =", 10).Order("bob").Order("bob")
Convey("removes dups and equality orders", func() {
@@ -473,7 +564,7 @@ func TestDatastoreQueryer(t *testing.T) {
Convey("if we equality-filter on __key__, order is ditched", func() {
q = q.Order("wat")
- q := q.Filter("__key__ =", rds.NewKey("Foo", "wat", 0, nil))
+ q := q.Filter("__key__ =", ds.NewKey("Foo", "wat", 0, nil))
qi := q.(*queryImpl).normalize().checkCorrectness("", false)
So(qi.order, ShouldResemble, []queryOrder(nil))
So(qi.err, ShouldBeNil)
@@ -488,7 +579,7 @@ func TestDatastoreQueryer(t *testing.T) {
})
Convey("can create bad queries", func() {
- q := rds.NewQuery("Foo")
+ q := ds.NewQuery("Foo")
Convey("bad filter ops", func() {
q := q.Filter("Bob !", "value")
@@ -529,26 +620,26 @@ func TestDatastoreQueryer(t *testing.T) {
So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "invalid cursor")
})
Convey("Bad ancestors", func() {
- q := q.Ancestor(rds.NewKey("Goop", "wat", 10, nil))
+ q := q.Ancestor(ds.NewKey("Goop", "wat", 10, nil))
So(q, ShouldNotBeNil)
qi := q.(*queryImpl).checkCorrectness("", false)
- So(qi.err, ShouldEqual, gae.ErrDSInvalidKey)
+ So(qi.err, ShouldEqual, datastore.ErrInvalidKey)
})
Convey("nil ancestors", func() {
qi := q.Ancestor(nil).(*queryImpl).checkCorrectness("", false)
So(qi.err.Error(), ShouldContainSubstring, "nil query ancestor")
})
Convey("Bad key filters", func() {
- q := q.Filter("__key__ =", rds.NewKey("Goop", "wat", 10, nil))
+ q := q.Filter("__key__ =", ds.NewKey("Goop", "wat", 10, nil))
qi := q.(*queryImpl).checkCorrectness("", false)
- So(qi.err, ShouldEqual, gae.ErrDSInvalidKey)
+ So(qi.err, ShouldEqual, datastore.ErrInvalidKey)
})
Convey("non-ancestor queries in a transaction", func() {
qi := q.(*queryImpl).checkCorrectness("", true)
So(qi.err.Error(), ShouldContainSubstring, "Only ancestor queries")
})
Convey("absurd numbers of filters are prohibited", func() {
- q := q.Ancestor(rds.NewKey("thing", "wat", 0, nil))
+ q := q.Ancestor(ds.NewKey("thing", "wat", 0, nil))
for i := 0; i < 100; i++ {
q = q.Filter("something =", 10)
}
@@ -571,17 +662,17 @@ func TestDatastoreQueryer(t *testing.T) {
So(qi.err.Error(), ShouldContainSubstring, "first sort property")
})
Convey("kindless with non-__key__ filters", func() {
- q := rds.NewQuery("").Filter("face <", 25.3)
+ q := ds.NewQuery("").Filter("face <", 25.3)
qi := q.(*queryImpl).checkCorrectness("", false)
So(qi.err.Error(), ShouldContainSubstring, "kind is required for non-__key__")
})
Convey("kindless with non-__key__ orders", func() {
- q := rds.NewQuery("").Order("face")
+ q := ds.NewQuery("").Order("face")
qi := q.(*queryImpl).checkCorrectness("", false)
So(qi.err.Error(), ShouldContainSubstring, "kind is required for all orders")
})
Convey("kindless with decending-__key__ orders", func() {
- q := rds.NewQuery("").Order("-__key__")
+ q := ds.NewQuery("").Order("-__key__")
qi := q.(*queryImpl).checkCorrectness("", false)
So(qi.err.Error(), ShouldContainSubstring, "kind is required for all orders")
})
« no previous file with comments | « go/src/infra/gae/libs/wrapper/memory/datastore_query.go ('k') | go/src/infra/gae/libs/wrapper/memory/doc.go » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698