aboutsummaryrefslogtreecommitdiff
path: root/transaction_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'transaction_test.go')
-rw-r--r--transaction_test.go336
1 files changed, 298 insertions, 38 deletions
diff --git a/transaction_test.go b/transaction_test.go
index 4a7170c..880b299 100644
--- a/transaction_test.go
+++ b/transaction_test.go
@@ -1,9 +1,11 @@
package bolt
import (
+ "bytes"
"fmt"
"os"
"sort"
+ "strings"
"testing"
"testing/quick"
@@ -53,24 +55,11 @@ func TestTransactionCursorEmptyBucket(t *testing.T) {
withOpenDB(func(db *DB, path string) {
db.CreateBucket("widgets")
txn, _ := db.Transaction()
- c, err := txn.Cursor("widgets")
- assert.NoError(t, err)
+ c := txn.Bucket("widgets").Cursor()
k, v := c.First()
assert.Nil(t, k)
assert.Nil(t, v)
- txn.Close()
- })
-}
-
-// Ensure that a Transaction returns a nil when a bucket doesn't exist.
-func TestTransactionCursorMissingBucket(t *testing.T) {
- withOpenDB(func(db *DB, path string) {
- db.CreateBucket("widgets")
- txn, _ := db.Transaction()
- c, err := txn.Cursor("woojits")
- assert.Nil(t, c)
- assert.Equal(t, err, ErrBucketNotFound)
- txn.Close()
+ txn.Rollback()
})
}
@@ -82,8 +71,7 @@ func TestTransactionCursorLeafRoot(t *testing.T) {
db.Put("widgets", []byte("foo"), []byte{0})
db.Put("widgets", []byte("bar"), []byte{1})
txn, _ := db.Transaction()
- c, err := txn.Cursor("widgets")
- assert.NoError(t, err)
+ c := txn.Bucket("widgets").Cursor()
k, v := c.First()
assert.Equal(t, string(k), "bar")
@@ -105,7 +93,7 @@ func TestTransactionCursorLeafRoot(t *testing.T) {
assert.Nil(t, k)
assert.Nil(t, v)
- txn.Close()
+ txn.Rollback()
})
}
@@ -117,8 +105,7 @@ func TestTransactionCursorLeafRootReverse(t *testing.T) {
db.Put("widgets", []byte("foo"), []byte{0})
db.Put("widgets", []byte("bar"), []byte{1})
txn, _ := db.Transaction()
- c, err := txn.Cursor("widgets")
- assert.NoError(t, err)
+ c := txn.Bucket("widgets").Cursor()
k, v := c.Last()
assert.Equal(t, string(k), "foo")
@@ -140,7 +127,7 @@ func TestTransactionCursorLeafRootReverse(t *testing.T) {
assert.Nil(t, k)
assert.Nil(t, v)
- txn.Close()
+ txn.Rollback()
})
}
@@ -152,8 +139,7 @@ func TestTransactionCursorRestart(t *testing.T) {
db.Put("widgets", []byte("foo"), []byte{})
txn, _ := db.Transaction()
- c, err := txn.Cursor("widgets")
- assert.NoError(t, err)
+ c := txn.Bucket("widgets").Cursor()
k, _ := c.First()
assert.Equal(t, string(k), "bar")
@@ -167,7 +153,7 @@ func TestTransactionCursorRestart(t *testing.T) {
k, _ = c.Next()
assert.Equal(t, string(k), "foo")
- txn.Close()
+ txn.Rollback()
})
}
@@ -177,27 +163,27 @@ func TestTransactionCursorIterate(t *testing.T) {
withOpenDB(func(db *DB, path string) {
// Bulk insert all values.
db.CreateBucket("widgets")
- rwtxn, _ := db.RWTransaction()
+ txn, _ := db.RWTransaction()
+ b := txn.Bucket("widgets")
for _, item := range items {
- assert.NoError(t, rwtxn.Put("widgets", item.Key, item.Value))
+ assert.NoError(t, b.Put(item.Key, item.Value))
}
- assert.NoError(t, rwtxn.Commit())
+ assert.NoError(t, txn.Commit())
// Sort test data.
sort.Sort(items)
// Iterate over all items and check consistency.
var index = 0
- txn, _ := db.Transaction()
- c, err := txn.Cursor("widgets")
- assert.NoError(t, err)
+ txn, _ = db.Transaction()
+ c := txn.Bucket("widgets").Cursor()
for k, v := c.First(); k != nil && index < len(items); k, v = c.Next() {
assert.Equal(t, k, items[index].Key)
assert.Equal(t, v, items[index].Value)
index++
}
assert.Equal(t, len(items), index)
- txn.Close()
+ txn.Rollback()
})
fmt.Fprint(os.Stderr, ".")
return true
@@ -214,27 +200,301 @@ func TestTransactionCursorIterateReverse(t *testing.T) {
withOpenDB(func(db *DB, path string) {
// Bulk insert all values.
db.CreateBucket("widgets")
- rwtxn, _ := db.RWTransaction()
+ txn, _ := db.RWTransaction()
+ b := txn.Bucket("widgets")
for _, item := range items {
- assert.NoError(t, rwtxn.Put("widgets", item.Key, item.Value))
+ assert.NoError(t, b.Put(item.Key, item.Value))
}
- assert.NoError(t, rwtxn.Commit())
+ assert.NoError(t, txn.Commit())
// Sort test data.
sort.Sort(revtestdata(items))
// Iterate over all items and check consistency.
var index = 0
- txn, _ := db.Transaction()
- c, err := txn.Cursor("widgets")
- assert.NoError(t, err)
+ txn, _ = db.Transaction()
+ c := txn.Bucket("widgets").Cursor()
for k, v := c.Last(); k != nil && index < len(items); k, v = c.Prev() {
assert.Equal(t, k, items[index].Key)
assert.Equal(t, v, items[index].Value)
index++
}
assert.Equal(t, len(items), index)
- txn.Close()
+ txn.Rollback()
+ })
+ fmt.Fprint(os.Stderr, ".")
+ return true
+ }
+ if err := quick.Check(f, qconfig()); err != nil {
+ t.Error(err)
+ }
+ fmt.Fprint(os.Stderr, "\n")
+}
+
+// Ensure that a bucket can be created and retrieved.
+func TestTransactionCreateBucket(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ // Create a bucket.
+ err := db.CreateBucket("widgets")
+ assert.NoError(t, err)
+
+ // Read the bucket through a separate transaction.
+ b, err := db.Bucket("widgets")
+ assert.NotNil(t, b)
+ assert.NoError(t, err)
+ })
+}
+
+// Ensure that a bucket can be created if it doesn't already exist.
+func TestTransactionCreateBucketIfNotExists(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ assert.NoError(t, db.CreateBucketIfNotExists("widgets"))
+ assert.NoError(t, db.CreateBucketIfNotExists("widgets"))
+
+ // Read the bucket through a separate transaction.
+ b, err := db.Bucket("widgets")
+ assert.NotNil(t, b)
+ assert.NoError(t, err)
+ })
+}
+
+// Ensure that a bucket cannot be created twice.
+func TestTransactionRecreateBucket(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ // Create a bucket.
+ err := db.CreateBucket("widgets")
+ assert.NoError(t, err)
+
+ // Create the same bucket again.
+ err = db.CreateBucket("widgets")
+ assert.Equal(t, err, ErrBucketExists)
+ })
+}
+
+// Ensure that a bucket is created with a non-blank name.
+func TestTransactionCreateBucketWithoutName(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ err := db.CreateBucket("")
+ assert.Equal(t, err, ErrBucketNameRequired)
+ })
+}
+
+// Ensure that a bucket name is not too long.
+func TestTransactionCreateBucketWithLongName(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ err := db.CreateBucket(strings.Repeat("X", 255))
+ assert.NoError(t, err)
+
+ err = db.CreateBucket(strings.Repeat("X", 256))
+ assert.Equal(t, err, ErrBucketNameTooLarge)
+ })
+}
+
+// Ensure that a bucket can be deleted.
+func TestTransactionDeleteBucket(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ // Create a bucket and add a value.
+ db.CreateBucket("widgets")
+ db.Put("widgets", []byte("foo"), []byte("bar"))
+
+ // Delete the bucket and make sure we can't get the value.
+ assert.NoError(t, db.DeleteBucket("widgets"))
+ value, err := db.Get("widgets", []byte("foo"))
+ assert.Equal(t, err, ErrBucketNotFound)
+ assert.Nil(t, value)
+
+ // Create the bucket again and make sure there's not a phantom value.
+ assert.NoError(t, db.CreateBucket("widgets"))
+ value, err = db.Get("widgets", []byte("foo"))
+ assert.NoError(t, err)
+ assert.Nil(t, value)
+ })
+}
+
+// Ensure that a bucket can return an autoincrementing sequence.
+func TestTransactionNextSequence(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ db.CreateBucket("widgets")
+ db.CreateBucket("woojits")
+
+ // Make sure sequence increments.
+ seq, err := db.NextSequence("widgets")
+ assert.NoError(t, err)
+ assert.Equal(t, seq, 1)
+ seq, err = db.NextSequence("widgets")
+ assert.NoError(t, err)
+ assert.Equal(t, seq, 2)
+
+ // Buckets should be separate.
+ seq, err = db.NextSequence("woojits")
+ assert.NoError(t, err)
+ assert.Equal(t, seq, 1)
+
+ // Missing buckets return an error.
+ seq, err = db.NextSequence("no_such_bucket")
+ assert.Equal(t, err, ErrBucketNotFound)
+ assert.Equal(t, seq, 0)
+ })
+}
+
+// Ensure that incrementing past the maximum sequence number will return an error.
+func TestTransactionNextSequenceOverflow(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ db.CreateBucket("widgets")
+ db.Do(func(txn *Transaction) error {
+ b := txn.Bucket("widgets")
+ b.bucket.sequence = uint64(maxInt)
+ seq, err := b.NextSequence()
+ assert.Equal(t, err, ErrSequenceOverflow)
+ assert.Equal(t, seq, 0)
+ return nil
+ })
+ })
+}
+
+// Ensure that an error is returned when inserting into a bucket that doesn't exist.
+func TestTransactionPutBucketNotFound(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ err := db.Put("widgets", []byte("foo"), []byte("bar"))
+ assert.Equal(t, err, ErrBucketNotFound)
+ })
+}
+
+// Ensure that an error is returned when inserting with an empty key.
+func TestTransactionPutEmptyKey(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ db.CreateBucket("widgets")
+ err := db.Put("widgets", []byte(""), []byte("bar"))
+ assert.Equal(t, err, ErrKeyRequired)
+ err = db.Put("widgets", nil, []byte("bar"))
+ assert.Equal(t, err, ErrKeyRequired)
+ })
+}
+
+// Ensure that an error is returned when inserting with a key that's too large.
+func TestTransactionPutKeyTooLarge(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ db.CreateBucket("widgets")
+ err := db.Put("widgets", make([]byte, 32769), []byte("bar"))
+ assert.Equal(t, err, ErrKeyTooLarge)
+ })
+}
+
+// Ensure that an error is returned when deleting from a bucket that doesn't exist.
+func TestTransactionDeleteBucketNotFound(t *testing.T) {
+ withOpenDB(func(db *DB, path string) {
+ err := db.DeleteBucket("widgets")
+ assert.Equal(t, err, ErrBucketNotFound)
+ })
+}
+
+// Ensure that a bucket can write random keys and values across multiple txns.
+func TestTransactionPutSingle(t *testing.T) {
+ index := 0
+ f := func(items testdata) bool {
+ withOpenDB(func(db *DB, path string) {
+ m := make(map[string][]byte)
+
+ db.CreateBucket("widgets")
+ for _, item := range items {
+ if err := db.Put("widgets", item.Key, item.Value); err != nil {
+ panic("put error: " + err.Error())
+ }
+ m[string(item.Key)] = item.Value
+
+ // Verify all key/values so far.
+ i := 0
+ for k, v := range m {
+ value, err := db.Get("widgets", []byte(k))
+ if err != nil {
+ panic("get error: " + err.Error())
+ }
+ if !bytes.Equal(value, v) {
+ db.CopyFile("/tmp/bolt.put.single.db", 0666)
+ t.Fatalf("value mismatch [run %d] (%d of %d):\nkey: %x\ngot: %x\nexp: %x", index, i, len(m), []byte(k), value, v)
+ }
+ i++
+ }
+ }
+
+ fmt.Fprint(os.Stderr, ".")
+ })
+ index++
+ return true
+ }
+ if err := quick.Check(f, qconfig()); err != nil {
+ t.Error(err)
+ }
+ fmt.Fprint(os.Stderr, "\n")
+}
+
+// Ensure that a transaction can insert multiple key/value pairs at once.
+func TestTransactionPutMultiple(t *testing.T) {
+ f := func(items testdata) bool {
+ withOpenDB(func(db *DB, path string) {
+ // Bulk insert all values.
+ db.CreateBucket("widgets")
+ txn, _ := db.RWTransaction()
+ b := txn.Bucket("widgets")
+ for _, item := range items {
+ assert.NoError(t, b.Put(item.Key, item.Value))
+ }
+ assert.NoError(t, txn.Commit())
+
+ // Verify all items exist.
+ txn, _ = db.Transaction()
+ for _, item := range items {
+ value := txn.Bucket("widgets").Get(item.Key)
+ if !assert.Equal(t, item.Value, value) {
+ db.CopyFile("/tmp/bolt.put.multiple.db", 0666)
+ t.FailNow()
+ }
+ }
+ txn.Rollback()
+ })
+ fmt.Fprint(os.Stderr, ".")
+ return true
+ }
+ if err := quick.Check(f, qconfig()); err != nil {
+ t.Error(err)
+ }
+ fmt.Fprint(os.Stderr, "\n")
+}
+
+// Ensure that a transaction can delete all key/value pairs and return to a single leaf page.
+func TestTransactionDelete(t *testing.T) {
+ f := func(items testdata) bool {
+ withOpenDB(func(db *DB, path string) {
+ // Bulk insert all values.
+ db.CreateBucket("widgets")
+ txn, _ := db.RWTransaction()
+ b := txn.Bucket("widgets")
+ for _, item := range items {
+ assert.NoError(t, b.Put(item.Key, item.Value))
+ }
+ assert.NoError(t, txn.Commit())
+
+ // Remove items one at a time and check consistency.
+ for i, item := range items {
+ assert.NoError(t, db.Delete("widgets", item.Key))
+
+ // Anything before our deletion index should be nil.
+ txn, _ := db.Transaction()
+ for j, exp := range items {
+ if j > i {
+ value := txn.Bucket("widgets").Get(exp.Key)
+ if !assert.Equal(t, exp.Value, value) {
+ t.FailNow()
+ }
+ } else {
+ value := txn.Bucket("widgets").Get(exp.Key)
+ if !assert.Nil(t, value) {
+ t.FailNow()
+ }
+ }
+ }
+ txn.Rollback()
+ }
})
fmt.Fprint(os.Stderr, ".")
return true