test for TxnDatastore keytransform wrapper

Author: i-norden

keytransform/txndatastore_test.go

@@ -0,0 +1,175 @@
+package keytransform_test
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"sort"
+
+	. "gopkg.in/check.v1"
+
+	ds "github.com/ipfs/go-datastore"
+	kt "github.com/ipfs/go-datastore/keytransform"
+	dsq "github.com/ipfs/go-datastore/query"
+	dstest "github.com/ipfs/go-datastore/test"
+)
+
+var _ = Suite(&DSSuite{})
+
+func (ks *DSSuite) TestWrapTxnDatastoreBasic(c *C) {
+	ctx := context.Background()
+	ms := ds.NewMapDatastore()
+	mpds := dstest.NewTestTxnDatastore(ms, true)
+
+	kt.WrapTxnDatastore(mpds, pair)
+	ktds := kt.WrapTxnDatastore(mpds, pair)
+	ktdsTx, err := ktds.NewTransaction(ctx, false)
+	c.Check(err, Equals, nil)
+
+	keys := strsToKeys([]string{
+		"foo",
+		"foo/bar",
+		"foo/bar/baz",
+		"foo/barb",
+		"foo/bar/bazb",
+		"foo/bar/baz/barb",
+	})
+
+	for _, k := range keys {
+		err := ktdsTx.Put(ctx, k, []byte(k.String()))
+		c.Check(err, Equals, nil)
+	}
+
+	for _, k := range keys {
+		// underlying mapstore can only see committed results
+		_, err := ms.Get(ctx, k)
+		c.Check(err, Equals, ds.ErrNotFound)
+
+		_, err = ms.Get(ctx, ds.NewKey("abc").Child(k))
+		c.Check(err, Equals, ds.ErrNotFound)
+
+		v1, err := ktdsTx.Get(ctx, k)
+		c.Check(err, Equals, nil)
+		c.Check(bytes.Equal(v1, []byte(k.String())), Equals, true)
+
+		// underlying TxnDatastore can only see committed results
+		_, err = mpds.Get(ctx, ds.NewKey("abc").Child(k))
+		c.Check(err, Equals, ds.ErrNotFound)
+	}
+
+	run := func(d ds.Read, q dsq.Query) []ds.Key {
+		r, err := d.Query(ctx, q)
+		c.Check(err, Equals, nil)
+
+		e, err := r.Rest()
+		c.Check(err, Equals, nil)
+
+		return ds.EntryKeys(e)
+	}
+
+	listA := run(mpds, dsq.Query{})
+	listB := run(ktdsTx, dsq.Query{})
+	if len(listA) == len(listB) {
+		c.Errorf("TxnDatastore and WrappedTxDatastore should not have equal Query results pre-commit")
+	}
+
+	if err := ktds.Check(ctx); err != dstest.ErrTest {
+		c.Errorf("Unexpected Check() error: %s", err)
+	}
+
+	if err := ktds.CollectGarbage(ctx); err != dstest.ErrTest {
+		c.Errorf("Unexpected CollectGarbage() error: %s", err)
+	}
+
+	if err := ktds.Scrub(ctx); err != dstest.ErrTest {
+		c.Errorf("Unexpected Scrub() error: %s", err)
+	}
+
+	// Commit wrapped tx and compare
+	err = ktdsTx.Commit(ctx)
+	c.Check(err, Equals, nil)
+
+	for _, k := range keys {
+		// results should be committed to the underlying mapstore
+		_, err = ms.Get(ctx, k)
+		c.Check(err, Equals, ds.ErrNotFound)
+
+		v0, err := ms.Get(ctx, ds.NewKey("abc").Child(k))
+		c.Check(err, Equals, nil)
+		c.Check(bytes.Equal(v0, []byte(k.String())), Equals, true)
+
+		v1, err := ktdsTx.Get(ctx, k)
+		c.Check(err, Equals, nil)
+		c.Check(bytes.Equal(v1, []byte(k.String())), Equals, true)
+
+		// results should be committed to the wrapped TxnDatastore
+		v2, err := mpds.Get(ctx, ds.NewKey("abc").Child(k))
+		c.Check(err, Equals, nil)
+		c.Check(bytes.Equal(v2, []byte(k.String())), Equals, true)
+	}
+
+	listA = run(mpds, dsq.Query{})
+	listB = run(ktdsTx, dsq.Query{})
+	listC := run(ms, dsq.Query{})
+	c.Check(len(listA), Equals, len(listB))
+	c.Check(len(listA), Equals, len(listC))
+
+	// sort them cause yeah.
+	sort.Sort(ds.KeySlice(listA))
+	sort.Sort(ds.KeySlice(listB))
+	sort.Sort(ds.KeySlice(listC))
+
+	for i, kA := range listA {
+		kB := listB[i]
+		kC := listC[i]
+		c.Check(pair.Invert(kA), Equals, kB)
+		c.Check(kA, Equals, pair.Convert(kB))
+		c.Check(kC, Equals, kA)
+	}
+
+	c.Log("listA: ", listA)
+	c.Log("listB: ", listB)
+	c.Log("listC: ", listC)
+
+	// Create a new tx and add some uncommitted values to
+	ktdsTx, err = ktds.NewTransaction(ctx, false)
+	c.Check(err, Equals, nil)
+
+	unCommittedKeys := strsToKeys([]string{
+		"foo",
+		"foo/bar",
+		"foo/bar/baz",
+	})
+	unCommittedKeysMap := make(map[ds.Key][]byte)
+	for i, k := range unCommittedKeys {
+		unCommittedKeysMap[k] = []byte(fmt.Sprintf("overwrite value %d", i))
+	}
+	for k, val := range unCommittedKeysMap {
+		err := ktdsTx.Put(ctx, k, val)
+		c.Check(err, Equals, nil)
+	}
+
+	for _, k := range keys {
+		// underlying mapstore will have only the committed results
+		_, err = ms.Get(ctx, k)
+		c.Check(err, Equals, ds.ErrNotFound)
+
+		v0, err := ms.Get(ctx, ds.NewKey("abc").Child(k))
+		c.Check(err, Equals, nil)
+		c.Check(bytes.Equal(v0, []byte(k.String())), Equals, true)
+
+		// tx will return a mixture of the pending results and committed results
+		v1, err := ktdsTx.Get(ctx, k)
+		c.Check(err, Equals, nil)
+		if val, ok := unCommittedKeysMap[k]; ok {
+			c.Check(bytes.Equal(v1, val), Equals, true)
+		} else {
+			c.Check(bytes.Equal(v1, []byte(k.String())), Equals, true)
+		}
+
+		// underlying TxnDatastore will have only the committed results
+		v2, err := mpds.Get(ctx, ds.NewKey("abc").Child(k))
+		c.Check(err, Equals, nil)
+		c.Check(bytes.Equal(v2, []byte(k.String())), Equals, true)
+	}
+}

test/test_util.go

@@ -197,34 +197,52 @@ type testTxnDatastore struct {
 	*dstore.MapDatastore
 }
 
-func NewTestTxnDatastore(testErrors bool) *testTxnDatastore {
+func NewTestTxnDatastore(ms *dstore.MapDatastore, testErrors bool) *testTxnDatastore {
+	if ms == nil {
+		ms = dstore.NewMapDatastore()
+	}
 	return &testTxnDatastore{
 		testErrors:   testErrors,
-		MapDatastore: dstore.NewMapDatastore(),
+		MapDatastore: ms,
 	}
 }
 
-func (t *testTxnDatastore) NewTransaction(ctx context.Context, readOnly bool) (dstore.Txn, error) {
+func (t *testTxnDatastore) Check(_ context.Context) error {
 	if t.testErrors {
-		return nil, ErrTest
+		return ErrTest
 	}
+	return nil
+}
+
+func (t *testTxnDatastore) Scrub(_ context.Context) error {
+	if t.testErrors {
+		return ErrTest
+	}
+	return nil
+}
+
+func (t *testTxnDatastore) CollectGarbage(_ context.Context) error {
+	if t.testErrors {
+		return ErrTest
+	}
+	return nil
+}
+
+func (t *testTxnDatastore) NewTransaction(ctx context.Context, readOnly bool) (dstore.Txn, error) {
 	return newTestTx(t.testErrors, t.MapDatastore), nil
 }
 
 var _ dstore.Txn = (*testTxn)(nil)
 
 type testTxn struct {
-	testTxErrors bool
-
 	dirty     map[dstore.Key][]byte
 	committed *dstore.MapDatastore
 }
 
 func newTestTx(testTxErrors bool, committed *dstore.MapDatastore) *testTxn {
 	return &testTxn{
-		testTxErrors: testTxErrors,
-		dirty:        make(map[dstore.Key][]byte),
-		committed:    committed,
+		dirty:     make(map[dstore.Key][]byte),
+		committed: committed,
 	}
 }
 
@@ -237,19 +255,13 @@ func newTestTx(testTxErrors bool, committed *dstore.MapDatastore) *testTxn {
 // whereas Query considers both the dirty transaction and the underlying committed datastore.
 
 func (t *testTxn) Get(ctx context.Context, key dstore.Key) ([]byte, error) {
-	if t.testTxErrors {
-		return nil, ErrTest
-	}
 	if val, ok := t.dirty[key]; ok {
 		return val, nil
 	}
 	return t.committed.Get(ctx, key)
 }
 
 func (t *testTxn) Has(ctx context.Context, key dstore.Key) (bool, error) {
-	if t.testTxErrors {
-		return false, ErrTest
-	}
 	if _, ok := t.dirty[key]; ok {
 		return true, nil
 	}
@@ -258,9 +270,6 @@ func (t *testTxn) Has(ctx context.Context, key dstore.Key) (bool, error) {
 }
 
 func (t *testTxn) GetSize(ctx context.Context, key dstore.Key) (int, error) {
-	if t.testTxErrors {
-		return 0, ErrTest
-	}
 	if val, ok := t.dirty[key]; ok {
 		return len(val), nil
 	}
@@ -269,10 +278,6 @@ func (t *testTxn) GetSize(ctx context.Context, key dstore.Key) (int, error) {
 }
 
 func (t *testTxn) Query(ctx context.Context, q dsq.Query) (dsq.Results, error) {
-	if t.testTxErrors {
-		return nil, ErrTest
-	}
-
 	// not entirely sure if Query is *supposed* to access both uncommitted and committed data, but if so I think this
 	// is the simplest way of handling it and the overhead should be fine for testing purposes
 	transientStore := dstore.NewMapDatastore()
@@ -320,28 +325,18 @@ func (t *testTxn) Query(ctx context.Context, q dsq.Query) (dsq.Results, error) {
 }
 
 func (t *testTxn) Put(ctx context.Context, key dstore.Key, value []byte) error {
-	if t.testTxErrors {
-		return ErrTest
-	}
 	t.dirty[key] = value
 	return nil
 }
 
 func (t *testTxn) Delete(ctx context.Context, key dstore.Key) error {
-	if t.testTxErrors {
-		return ErrTest
-	}
 	if _, ok := t.dirty[key]; ok {
 		delete(t.dirty, key)
 	}
 	return t.committed.Delete(ctx, key)
 }
 
 func (t *testTxn) Commit(ctx context.Context) error {
-	if t.testTxErrors {
-		return ErrTest
-	}
-
 	batch, err := t.committed.Batch(ctx)
 	if err != nil {
 		return err