diff --git a/bucket_test.go b/bucket_test.go
index c6e8481..c4867fa 100644
--- a/bucket_test.go
+++ b/bucket_test.go
@@ -3,7 +3,7 @@ package storm
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestBucket(t *testing.T) {
@@ -16,13 +16,13 @@ func TestBucket(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	assert.Nil(t, db.root.GetBucket(readTx, "none"))
+	require.Nil(t, db.root.GetBucket(readTx, "none"))
 
 	b, err := db.root.CreateBucketIfNotExists(readTx, "new")
 
 	// Cannot create buckets in a read transaction
-	assert.Error(t, err)
-	assert.Nil(t, b)
+	require.Error(t, err)
+	require.Nil(t, b)
 
 	// Read transactions in Bolt needs a rollback and not a commit
 	readTx.Rollback()
@@ -36,18 +36,18 @@ func TestBucket(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	assert.Nil(t, db.root.GetBucket(writeTx, "none"))
+	require.Nil(t, db.root.GetBucket(writeTx, "none"))
 
 	b, err = db.root.CreateBucketIfNotExists(writeTx, "new")
 
-	assert.NoError(t, err)
-	assert.NotNil(t, b)
+	require.NoError(t, err)
+	require.NotNil(t, b)
 
 	n2 := db.From("a", "b")
 	b, err = n2.CreateBucketIfNotExists(writeTx, "c")
 
-	assert.NoError(t, err)
-	assert.NotNil(t, b)
+	require.NoError(t, err)
+	require.NotNil(t, b)
 
 	writeTx.Commit()
 
@@ -59,9 +59,9 @@ func TestBucket(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	assert.NotNil(t, db.root.GetBucket(readTx, "new"))
-	assert.Nil(t, db.root.GetBucket(readTx, "c"))
-	assert.NotNil(t, n2.GetBucket(readTx, "c"))
+	require.NotNil(t, db.root.GetBucket(readTx, "new"))
+	require.Nil(t, db.root.GetBucket(readTx, "c"))
+	require.NotNil(t, n2.GetBucket(readTx, "c"))
 
 	readTx.Rollback()
 	// End read tx
diff --git a/codec/protobuf/protobuf_test.go b/codec/protobuf/protobuf_test.go
index 35a26df..71b9a86 100644
--- a/codec/protobuf/protobuf_test.go
+++ b/codec/protobuf/protobuf_test.go
@@ -8,14 +8,14 @@ import (
 
 	"github.com/asdine/storm"
 	"github.com/asdine/storm/codec/internal"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestProtobuf(t *testing.T) {
 	u1 := SimpleUser{Id: 1, Name: "John"}
 	u2 := SimpleUser{}
 	internal.RoundtripTester(t, Codec, &u1, &u2)
-	assert.True(t, u1.Id == u2.Id)
+	require.True(t, u1.Id == u2.Id)
 }
 
 func TestSave(t *testing.T) {
@@ -24,11 +24,11 @@ func TestSave(t *testing.T) {
 	db, _ := storm.Open(filepath.Join(dir, "storm.db"), storm.Codec(Codec))
 	u1 := SimpleUser{Id: 1, Name: "John"}
 	err := db.Save(&u1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	u2 := SimpleUser{}
 	err = db.One("Id", uint64(1), &u2)
-	assert.NoError(t, err)
-	assert.Equal(t, u2.Name, u1.Name)
+	require.NoError(t, err)
+	require.Equal(t, u2.Name, u1.Name)
 }
 
 func TestGetSet(t *testing.T) {
@@ -36,9 +36,9 @@ func TestGetSet(t *testing.T) {
 	defer os.RemoveAll(dir)
 	db, _ := storm.Open(filepath.Join(dir, "storm.db"), storm.Codec(Codec))
 	err := db.Set("bucket", "key", "value")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	var s string
 	err = db.Get("bucket", "key", &s)
-	assert.NoError(t, err)
-	assert.Equal(t, "value", s)
+	require.NoError(t, err)
+	require.Equal(t, "value", s)
 }
diff --git a/codec/sereal/sereal_test.go b/codec/sereal/sereal_test.go
index c0e59e7..a9c57c2 100644
--- a/codec/sereal/sereal_test.go
+++ b/codec/sereal/sereal_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	"github.com/asdine/storm/codec/internal"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type SerealUser struct {
@@ -17,5 +17,5 @@ func TestSereal(t *testing.T) {
 	u1.Self = u1 // cyclic ref
 	u2 := &SerealUser{}
 	internal.RoundtripTester(t, Codec, &u1, &u2)
-	assert.True(t, u2 == u2.Self)
+	require.True(t, u2 == u2.Self)
 }
diff --git a/extract_test.go b/extract_test.go
index 658a1af..ed8b119 100644
--- a/extract_test.go
+++ b/extract_test.go
@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func allByType(m *structConfig, indexType string) []*fieldConfig {
@@ -22,55 +22,55 @@ func TestExtractNoTags(t *testing.T) {
 	s := ClassicNoTags{}
 	r := reflect.ValueOf(&s)
 	_, err := extract(&r)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNoID, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNoID, err)
 }
 
 func TestExtractBadTags(t *testing.T) {
 	s := ClassicBadTags{}
 	r := reflect.ValueOf(&s)
 	infos, err := extract(&r)
-	assert.Error(t, err)
-	assert.Equal(t, ErrUnknownTag, err)
-	assert.Nil(t, infos)
+	require.Error(t, err)
+	require.Equal(t, ErrUnknownTag, err)
+	require.Nil(t, infos)
 }
 
 func TestExtractUniqueTags(t *testing.T) {
 	s := ClassicUnique{ID: "id"}
 	r := reflect.ValueOf(&s)
 	infos, err := extract(&r)
-	assert.NoError(t, err)
-	assert.NotNil(t, infos)
-	assert.NotNil(t, infos.ID)
-	assert.False(t, infos.ID.IsZero)
-	assert.Equal(t, "ClassicUnique", infos.Name)
-	assert.Len(t, allByType(infos, "index"), 0)
-	assert.Len(t, allByType(infos, "unique"), 4)
+	require.NoError(t, err)
+	require.NotNil(t, infos)
+	require.NotNil(t, infos.ID)
+	require.False(t, infos.ID.IsZero)
+	require.Equal(t, "ClassicUnique", infos.Name)
+	require.Len(t, allByType(infos, "index"), 0)
+	require.Len(t, allByType(infos, "unique"), 4)
 }
 
 func TestExtractIndexTags(t *testing.T) {
 	s := ClassicIndex{ID: "id"}
 	r := reflect.ValueOf(&s)
 	infos, err := extract(&r)
-	assert.NoError(t, err)
-	assert.NotNil(t, infos)
-	assert.NotNil(t, infos.ID)
-	assert.False(t, infos.ID.IsZero)
-	assert.Equal(t, "ClassicIndex", infos.Name)
-	assert.Len(t, allByType(infos, "index"), 5)
-	assert.Len(t, allByType(infos, "unique"), 0)
+	require.NoError(t, err)
+	require.NotNil(t, infos)
+	require.NotNil(t, infos.ID)
+	require.False(t, infos.ID.IsZero)
+	require.Equal(t, "ClassicIndex", infos.Name)
+	require.Len(t, allByType(infos, "index"), 5)
+	require.Len(t, allByType(infos, "unique"), 0)
 }
 
 func TestExtractInlineWithIndex(t *testing.T) {
 	s := ClassicInline{ToEmbed: &ToEmbed{ID: "50"}}
 	r := reflect.ValueOf(&s)
 	infos, err := extract(&r)
-	assert.NoError(t, err)
-	assert.NotNil(t, infos)
-	assert.NotNil(t, infos.ID)
-	assert.Equal(t, "ClassicInline", infos.Name)
-	assert.Len(t, allByType(infos, "index"), 3)
-	assert.Len(t, allByType(infos, "unique"), 2)
+	require.NoError(t, err)
+	require.NotNil(t, infos)
+	require.NotNil(t, infos.ID)
+	require.Equal(t, "ClassicInline", infos.Name)
+	require.Len(t, allByType(infos, "index"), 3)
+	require.Len(t, allByType(infos, "unique"), 2)
 }
 
 func TestExtractMultipleTags(t *testing.T) {
@@ -85,36 +85,36 @@ func TestExtractMultipleTags(t *testing.T) {
 	s := User{}
 	r := reflect.ValueOf(&s)
 	infos, err := extract(&r)
-	assert.NoError(t, err)
-	assert.NotNil(t, infos)
-	assert.NotNil(t, infos.ID)
-	assert.Equal(t, "User", infos.Name)
-	assert.Len(t, allByType(infos, "index"), 2)
-	assert.Len(t, allByType(infos, "unique"), 1)
+	require.NoError(t, err)
+	require.NotNil(t, infos)
+	require.NotNil(t, infos.ID)
+	require.Equal(t, "User", infos.Name)
+	require.Len(t, allByType(infos, "index"), 2)
+	require.Len(t, allByType(infos, "unique"), 1)
 
-	assert.True(t, infos.Fields["Age"].Increment)
-	assert.Equal(t, int64(1), infos.Fields["Age"].IncrementStart)
-	assert.Equal(t, "index", infos.Fields["Age"].Index)
-	assert.False(t, infos.Fields["Age"].IsID)
-	assert.True(t, infos.Fields["Age"].IsInteger)
-	assert.True(t, infos.Fields["Age"].IsZero)
-	assert.NotNil(t, infos.Fields["Age"].Value)
+	require.True(t, infos.Fields["Age"].Increment)
+	require.Equal(t, int64(1), infos.Fields["Age"].IncrementStart)
+	require.Equal(t, "index", infos.Fields["Age"].Index)
+	require.False(t, infos.Fields["Age"].IsID)
+	require.True(t, infos.Fields["Age"].IsInteger)
+	require.True(t, infos.Fields["Age"].IsZero)
+	require.NotNil(t, infos.Fields["Age"].Value)
 
-	assert.True(t, infos.Fields["X"].Increment)
-	assert.Equal(t, int64(100), infos.Fields["X"].IncrementStart)
-	assert.Equal(t, "unique", infos.Fields["X"].Index)
-	assert.False(t, infos.Fields["X"].IsID)
-	assert.True(t, infos.Fields["X"].IsInteger)
-	assert.True(t, infos.Fields["X"].IsZero)
-	assert.NotNil(t, infos.Fields["X"].Value)
+	require.True(t, infos.Fields["X"].Increment)
+	require.Equal(t, int64(100), infos.Fields["X"].IncrementStart)
+	require.Equal(t, "unique", infos.Fields["X"].Index)
+	require.False(t, infos.Fields["X"].IsID)
+	require.True(t, infos.Fields["X"].IsInteger)
+	require.True(t, infos.Fields["X"].IsZero)
+	require.NotNil(t, infos.Fields["X"].Value)
 
-	assert.True(t, infos.Fields["Y"].Increment)
-	assert.Equal(t, int64(-100), infos.Fields["Y"].IncrementStart)
-	assert.Equal(t, "index", infos.Fields["Y"].Index)
-	assert.False(t, infos.Fields["Y"].IsID)
-	assert.True(t, infos.Fields["Y"].IsInteger)
-	assert.True(t, infos.Fields["Y"].IsZero)
-	assert.NotNil(t, infos.Fields["Y"].Value)
+	require.True(t, infos.Fields["Y"].Increment)
+	require.Equal(t, int64(-100), infos.Fields["Y"].IncrementStart)
+	require.Equal(t, "index", infos.Fields["Y"].Index)
+	require.False(t, infos.Fields["Y"].IsID)
+	require.True(t, infos.Fields["Y"].IsInteger)
+	require.True(t, infos.Fields["Y"].IsZero)
+	require.NotNil(t, infos.Fields["Y"].Value)
 
 	type NoInt struct {
 		ID uint64 `storm:"id,increment=hello"`
@@ -123,7 +123,7 @@ func TestExtractMultipleTags(t *testing.T) {
 	var n NoInt
 	r = reflect.ValueOf(&n)
 	_, err = extract(&r)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	type BadSuffix struct {
 		ID uint64 `storm:"id,incrementag=100"`
@@ -132,5 +132,5 @@ func TestExtractMultipleTags(t *testing.T) {
 	var b BadSuffix
 	r = reflect.ValueOf(&b)
 	_, err = extract(&r)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
diff --git a/finder_test.go b/finder_test.go
index a3db118..cfc0d65 100644
--- a/finder_test.go
+++ b/finder_test.go
@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -27,87 +26,87 @@ func TestFind(t *testing.T) {
 		}
 
 		err := db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	err := db.Find("Name", "John", &User{})
-	assert.Error(t, err)
-	assert.Equal(t, ErrSlicePtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrSlicePtrNeeded, err)
 
 	err = db.Find("Name", "John", &[]struct {
 		Name string
 		ID   int
 	}{})
-	assert.Error(t, err)
-	assert.Equal(t, ErrNoName, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNoName, err)
 
 	notTheRightUsers := []UniqueNameUser{}
 
 	err = db.Find("Name", "John", &notTheRightUsers)
-	assert.Error(t, err)
-	assert.EqualError(t, err, "not found")
+	require.Error(t, err)
+	require.EqualError(t, err, "not found")
 
 	users := []User{}
 
 	err = db.Find("unexportedField", "John", &users)
-	assert.Error(t, err)
-	assert.EqualError(t, err, "field unexportedField not found")
+	require.Error(t, err)
+	require.EqualError(t, err, "field unexportedField not found")
 
 	err = db.Find("DateOfBirth", "John", &users)
-	assert.Error(t, err)
-	assert.True(t, ErrNotFound == err)
+	require.Error(t, err)
+	require.True(t, ErrNotFound == err)
 
 	err = db.Find("Group", "staff", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 50)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 99, users[49].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 50)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 99, users[49].ID)
 
 	err = db.Find("Group", "staff", &users, Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 50)
-	assert.Equal(t, 99, users[0].ID)
-	assert.Equal(t, 1, users[49].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 50)
+	require.Equal(t, 99, users[0].ID)
+	require.Equal(t, 1, users[49].ID)
 
 	err = db.Find("Group", "admin", &users)
-	assert.Error(t, err)
-	assert.True(t, ErrNotFound == err)
+	require.Error(t, err)
+	require.True(t, ErrNotFound == err)
 
 	err = db.Find("Name", "John", users)
-	assert.Error(t, err)
-	assert.Equal(t, ErrSlicePtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrSlicePtrNeeded, err)
 
 	err = db.Find("Name", "John", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	err = db.Find("Name", "John", &users, Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 100, users[0].ID)
-	assert.Equal(t, 1, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 100, users[0].ID)
+	require.Equal(t, 1, users[99].ID)
 
 	users = []User{}
 	err = db.Find("Slug", "John10", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 1)
-	assert.Equal(t, 10, users[0].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 1)
+	require.Equal(t, 10, users[0].ID)
 
 	users = []User{}
 	err = db.Find("Name", nil, &users)
-	assert.Error(t, err)
-	assert.True(t, ErrNotFound == err)
+	require.Error(t, err)
+	require.True(t, ErrNotFound == err)
 
 	err = db.Find("Name", "John", &users, Limit(10), Skip(20))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 21, users[0].ID)
-	assert.Equal(t, 30, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 21, users[0].ID)
+	require.Equal(t, 30, users[9].ID)
 
 	err = db.Find("Age", 10, &users)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestFindNil(t *testing.T) {
@@ -131,7 +130,7 @@ func TestFindNil(t *testing.T) {
 		}
 
 		err := db.Save(&u)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	var users []User
@@ -183,113 +182,113 @@ func TestAllByIndex(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		w := User{Name: "John", ID: i + 1, Slug: fmt.Sprintf("John%d", i+1), DateOfBirth: time.Now().Add(-time.Duration(i*10) * time.Minute)}
 		err := db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	err := db.AllByIndex("", nil)
-	assert.Error(t, err)
-	assert.Equal(t, ErrSlicePtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrSlicePtrNeeded, err)
 
 	var users []User
 
 	err = db.AllByIndex("Unknown field", &users)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotFound, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.AllByIndex("DateOfBirth", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 100, users[0].ID)
-	assert.Equal(t, 1, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 100, users[0].ID)
+	require.Equal(t, 1, users[99].ID)
 
 	err = db.AllByIndex("Name", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	y := UniqueNameUser{Name: "Jake", ID: 200}
 	err = db.Save(&y)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var y2 []UniqueNameUser
 	err = db.AllByIndex("ID", &y2)
-	assert.NoError(t, err)
-	assert.Len(t, y2, 1)
+	require.NoError(t, err)
+	require.Len(t, y2, 1)
 
 	n := NestedID{}
 	n.ID = "100"
 	n.Name = "John"
 
 	err = db.Save(&n)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var n2 []NestedID
 	err = db.AllByIndex("ID", &n2)
-	assert.NoError(t, err)
-	assert.Len(t, n2, 1)
+	require.NoError(t, err)
+	require.Len(t, n2, 1)
 
 	err = db.AllByIndex("Name", &users, Limit(10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 10, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 10, users[9].ID)
 
 	err = db.AllByIndex("Name", &users, Limit(200))
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	err = db.AllByIndex("Name", &users, Limit(-10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	err = db.AllByIndex("Name", &users, Skip(200))
-	assert.NoError(t, err)
-	assert.Len(t, users, 0)
+	require.NoError(t, err)
+	require.Len(t, users, 0)
 
 	err = db.AllByIndex("Name", &users, Skip(-10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	err = db.AllByIndex("ID", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	err = db.AllByIndex("ID", &users, Limit(10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 10, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 10, users[9].ID)
 
 	err = db.AllByIndex("ID", &users, Skip(10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 90)
-	assert.Equal(t, 11, users[0].ID)
-	assert.Equal(t, 100, users[89].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 90)
+	require.Equal(t, 11, users[0].ID)
+	require.Equal(t, 100, users[89].ID)
 
 	err = db.AllByIndex("Name", &users, Limit(10), Skip(10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 11, users[0].ID)
-	assert.Equal(t, 20, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 11, users[0].ID)
+	require.Equal(t, 20, users[9].ID)
 
 	err = db.AllByIndex("Name", &users, Limit(10), Skip(10), Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 90, users[0].ID)
-	assert.Equal(t, 81, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 90, users[0].ID)
+	require.Equal(t, 81, users[9].ID)
 
 	err = db.AllByIndex("Age", &users, Limit(10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
 }
 
 func TestAll(t *testing.T) {
@@ -299,63 +298,63 @@ func TestAll(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		w := User{Name: "John", ID: i + 1, Slug: fmt.Sprintf("John%d", i+1), DateOfBirth: time.Now().Add(-time.Duration(i*10) * time.Minute)}
 		err := db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	var users []User
 
 	err := db.All(&users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 1, users[0].ID)
-	assert.Equal(t, 100, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 1, users[0].ID)
+	require.Equal(t, 100, users[99].ID)
 
 	err = db.All(&users, Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 100)
-	assert.Equal(t, 100, users[0].ID)
-	assert.Equal(t, 1, users[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 100)
+	require.Equal(t, 100, users[0].ID)
+	require.Equal(t, 1, users[99].ID)
 
 	var users2 []*User
 
 	err = db.All(&users2)
-	assert.NoError(t, err)
-	assert.Len(t, users2, 100)
-	assert.Equal(t, 1, users2[0].ID)
-	assert.Equal(t, 100, users2[99].ID)
+	require.NoError(t, err)
+	require.Len(t, users2, 100)
+	require.Equal(t, 1, users2[0].ID)
+	require.Equal(t, 100, users2[99].ID)
 
 	err = db.Save(&NestedID{
 		ToEmbed: ToEmbed{ID: "id1"},
 		Name:    "John",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.Save(&NestedID{
 		ToEmbed: ToEmbed{ID: "id2"},
 		Name:    "Mike",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db.Save(&NestedID{
 		ToEmbed: ToEmbed{ID: "id3"},
 		Name:    "Steve",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var nested []NestedID
 	err = db.All(&nested)
-	assert.NoError(t, err)
-	assert.Len(t, nested, 3)
+	require.NoError(t, err)
+	require.Len(t, nested, 3)
 
 	err = db.All(&users, Limit(10), Skip(10))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 11, users[0].ID)
-	assert.Equal(t, 20, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 11, users[0].ID)
+	require.Equal(t, 20, users[9].ID)
 
 	err = db.All(&users, Limit(0), Skip(0))
-	assert.NoError(t, err)
-	assert.Len(t, users, 0)
+	require.NoError(t, err)
+	require.Len(t, users, 0)
 }
 
 func TestCount(t *testing.T) {
@@ -365,38 +364,38 @@ func TestCount(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		w := User{Name: "John", ID: i + 1, Slug: fmt.Sprintf("John%d", i+1), DateOfBirth: time.Now().Add(-time.Duration(i*10) * time.Minute)}
 		err := db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	count, err := db.Count(&User{})
-	assert.NoError(t, err)
-	assert.Equal(t, 100, count)
+	require.NoError(t, err)
+	require.Equal(t, 100, count)
 
 	w := User{Name: "John", ID: 101, Slug: fmt.Sprintf("John%d", 101), DateOfBirth: time.Now().Add(-time.Duration(101*10) * time.Minute)}
 	err = db.Save(&w)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	count, err = db.Count(&User{})
-	assert.NoError(t, err)
-	assert.Equal(t, 101, count)
+	require.NoError(t, err)
+	require.Equal(t, 101, count)
 
 	tx, err := db.Begin(true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = tx.Count(User{})
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	count, err = tx.Count(&User{})
-	assert.NoError(t, err)
-	assert.Equal(t, 101, count)
+	require.NoError(t, err)
+	require.Equal(t, 101, count)
 
 	w = User{Name: "John", ID: 102, Slug: fmt.Sprintf("John%d", 102), DateOfBirth: time.Now().Add(-time.Duration(101*10) * time.Minute)}
 	err = tx.Save(&w)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	count, err = tx.Count(&User{})
-	assert.NoError(t, err)
-	assert.Equal(t, 102, count)
+	require.NoError(t, err)
+	require.Equal(t, 102, count)
 
 	tx.Commit()
 }
@@ -407,11 +406,11 @@ func TestCountEmpty(t *testing.T) {
 
 	user := &User{}
 	err := db.Init(user)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	count, err := db.Count(user)
-	assert.Zero(t, count)
-	assert.NoError(t, err)
+	require.Zero(t, count)
+	require.NoError(t, err)
 }
 
 func TestOne(t *testing.T) {
@@ -420,75 +419,75 @@ func TestOne(t *testing.T) {
 
 	u := UniqueNameUser{Name: "John", ID: 10}
 	err := db.Save(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	v := UniqueNameUser{}
 	err = db.One("Name", "John", &v)
-	assert.NoError(t, err)
-	assert.Equal(t, u, v)
+	require.NoError(t, err)
+	require.Equal(t, u, v)
 
 	for i := 0; i < 10; i++ {
 		w := IndexedNameUser{Name: "John", ID: i + 1, Group: "staff"}
 		err = db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	var x IndexedNameUser
 	err = db.One("Name", "John", &x)
-	assert.NoError(t, err)
-	assert.Equal(t, "John", x.Name)
-	assert.Equal(t, 1, x.ID)
-	assert.Zero(t, x.age)
-	assert.True(t, x.DateOfBirth.IsZero())
+	require.NoError(t, err)
+	require.Equal(t, "John", x.Name)
+	require.Equal(t, 1, x.ID)
+	require.Zero(t, x.age)
+	require.True(t, x.DateOfBirth.IsZero())
 
 	err = db.One("Name", "Mike", &x)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotFound, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.One("", nil, &x)
-	assert.Error(t, err)
-	assert.True(t, ErrNotFound == err)
+	require.Error(t, err)
+	require.True(t, ErrNotFound == err)
 
 	err = db.One("", "Mike", nil)
-	assert.Error(t, err)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	err = db.One("", nil, nil)
-	assert.Error(t, err)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	err = db.One("Group", "staff", &x)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, x.ID)
+	require.NoError(t, err)
+	require.Equal(t, 1, x.ID)
 
 	err = db.One("Score", 5, &x)
-	assert.NoError(t, err)
-	assert.Equal(t, 5, x.ID)
+	require.NoError(t, err)
+	require.Equal(t, 5, x.ID)
 
 	err = db.One("Group", "admin", &x)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotFound, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
 
 	y := UniqueNameUser{Name: "Jake", ID: 200}
 	err = db.Save(&y)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var y2 UniqueNameUser
 	err = db.One("ID", 200, &y2)
-	assert.NoError(t, err)
-	assert.Equal(t, y, y2)
+	require.NoError(t, err)
+	require.Equal(t, y, y2)
 
 	n := NestedID{}
 	n.ID = "100"
 	n.Name = "John"
 
 	err = db.Save(&n)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var n2 NestedID
 	err = db.One("ID", "100", &n2)
-	assert.NoError(t, err)
-	assert.Equal(t, n, n2)
+	require.NoError(t, err)
+	require.Equal(t, n, n2)
 }
 
 func TestOneNotWritable(t *testing.T) {
@@ -497,7 +496,7 @@ func TestOneNotWritable(t *testing.T) {
 	db, _ := Open(filepath.Join(dir, "storm.db"))
 
 	err := db.Save(&User{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db.Close()
 
@@ -507,18 +506,18 @@ func TestOneNotWritable(t *testing.T) {
 	defer db.Close()
 
 	err = db.Save(&User{ID: 20, Name: "John"})
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	var u User
 	err = db.One("ID", 10, &u)
-	assert.NoError(t, err)
-	assert.Equal(t, 10, u.ID)
-	assert.Equal(t, "John", u.Name)
+	require.NoError(t, err)
+	require.Equal(t, 10, u.ID)
+	require.Equal(t, "John", u.Name)
 
 	err = db.One("Name", "John", &u)
-	assert.NoError(t, err)
-	assert.Equal(t, 10, u.ID)
-	assert.Equal(t, "John", u.Name)
+	require.NoError(t, err)
+	require.Equal(t, 10, u.ID)
+	require.Equal(t, "John", u.Name)
 }
 
 func TestRange(t *testing.T) {
@@ -534,10 +533,10 @@ func TestRange(t *testing.T) {
 			Group:       fmt.Sprintf("Group%03d", i%5),
 		}
 		err := db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		z := User{Name: fmt.Sprintf("Zach%03d", i+1), ID: i + 101, Slug: fmt.Sprintf("Zach%03d", i+1)}
 		err = db.Save(&z)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	min := "John010"
@@ -545,76 +544,76 @@ func TestRange(t *testing.T) {
 	var users []User
 
 	err := db.Range("Slug", min, max, users)
-	assert.Equal(t, ErrSlicePtrNeeded, err)
+	require.Equal(t, ErrSlicePtrNeeded, err)
 
 	err = db.Range("Slug", min, max, &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 11)
-	assert.Equal(t, "John010", users[0].Slug)
-	assert.Equal(t, "John020", users[10].Slug)
+	require.NoError(t, err)
+	require.Len(t, users, 11)
+	require.Equal(t, "John010", users[0].Slug)
+	require.Equal(t, "John020", users[10].Slug)
 
 	err = db.Range("Slug", min, max, &users, Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 11)
-	assert.Equal(t, "John020", users[0].Slug)
-	assert.Equal(t, "John010", users[10].Slug)
+	require.NoError(t, err)
+	require.Len(t, users, 11)
+	require.Equal(t, "John020", users[0].Slug)
+	require.Equal(t, "John010", users[10].Slug)
 
 	min = "Zach010"
 	max = "Zach020"
 	users = nil
 	err = db.Range("Name", min, max, &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 11)
-	assert.Equal(t, "Zach010", users[0].Name)
-	assert.Equal(t, "Zach020", users[10].Name)
+	require.NoError(t, err)
+	require.Len(t, users, 11)
+	require.Equal(t, "Zach010", users[0].Name)
+	require.Equal(t, "Zach020", users[10].Name)
 
 	err = db.Range("Name", min, max, &users, Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 11)
-	assert.Equal(t, "Zach020", users[0].Name)
-	assert.Equal(t, "Zach010", users[10].Name)
+	require.NoError(t, err)
+	require.Len(t, users, 11)
+	require.Equal(t, "Zach020", users[0].Name)
+	require.Equal(t, "Zach010", users[10].Name)
 
 	err = db.Range("Name", min, max, &User{})
-	assert.Error(t, err)
-	assert.Equal(t, ErrSlicePtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrSlicePtrNeeded, err)
 
 	notTheRightUsers := []UniqueNameUser{}
 
 	err = db.Range("Name", min, max, &notTheRightUsers)
-	assert.NoError(t, err)
-	assert.Equal(t, 0, len(notTheRightUsers))
+	require.NoError(t, err)
+	require.Equal(t, 0, len(notTheRightUsers))
 
 	users = nil
 
 	err = db.Range("Age", min, max, &users)
-	assert.Error(t, err)
-	assert.EqualError(t, err, "not found")
+	require.Error(t, err)
+	require.EqualError(t, err, "not found")
 
 	err = db.Range("Age", 2, 5, &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 4)
+	require.NoError(t, err)
+	require.Len(t, users, 4)
 
 	dateMin := time.Now().Add(-time.Duration(50) * time.Hour)
 	dateMax := dateMin.Add(time.Duration(3) * time.Hour)
 	err = db.Range("DateOfBirth", dateMin, dateMax, &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 3)
-	assert.Equal(t, "John050", users[0].Slug)
-	assert.Equal(t, "John048", users[2].Slug)
+	require.NoError(t, err)
+	require.Len(t, users, 3)
+	require.Equal(t, "John050", users[0].Slug)
+	require.Equal(t, "John048", users[2].Slug)
 
 	err = db.Range("Slug", "John010", "John040", &users, Limit(10), Skip(20))
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 30, users[0].ID)
-	assert.Equal(t, 39, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 30, users[0].ID)
+	require.Equal(t, 39, users[9].ID)
 
 	err = db.Range("Slug", "John010", "John040", &users, Limit(10), Skip(20), Reverse())
-	assert.NoError(t, err)
-	assert.Len(t, users, 10)
-	assert.Equal(t, 20, users[0].ID)
-	assert.Equal(t, 11, users[9].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 10)
+	require.Equal(t, 20, users[0].ID)
+	require.Equal(t, 11, users[9].ID)
 
 	err = db.Range("Group", "Group002", "Group004", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 60)
+	require.NoError(t, err)
+	require.Len(t, users, 60)
 }
diff --git a/index/list_test.go b/index/list_test.go
index 354db88..515fe2d 100644
--- a/index/list_test.go
+++ b/index/list_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/asdine/storm/codec/gob"
 	"github.com/asdine/storm/index"
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestListIndex(t *testing.T) {
@@ -22,130 +22,130 @@ func TestListIndex(t *testing.T) {
 
 	err := db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewListIndex(b, []byte("lindex1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("goodbye"), []byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add(nil, []byte("id2"))
-		assert.Error(t, err)
-		assert.Equal(t, index.ErrNilParam, err)
+		require.Error(t, err)
+		require.Equal(t, index.ErrNilParam, err)
 
 		err = idx.Add([]byte("hi"), nil)
-		assert.Error(t, err)
-		assert.Equal(t, index.ErrNilParam, err)
+		require.Error(t, err)
+		require.Equal(t, index.ErrNilParam, err)
 
 		ids, err := idx.All([]byte("hello"), nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id1"), ids[0])
+		require.NoError(t, err)
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id1"), ids[0])
 
 		ids, err = idx.All([]byte("goodbye"), nil)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id2"), ids[0])
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id2"), ids[0])
 
 		ids, err = idx.All([]byte("yo"), nil)
-		assert.Nil(t, ids)
+		require.Nil(t, ids)
 
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		ids, err = idx.All([]byte("goodbye"), nil)
-		assert.Len(t, ids, 0)
+		require.Len(t, ids, 0)
 
 		err = idx.RemoveID(nil)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.RemoveID([]byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = idx.RemoveID([]byte("id3"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		ids, err = idx.All([]byte("hello"), nil)
-		assert.NoError(t, err)
-		assert.Nil(t, ids)
+		require.NoError(t, err)
+		require.Nil(t, ids)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hi"), []byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("yo"), []byte("id3"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		ids, err = idx.All([]byte("hello"), nil)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id1"), ids[0])
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id1"), ids[0])
 		ids, err = idx.All([]byte("hi"), nil)
-		assert.Len(t, ids, 0)
+		require.Len(t, ids, 0)
 		ids, err = idx.All([]byte("yo"), nil)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id3"), ids[0])
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id3"), ids[0])
 
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = idx.RemoveID([]byte("id4"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hey"), []byte("id1"))
 		err = idx.Add([]byte("hey"), []byte("id2"))
 		err = idx.Add([]byte("hey"), []byte("id3"))
 		err = idx.Add([]byte("hey"), []byte("id4"))
 		ids, err = idx.All([]byte("hey"), nil)
-		assert.Len(t, ids, 4)
+		require.Len(t, ids, 4)
 
 		opts := index.NewOptions()
 		opts.Limit = 1
 		ids, err = idx.All([]byte("hey"), opts)
-		assert.Len(t, ids, 1)
+		require.Len(t, ids, 1)
 
 		opts = index.NewOptions()
 		opts.Skip = 2
 		ids, err = idx.All([]byte("hey"), opts)
-		assert.Len(t, ids, 2)
+		require.Len(t, ids, 2)
 
 		opts = index.NewOptions()
 		opts.Skip = 2
 		opts.Limit = 3
 		opts.Reverse = true
 		ids, err = idx.All([]byte("hey"), opts)
-		assert.Len(t, ids, 2)
-		assert.Equal(t, []byte("id2"), ids[0])
+		require.Len(t, ids, 2)
+		require.Equal(t, []byte("id2"), ids[0])
 
 		id := idx.Get([]byte("hey"))
-		assert.Equal(t, []byte("id1"), id)
+		require.Equal(t, []byte("id1"), id)
 
 		err = idx.Remove([]byte("hey"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		ids, err = idx.All([]byte("hey"), nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 0)
+		require.NoError(t, err)
+		require.Len(t, ids, 0)
 
 		ids, err = idx.All([]byte("hey"), nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 0)
+		require.NoError(t, err)
+		require.Len(t, ids, 0)
 		return nil
 	})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestListIndexReverse(t *testing.T) {
@@ -156,38 +156,38 @@ func TestListIndexReverse(t *testing.T) {
 
 	err := db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewListIndex(b, []byte("lindex1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		opts := index.NewOptions()
 		ids, err := idx.All([]byte("hello"), opts)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id1"), ids[0])
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id1"), ids[0])
 
 		opts = index.NewOptions()
 		opts.Reverse = true
 		ids, err = idx.All([]byte("hello"), opts)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id1"), ids[0])
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id1"), ids[0])
 
 		err = idx.Add([]byte("hello"), []byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		opts = index.NewOptions()
 		opts.Reverse = true
 		ids, err = idx.All([]byte("hello"), opts)
-		assert.Len(t, ids, 2)
-		assert.Equal(t, []byte("id2"), ids[0])
-		assert.Equal(t, []byte("id1"), ids[1])
+		require.Len(t, ids, 2)
+		require.Equal(t, []byte("id2"), ids[0])
+		require.Equal(t, []byte("id1"), ids[1])
 		return nil
 	})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestListIndexAddRemoveID(t *testing.T) {
@@ -198,38 +198,38 @@ func TestListIndexAddRemoveID(t *testing.T) {
 
 	db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewListIndex(b, []byte("lindex1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
-		assert.Equal(t, 1, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 1, countItems(t, idx.IndexBucket))
 
 		err = idx.Add([]byte("hello"), []byte("id2"))
-		assert.NoError(t, err)
-		assert.Equal(t, 2, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 2, countItems(t, idx.IndexBucket))
 
 		err = idx.Add([]byte("goodbye"), []byte("id1"))
-		assert.NoError(t, err)
-		assert.Equal(t, 2, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 2, countItems(t, idx.IndexBucket))
 
 		err = idx.Add([]byte("hello"), []byte("id3"))
-		assert.NoError(t, err)
-		assert.Equal(t, 3, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 3, countItems(t, idx.IndexBucket))
 
 		err = idx.RemoveID([]byte("id1"))
-		assert.NoError(t, err)
-		assert.Equal(t, 2, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 2, countItems(t, idx.IndexBucket))
 
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
-		assert.Equal(t, 1, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 1, countItems(t, idx.IndexBucket))
 
 		err = idx.RemoveID([]byte("id3"))
-		assert.NoError(t, err)
-		assert.Equal(t, 0, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 0, countItems(t, idx.IndexBucket))
 		return nil
 	})
 }
@@ -242,70 +242,70 @@ func TestListIndexAllRecords(t *testing.T) {
 
 	db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewListIndex(b, []byte("lindex1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		ids, err := idx.AllRecords(nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 0)
+		require.NoError(t, err)
+		require.Len(t, ids, 0)
 
 		err = idx.Add([]byte("goodbye"), []byte("id2"))
-		assert.NoError(t, err)
-		assert.Equal(t, 1, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 1, countItems(t, idx.IndexBucket))
 
 		err = idx.Add([]byte("goodbye"), []byte("id1"))
-		assert.NoError(t, err)
-		assert.Equal(t, 2, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 2, countItems(t, idx.IndexBucket))
 
 		err = idx.Add([]byte("hello"), []byte("id4"))
-		assert.NoError(t, err)
-		assert.Equal(t, 3, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 3, countItems(t, idx.IndexBucket))
 
 		err = idx.Add([]byte("hello"), []byte("id3"))
-		assert.NoError(t, err)
-		assert.Equal(t, 4, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 4, countItems(t, idx.IndexBucket))
 
 		ids, err = idx.AllRecords(nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 4)
-		assert.Equal(t, []byte("id1"), ids[0])
-		assert.Equal(t, []byte("id2"), ids[1])
-		assert.Equal(t, []byte("id3"), ids[2])
-		assert.Equal(t, []byte("id4"), ids[3])
+		require.NoError(t, err)
+		require.Len(t, ids, 4)
+		require.Equal(t, []byte("id1"), ids[0])
+		require.Equal(t, []byte("id2"), ids[1])
+		require.Equal(t, []byte("id3"), ids[2])
+		require.Equal(t, []byte("id4"), ids[3])
 
 		err = idx.RemoveID([]byte("id1"))
-		assert.NoError(t, err)
-		assert.Equal(t, 3, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 3, countItems(t, idx.IndexBucket))
 
 		ids, err = idx.AllRecords(nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 3)
-		assert.Equal(t, []byte("id2"), ids[0])
+		require.NoError(t, err)
+		require.Len(t, ids, 3)
+		require.Equal(t, []byte("id2"), ids[0])
 
 		err = idx.Add([]byte("goodbye"), []byte("id1"))
-		assert.NoError(t, err)
-		assert.Equal(t, 4, countItems(t, idx.IndexBucket))
+		require.NoError(t, err)
+		require.Equal(t, 4, countItems(t, idx.IndexBucket))
 
 		opts := index.NewOptions()
 		opts.Limit = 1
 		ids, err = idx.AllRecords(opts)
-		assert.Len(t, ids, 1)
+		require.Len(t, ids, 1)
 
 		opts = index.NewOptions()
 		opts.Skip = 2
 		ids, err = idx.AllRecords(opts)
-		assert.Len(t, ids, 2)
+		require.Len(t, ids, 2)
 
 		opts = index.NewOptions()
 		opts.Skip = 2
 		opts.Limit = 3
 		opts.Reverse = true
 		ids, err = idx.AllRecords(opts)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 2)
-		assert.Equal(t, []byte("id2"), ids[0])
+		require.NoError(t, err)
+		require.Len(t, ids, 2)
+		require.Equal(t, []byte("id2"), ids[0])
 
 		return nil
 	})
@@ -319,56 +319,56 @@ func TestListIndexRange(t *testing.T) {
 
 	db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewListIndex(b, []byte("index1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		for i := 0; i < 10; i++ {
 			val, _ := gob.Codec.Marshal(i)
 			err = idx.Add(val, val)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 
 		min, _ := gob.Codec.Marshal(3)
 		max, _ := gob.Codec.Marshal(5)
 		list, err := idx.Range(min, max, nil)
-		assert.Len(t, list, 3)
-		assert.NoError(t, err)
+		require.Len(t, list, 3)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{3, 4, 5}, list)
 
 		min, _ = gob.Codec.Marshal(11)
 		max, _ = gob.Codec.Marshal(20)
 		list, err = idx.Range(min, max, nil)
-		assert.Len(t, list, 0)
-		assert.NoError(t, err)
+		require.Len(t, list, 0)
+		require.NoError(t, err)
 
 		min, _ = gob.Codec.Marshal(7)
 		max, _ = gob.Codec.Marshal(2)
 		list, err = idx.Range(min, max, nil)
-		assert.Len(t, list, 0)
-		assert.NoError(t, err)
+		require.Len(t, list, 0)
+		require.NoError(t, err)
 
 		min, _ = gob.Codec.Marshal(-5)
 		max, _ = gob.Codec.Marshal(2)
 		list, err = idx.Range(min, max, nil)
-		assert.Len(t, list, 0)
-		assert.NoError(t, err)
+		require.Len(t, list, 0)
+		require.NoError(t, err)
 
 		min, _ = gob.Codec.Marshal(3)
 		max, _ = gob.Codec.Marshal(7)
 		opts := index.NewOptions()
 		opts.Skip = 2
 		list, err = idx.Range(min, max, opts)
-		assert.Len(t, list, 3)
-		assert.NoError(t, err)
+		require.Len(t, list, 3)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{5, 6, 7}, list)
 
 		opts = index.NewOptions()
 		opts.Limit = 2
 		list, err = idx.Range(min, max, opts)
-		assert.Len(t, list, 2)
-		assert.NoError(t, err)
+		require.Len(t, list, 2)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{3, 4}, list)
 
 		opts = index.NewOptions()
@@ -376,8 +376,8 @@ func TestListIndexRange(t *testing.T) {
 		opts.Skip = 2
 		opts.Limit = 2
 		list, err = idx.Range(min, max, opts)
-		assert.Len(t, list, 2)
-		assert.NoError(t, err)
+		require.Len(t, list, 2)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{5, 4}, list)
 		return nil
 	})
diff --git a/index/unique_test.go b/index/unique_test.go
index b3b65c7..8e465c3 100644
--- a/index/unique_test.go
+++ b/index/unique_test.go
@@ -10,7 +10,7 @@ import (
 	"github.com/asdine/storm/codec/gob"
 	"github.com/asdine/storm/index"
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestUniqueIndex(t *testing.T) {
@@ -21,101 +21,101 @@ func TestUniqueIndex(t *testing.T) {
 
 	err := db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewUniqueIndex(b, []byte("uindex1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hello"), []byte("id2"))
-		assert.Error(t, err)
-		assert.Equal(t, index.ErrAlreadyExists, err)
+		require.Error(t, err)
+		require.Equal(t, index.ErrAlreadyExists, err)
 
 		err = idx.Add(nil, []byte("id2"))
-		assert.Error(t, err)
-		assert.Equal(t, index.ErrNilParam, err)
+		require.Error(t, err)
+		require.Equal(t, index.ErrNilParam, err)
 
 		err = idx.Add([]byte("hi"), nil)
-		assert.Error(t, err)
-		assert.Equal(t, index.ErrNilParam, err)
+		require.Error(t, err)
+		require.Equal(t, index.ErrNilParam, err)
 
 		id := idx.Get([]byte("hello"))
-		assert.Equal(t, []byte("id1"), id)
+		require.Equal(t, []byte("id1"), id)
 
 		id = idx.Get([]byte("goodbye"))
-		assert.Nil(t, id)
+		require.Nil(t, id)
 
 		err = idx.Remove([]byte("hello"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Remove(nil)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		id = idx.Get([]byte("hello"))
-		assert.Nil(t, id)
+		require.Nil(t, id)
 
 		err = idx.Add([]byte("hello"), []byte("id1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("hi"), []byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = idx.Add([]byte("yo"), []byte("id3"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		list, err := idx.AllRecords(nil)
-		assert.NoError(t, err)
-		assert.Len(t, list, 3)
+		require.NoError(t, err)
+		require.Len(t, list, 3)
 
 		opts := index.NewOptions()
 		opts.Limit = 2
 		list, err = idx.AllRecords(opts)
-		assert.NoError(t, err)
-		assert.Len(t, list, 2)
+		require.NoError(t, err)
+		require.Len(t, list, 2)
 
 		opts = index.NewOptions()
 		opts.Skip = 2
 		list, err = idx.AllRecords(opts)
-		assert.NoError(t, err)
-		assert.Len(t, list, 1)
-		assert.Equal(t, []byte("id3"), list[0])
+		require.NoError(t, err)
+		require.Len(t, list, 1)
+		require.Equal(t, []byte("id3"), list[0])
 
 		opts = index.NewOptions()
 		opts.Skip = 2
 		opts.Limit = 1
 		opts.Reverse = true
 		list, err = idx.AllRecords(opts)
-		assert.NoError(t, err)
-		assert.Len(t, list, 1)
-		assert.Equal(t, []byte("id1"), list[0])
+		require.NoError(t, err)
+		require.Len(t, list, 1)
+		require.Equal(t, []byte("id1"), list[0])
 
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		id = idx.Get([]byte("hello"))
-		assert.Equal(t, []byte("id1"), id)
+		require.Equal(t, []byte("id1"), id)
 		id = idx.Get([]byte("hi"))
-		assert.Nil(t, id)
+		require.Nil(t, id)
 		id = idx.Get([]byte("yo"))
-		assert.Equal(t, []byte("id3"), id)
+		require.Equal(t, []byte("id3"), id)
 		ids, err := idx.All([]byte("yo"), nil)
-		assert.NoError(t, err)
-		assert.Len(t, ids, 1)
-		assert.Equal(t, []byte("id3"), ids[0])
+		require.NoError(t, err)
+		require.Len(t, ids, 1)
+		require.Equal(t, []byte("id3"), ids[0])
 
 		err = idx.RemoveID([]byte("id2"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = idx.RemoveID([]byte("id4"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return nil
 	})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestUniqueIndexRange(t *testing.T) {
@@ -126,56 +126,56 @@ func TestUniqueIndexRange(t *testing.T) {
 
 	db.Bolt.Update(func(tx *bolt.Tx) error {
 		b, err := tx.CreateBucket([]byte("test"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		idx, err := index.NewUniqueIndex(b, []byte("uindex1"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		for i := 0; i < 10; i++ {
 			val, _ := gob.Codec.Marshal(i)
 			err = idx.Add(val, val)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 
 		min, _ := gob.Codec.Marshal(3)
 		max, _ := gob.Codec.Marshal(5)
 		list, err := idx.Range(min, max, nil)
-		assert.Len(t, list, 3)
-		assert.NoError(t, err)
+		require.Len(t, list, 3)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{3, 4, 5}, list)
 
 		min, _ = gob.Codec.Marshal(11)
 		max, _ = gob.Codec.Marshal(20)
 		list, err = idx.Range(min, max, nil)
-		assert.Len(t, list, 0)
-		assert.NoError(t, err)
+		require.Len(t, list, 0)
+		require.NoError(t, err)
 
 		min, _ = gob.Codec.Marshal(7)
 		max, _ = gob.Codec.Marshal(2)
 		list, err = idx.Range(min, max, nil)
-		assert.Len(t, list, 0)
-		assert.NoError(t, err)
+		require.Len(t, list, 0)
+		require.NoError(t, err)
 
 		min, _ = gob.Codec.Marshal(-5)
 		max, _ = gob.Codec.Marshal(2)
 		list, err = idx.Range(min, max, nil)
-		assert.Len(t, list, 0)
-		assert.NoError(t, err)
+		require.Len(t, list, 0)
+		require.NoError(t, err)
 
 		min, _ = gob.Codec.Marshal(3)
 		max, _ = gob.Codec.Marshal(7)
 		opts := index.NewOptions()
 		opts.Skip = 2
 		list, err = idx.Range(min, max, opts)
-		assert.Len(t, list, 3)
-		assert.NoError(t, err)
+		require.Len(t, list, 3)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{5, 6, 7}, list)
 
 		opts = index.NewOptions()
 		opts.Limit = 2
 		list, err = idx.Range(min, max, opts)
-		assert.Len(t, list, 2)
-		assert.NoError(t, err)
+		require.Len(t, list, 2)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{3, 4}, list)
 
 		opts = index.NewOptions()
@@ -183,8 +183,8 @@ func TestUniqueIndexRange(t *testing.T) {
 		opts.Skip = 2
 		opts.Limit = 2
 		list, err = idx.Range(min, max, opts)
-		assert.Len(t, list, 2)
-		assert.NoError(t, err)
+		require.Len(t, list, 2)
+		require.NoError(t, err)
 		assertEncodedIntListEqual(t, []int{5, 4}, list)
 		return nil
 	})
@@ -195,8 +195,8 @@ func assertEncodedIntListEqual(t *testing.T, expected []int, actual [][]byte) {
 
 	for i, e := range actual {
 		err := gob.Codec.Unmarshal(e, &ints[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
-	assert.Equal(t, expected, ints)
+	require.Equal(t, expected, ints)
 }
diff --git a/kv_test.go b/kv_test.go
index 8bea919..8e96e03 100644
--- a/kv_test.go
+++ b/kv_test.go
@@ -8,7 +8,6 @@ import (
 	"github.com/asdine/storm/codec/gob"
 	"github.com/asdine/storm/codec/json"
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -17,40 +16,40 @@ func TestGet(t *testing.T) {
 	defer cleanup()
 
 	err := db.Set("trash", 10, 100)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var nb int
 	err = db.Get("trash", 10, &nb)
-	assert.NoError(t, err)
-	assert.Equal(t, 100, nb)
+	require.NoError(t, err)
+	require.Equal(t, 100, nb)
 
 	tm := time.Now()
 	err = db.Set("logs", tm, "I'm hungry")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var message string
 	err = db.Get("logs", tm, &message)
-	assert.NoError(t, err)
-	assert.Equal(t, "I'm hungry", message)
+	require.NoError(t, err)
+	require.Equal(t, "I'm hungry", message)
 
 	var hand int
 	err = db.Get("wallet", "100 bucks", &hand)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.Set("wallet", "10 bucks", 10)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.Get("wallet", "100 bucks", &hand)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.Get("logs", tm, nil)
-	assert.Equal(t, ErrPtrNeeded, err)
+	require.Equal(t, ErrPtrNeeded, err)
 
 	err = db.Get("", nil, nil)
-	assert.Equal(t, ErrPtrNeeded, err)
+	require.Equal(t, ErrPtrNeeded, err)
 
 	err = db.Get("", "100 bucks", &hand)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 }
 
 func TestGetBytes(t *testing.T) {
@@ -58,14 +57,14 @@ func TestGetBytes(t *testing.T) {
 	defer cleanup()
 
 	err := db.SetBytes("trash", "a", []byte("hi"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	val, err := db.GetBytes("trash", "a")
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("hi"), val)
+	require.NoError(t, err)
+	require.Equal(t, []byte("hi"), val)
 
 	_, err = db.GetBytes("trash", "b")
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 }
 
 func TestSet(t *testing.T) {
@@ -73,52 +72,52 @@ func TestSet(t *testing.T) {
 	defer cleanup()
 
 	err := db.Set("b1", 10, 10)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Set("b1", "best friend's mail", &mail.Address{Name: "Gandalf", Address: "gandalf@lorien.ma"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Set("b2", []byte("i'm already a slice of bytes"), "a value")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Set("b2", []byte("i'm already a slice of bytes"), nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Set("b1", 0, 100)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Set("b1", nil, 100)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	db.Bolt.View(func(tx *bolt.Tx) error {
 		b1 := tx.Bucket([]byte("b1"))
-		assert.NotNil(t, b1)
+		require.NotNil(t, b1)
 		b2 := tx.Bucket([]byte("b2"))
-		assert.NotNil(t, b2)
+		require.NotNil(t, b2)
 
 		k1, err := toBytes(10, json.Codec)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		val := b1.Get(k1)
-		assert.NotNil(t, val)
+		require.NotNil(t, val)
 
 		k2 := []byte("best friend's mail")
 		val = b1.Get(k2)
-		assert.NotNil(t, val)
+		require.NotNil(t, val)
 
 		k3, err := toBytes(0, json.Codec)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		val = b1.Get(k3)
-		assert.NotNil(t, val)
+		require.NotNil(t, val)
 
 		return nil
 	})
 
 	err = db.Set("", 0, 100)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = db.Set("b", nil, 100)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = db.Set("b", 10, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.Set("b", nil, nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestSetMetadata(t *testing.T) {
@@ -138,13 +137,13 @@ func TestDelete(t *testing.T) {
 	defer cleanup()
 
 	err := db.Set("files", "myfile.csv", "a,b,c,d")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Delete("files", "myfile.csv")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Delete("files", "myfile.csv")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.Delete("i don't exist", "myfile.csv")
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 	err = db.Delete("", nil)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 }
diff --git a/node_test.go b/node_test.go
index 7d0f88e..99b902a 100644
--- a/node_test.go
+++ b/node_test.go
@@ -6,7 +6,7 @@ import (
 	"github.com/asdine/storm/codec/gob"
 	"github.com/asdine/storm/codec/json"
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNode(t *testing.T) {
@@ -15,15 +15,15 @@ func TestNode(t *testing.T) {
 
 	n1 := db.From("b", "c")
 	node1, ok := n1.(*node)
-	assert.True(t, ok)
-	assert.Equal(t, db, node1.s)
-	assert.NotEqual(t, db.root, n1)
-	assert.Equal(t, []string{"a"}, db.root.rootBucket)
-	assert.Equal(t, []string{"b", "c"}, node1.rootBucket)
+	require.True(t, ok)
+	require.Equal(t, db, node1.s)
+	require.NotEqual(t, db.root, n1)
+	require.Equal(t, []string{"a"}, db.root.rootBucket)
+	require.Equal(t, []string{"b", "c"}, node1.rootBucket)
 	n2 := n1.From("d", "e")
 	node2, ok := n2.(*node)
-	assert.True(t, ok)
-	assert.Equal(t, []string{"b", "c", "d", "e"}, node2.rootBucket)
+	require.True(t, ok)
+	require.Equal(t, []string{"b", "c", "d", "e"}, node2.rootBucket)
 }
 
 func TestNodeWithTransaction(t *testing.T) {
@@ -34,15 +34,15 @@ func TestNodeWithTransaction(t *testing.T) {
 	db.Bolt.Update(func(tx *bolt.Tx) error {
 		dbx := db.WithTransaction(tx)
 		err := dbx.Save(&User{ID: 10, Name: "John"})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = dbx.One("ID", 10, &user)
-		assert.NoError(t, err)
-		assert.Equal(t, "John", user.Name)
+		require.NoError(t, err)
+		require.Equal(t, "John", user.Name)
 		return nil
 	})
 
 	err := db.One("ID", 10, &user)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNodeWithCodec(t *testing.T) {
@@ -50,13 +50,13 @@ func TestNodeWithCodec(t *testing.T) {
 	defer cleanup()
 
 	n := db.From("a").(*node)
-	assert.Equal(t, json.Codec, n.codec)
+	require.Equal(t, json.Codec, n.codec)
 	n = n.From("b", "c", "d").(*node)
-	assert.Equal(t, json.Codec, n.codec)
+	require.Equal(t, json.Codec, n.codec)
 	n = db.WithCodec(gob.Codec).(*node)
 	n = n.From("e").(*node)
-	assert.Equal(t, gob.Codec, n.codec)
+	require.Equal(t, gob.Codec, n.codec)
 	o := n.From("f").WithCodec(json.Codec).(*node)
-	assert.Equal(t, gob.Codec, n.codec)
-	assert.Equal(t, json.Codec, o.codec)
+	require.Equal(t, gob.Codec, n.codec)
+	require.Equal(t, json.Codec, o.codec)
 }
diff --git a/q/tree_test.go b/q/tree_test.go
index 7d0ba19..fb3b631 100644
--- a/q/tree_test.go
+++ b/q/tree_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type A struct {
@@ -19,34 +19,34 @@ type B struct {
 }
 
 func TestCompare(t *testing.T) {
-	assert.True(t, compare(10, 10, token.EQL))
-	assert.True(t, compare(10, 10.0, token.EQL))
-	assert.True(t, compare(10, "10", token.EQL))
-	assert.True(t, compare(10, "10.0", token.EQL))
-	assert.False(t, compare(10, "hello", token.EQL))
-	assert.True(t, compare(10.0, 10, token.EQL))
-	assert.True(t, compare(10.0, 10.0, token.EQL))
-	assert.True(t, compare(10.0, "10", token.EQL))
-	assert.True(t, compare(10.0, "10.0", token.EQL))
-	assert.False(t, compare(10.0, "hello", token.EQL))
-	assert.True(t, compare("hello", "hello", token.EQL))
-	assert.True(t, compare(&A{Name: "John"}, &A{Name: "John"}, token.EQL))
-	assert.False(t, compare(&A{Name: "John"}, &A{Name: "Jack"}, token.GTR))
-	assert.True(t, compare(10, 5.0, token.GTR))
+	require.True(t, compare(10, 10, token.EQL))
+	require.True(t, compare(10, 10.0, token.EQL))
+	require.True(t, compare(10, "10", token.EQL))
+	require.True(t, compare(10, "10.0", token.EQL))
+	require.False(t, compare(10, "hello", token.EQL))
+	require.True(t, compare(10.0, 10, token.EQL))
+	require.True(t, compare(10.0, 10.0, token.EQL))
+	require.True(t, compare(10.0, "10", token.EQL))
+	require.True(t, compare(10.0, "10.0", token.EQL))
+	require.False(t, compare(10.0, "hello", token.EQL))
+	require.True(t, compare("hello", "hello", token.EQL))
+	require.True(t, compare(&A{Name: "John"}, &A{Name: "John"}, token.EQL))
+	require.False(t, compare(&A{Name: "John"}, &A{Name: "Jack"}, token.GTR))
+	require.True(t, compare(10, 5.0, token.GTR))
 	t1 := time.Now()
 	t2 := t1.Add(2 * time.Hour)
 	t3 := t1.Add(-2 * time.Hour)
-	assert.True(t, compare(t1, t1, token.EQL))
-	assert.True(t, compare(t1, t2, token.LSS))
-	assert.True(t, compare(t1, t3, token.GTR))
-	assert.False(t, compare(&A{Name: "John"}, t1, token.EQL))
-	assert.False(t, compare(&A{Name: "John"}, t1, token.LEQ))
-	assert.True(t, compare(uint32(10), uint32(5), token.GTR))
-	assert.False(t, compare(uint32(5), uint32(10), token.GTR))
-	assert.True(t, compare(uint32(10), int32(5), token.GTR))
-	assert.True(t, compare(uint32(10), float32(5), token.GTR))
-	assert.True(t, compare(int32(10), uint32(5), token.GTR))
-	assert.True(t, compare(float32(10), uint32(5), token.GTR))
+	require.True(t, compare(t1, t1, token.EQL))
+	require.True(t, compare(t1, t2, token.LSS))
+	require.True(t, compare(t1, t3, token.GTR))
+	require.False(t, compare(&A{Name: "John"}, t1, token.EQL))
+	require.False(t, compare(&A{Name: "John"}, t1, token.LEQ))
+	require.True(t, compare(uint32(10), uint32(5), token.GTR))
+	require.False(t, compare(uint32(5), uint32(10), token.GTR))
+	require.True(t, compare(uint32(10), int32(5), token.GTR))
+	require.True(t, compare(uint32(10), float32(5), token.GTR))
+	require.True(t, compare(int32(10), uint32(5), token.GTR))
+	require.True(t, compare(float32(10), uint32(5), token.GTR))
 }
 
 func TestCmp(t *testing.T) {
@@ -60,25 +60,25 @@ func TestCmp(t *testing.T) {
 
 	q := Eq("Age", 10)
 	ok, err := q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	q = Gt("Age", 15)
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 
 	// Unknown field
 	q = Gt("Unknown", 15)
 	ok, err = q.Match(&a)
-	assert.Equal(t, err, ErrUnknownField)
-	assert.False(t, ok)
+	require.Equal(t, err, ErrUnknownField)
+	require.False(t, ok)
 }
 
 func TestStrictEq(t *testing.T) {
@@ -96,19 +96,19 @@ func TestStrictEq(t *testing.T) {
 
 	q := StrictEq("Age", 10)
 	ok, err := q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	q = StrictEq("Age", 10.0)
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 }
 
 func TestIn(t *testing.T) {
@@ -118,33 +118,33 @@ func TestIn(t *testing.T) {
 
 	q := In("Age", []int{1, 5, 10, 3})
 	ok, err := q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 
 	q = In("Age", []int{1, 5, 3})
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	q = In("Age", []int{})
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	q = In("Age", nil)
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	q = In("Age", []float64{1.0, 5.0, 10.0, 3.0})
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 
 	q = In("Age", 10)
 	ok, err = q.Match(&a)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 }
 
 func TestAnd(t *testing.T) {
@@ -163,11 +163,11 @@ func TestAnd(t *testing.T) {
 		Eq("Name", "John"),
 	)
 	ok, err := q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 }
 
 func TestOr(t *testing.T) {
@@ -186,11 +186,11 @@ func TestOr(t *testing.T) {
 		Eq("Name", "Jack"),
 	)
 	ok, err := q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 }
 
 func TestNot(t *testing.T) {
@@ -200,14 +200,14 @@ func TestNot(t *testing.T) {
 	ok, err := q.Match(&A{
 		Age: 11,
 	})
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 
 	ok, err = q.Match(&A{
 		Age: 10,
 	})
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	q = Not(
 		Gt("Age", 10),
@@ -216,22 +216,22 @@ func TestNot(t *testing.T) {
 	ok, err = q.Match(&A{
 		Age: 8,
 	})
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 
 	ok, err = q.Match(&A{
 		Age:  11,
 		Name: "Jack",
 	})
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 
 	ok, err = q.Match(&A{
 		Age:  5,
 		Name: "John",
 	})
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 }
 
 func TestAndOr(t *testing.T) {
@@ -253,9 +253,9 @@ func TestAndOr(t *testing.T) {
 		),
 	)
 	ok, err := q.Match(&a)
-	assert.NoError(t, err)
-	assert.True(t, ok)
+	require.NoError(t, err)
+	require.True(t, ok)
 	ok, err = q.Match(&b)
-	assert.NoError(t, err)
-	assert.False(t, ok)
+	require.NoError(t, err)
+	require.False(t, ok)
 }
diff --git a/query_test.go b/query_test.go
index 2ee65dd..95d7dcb 100644
--- a/query_test.go
+++ b/query_test.go
@@ -6,7 +6,6 @@ import (
 
 	"github.com/asdine/storm/codec/json"
 	"github.com/asdine/storm/q"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -22,7 +21,7 @@ func prepareScoreDB(t *testing.T) (*DB, func()) {
 		err := db.Save(&Score{
 			Value: i,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	return db, cleanup
@@ -36,14 +35,14 @@ func TestSelectFind(t *testing.T) {
 	var scoresPtr []*Score
 
 	err := db.Select(q.Eq("Value", 5)).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 1)
-	assert.Equal(t, 5, scores[0].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 1)
+	require.Equal(t, 5, scores[0].Value)
 
 	err = db.Select(q.Eq("Value", 5)).Find(&scoresPtr)
-	assert.NoError(t, err)
-	assert.Len(t, scoresPtr, 1)
-	assert.Equal(t, 5, scoresPtr[0].Value)
+	require.NoError(t, err)
+	require.Len(t, scoresPtr, 1)
+	require.Equal(t, 5, scoresPtr[0].Value)
 
 	err = db.Select(
 		q.Or(
@@ -51,10 +50,10 @@ func TestSelectFind(t *testing.T) {
 			q.Eq("Value", 6),
 		),
 	).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 2)
-	assert.Equal(t, 5, scores[0].Value)
-	assert.Equal(t, 6, scores[1].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 2)
+	require.Equal(t, 5, scores[0].Value)
+	require.Equal(t, 6, scores[1].Value)
 
 	err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -63,14 +62,14 @@ func TestSelectFind(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 6)
-	assert.Equal(t, 0, scores[0].Value)
-	assert.Equal(t, 1, scores[1].Value)
-	assert.Equal(t, 2, scores[2].Value)
-	assert.Equal(t, 5, scores[3].Value)
-	assert.Equal(t, 18, scores[4].Value)
-	assert.Equal(t, 19, scores[5].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 6)
+	require.Equal(t, 0, scores[0].Value)
+	require.Equal(t, 1, scores[1].Value)
+	require.Equal(t, 2, scores[2].Value)
+	require.Equal(t, 5, scores[3].Value)
+	require.Equal(t, 18, scores[4].Value)
+	require.Equal(t, 19, scores[5].Value)
 
 	err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -79,14 +78,14 @@ func TestSelectFind(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Reverse().Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 6)
-	assert.Equal(t, 19, scores[0].Value)
-	assert.Equal(t, 18, scores[1].Value)
-	assert.Equal(t, 5, scores[2].Value)
-	assert.Equal(t, 2, scores[3].Value)
-	assert.Equal(t, 1, scores[4].Value)
-	assert.Equal(t, 0, scores[5].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 6)
+	require.Equal(t, 19, scores[0].Value)
+	require.Equal(t, 18, scores[1].Value)
+	require.Equal(t, 5, scores[2].Value)
+	require.Equal(t, 2, scores[3].Value)
+	require.Equal(t, 1, scores[4].Value)
+	require.Equal(t, 0, scores[5].Value)
 }
 
 func TestSelectFindSkip(t *testing.T) {
@@ -102,10 +101,10 @@ func TestSelectFindSkip(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(4).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 2)
-	assert.Equal(t, 18, scores[0].Value)
-	assert.Equal(t, 19, scores[1].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 2)
+	require.Equal(t, 18, scores[0].Value)
+	require.Equal(t, 19, scores[1].Value)
 
 	err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -114,9 +113,9 @@ func TestSelectFindSkip(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(-10).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 6)
-	assert.Equal(t, 0, scores[0].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 6)
+	require.Equal(t, 0, scores[0].Value)
 
 	scores = nil
 	err = db.Select(q.Or(
@@ -126,9 +125,9 @@ func TestSelectFindSkip(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(1000).Find(&scores)
-	assert.Error(t, err)
-	assert.True(t, ErrNotFound == err)
-	assert.Len(t, scores, 0)
+	require.Error(t, err)
+	require.True(t, ErrNotFound == err)
+	require.Len(t, scores, 0)
 }
 
 func TestSelectFindLimit(t *testing.T) {
@@ -143,10 +142,10 @@ func TestSelectFindLimit(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Limit(2).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 2)
-	assert.Equal(t, 0, scores[0].Value)
-	assert.Equal(t, 1, scores[1].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 2)
+	require.Equal(t, 0, scores[0].Value)
+	require.Equal(t, 1, scores[1].Value)
 
 	err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -155,9 +154,9 @@ func TestSelectFindLimit(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Limit(-10).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 6)
-	assert.Equal(t, 0, scores[0].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 6)
+	require.Equal(t, 0, scores[0].Value)
 
 	scores = nil
 	err = db.Select(q.Or(
@@ -167,9 +166,9 @@ func TestSelectFindLimit(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Limit(0).Find(&scores)
-	assert.Error(t, err)
-	assert.True(t, ErrNotFound == err)
-	assert.Len(t, scores, 0)
+	require.Error(t, err)
+	require.True(t, ErrNotFound == err)
+	require.Len(t, scores, 0)
 }
 
 func TestSelectFindLimitSkip(t *testing.T) {
@@ -185,10 +184,10 @@ func TestSelectFindLimitSkip(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Limit(2).Skip(2).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 2)
-	assert.Equal(t, 2, scores[0].Value)
-	assert.Equal(t, 5, scores[1].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 2)
+	require.Equal(t, 2, scores[0].Value)
+	require.Equal(t, 5, scores[1].Value)
 
 	err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -197,9 +196,9 @@ func TestSelectFindLimitSkip(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Limit(2).Skip(5).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 1)
-	assert.Equal(t, 19, scores[0].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 1)
+	require.Equal(t, 19, scores[0].Value)
 }
 
 func TestSelectFindOrderBy(t *testing.T) {
@@ -225,105 +224,105 @@ func TestSelectFindOrderBy(t *testing.T) {
 		}
 
 		err := db.Save(&record)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	var list []T
 	err := db.Select().OrderBy("ID").Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 6)
+	require.NoError(t, err)
+	require.Len(t, list, 6)
 	for i, j := 0, 0; i < 6; i, j = i+1, j+1 {
 		if i == 2 {
 			j--
 		}
-		assert.Equal(t, i+1, list[i].ID)
+		require.Equal(t, i+1, list[i].ID)
 	}
 
 	list = nil
 	err = db.Select().OrderBy("Str").Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 6)
+	require.NoError(t, err)
+	require.Len(t, list, 6)
 	for i, j := 0, 0; i < 6; i, j = i+1, j+1 {
 		if i == 4 {
 			j--
 		}
-		assert.Equal(t, string([]byte{'a' + byte(j)}), list[i].Str)
+		require.Equal(t, string([]byte{'a' + byte(j)}), list[i].Str)
 	}
 
 	list = nil
 	err = db.Select().OrderBy("Int").Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 6)
+	require.NoError(t, err)
+	require.Len(t, list, 6)
 	for i, j := 0, 0; i < 6; i, j = i+1, j+1 {
 		if i == 2 {
 			j--
 		}
-		assert.Equal(t, j+1, list[i].Int)
+		require.Equal(t, j+1, list[i].Int)
 	}
 
 	list = nil
 	err = db.Select().OrderBy("Rnd").Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 6)
-	assert.Equal(t, 1, list[0].ID)
-	assert.Equal(t, 2, list[1].ID)
-	assert.Equal(t, 3, list[2].ID)
-	assert.Equal(t, 5, list[3].ID)
-	assert.Equal(t, 6, list[4].ID)
-	assert.Equal(t, 4, list[5].ID)
+	require.NoError(t, err)
+	require.Len(t, list, 6)
+	require.Equal(t, 1, list[0].ID)
+	require.Equal(t, 2, list[1].ID)
+	require.Equal(t, 3, list[2].ID)
+	require.Equal(t, 5, list[3].ID)
+	require.Equal(t, 6, list[4].ID)
+	require.Equal(t, 4, list[5].ID)
 
 	list = nil
 	err = db.Select().OrderBy("Int").Reverse().Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 6)
+	require.NoError(t, err)
+	require.Len(t, list, 6)
 	for i, j := 0, 0; i < 6; i, j = i+1, j+1 {
 		if i == 4 {
 			j--
 		}
-		assert.Equal(t, 5-j, list[i].Int)
+		require.Equal(t, 5-j, list[i].Int)
 	}
 
 	list = nil
 	err = db.Select().OrderBy("Int").Reverse().Limit(2).Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 2)
+	require.NoError(t, err)
+	require.Len(t, list, 2)
 	for i := 0; i < 2; i++ {
-		assert.Equal(t, 5-i, list[i].Int)
+		require.Equal(t, 5-i, list[i].Int)
 	}
 
 	list = nil
 	err = db.Select().OrderBy("Int").Reverse().Skip(2).Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 4)
+	require.NoError(t, err)
+	require.Len(t, list, 4)
 	for i, j := 0, 0; i < 3; i, j = i+1, j+1 {
 		if i == 2 {
 			j--
 		}
-		assert.Equal(t, 3-j, list[i].Int)
+		require.Equal(t, 3-j, list[i].Int)
 	}
 
 	list = nil
 	err = db.Select().OrderBy("Int").Reverse().Skip(5).Limit(2).Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 1)
-	assert.Equal(t, 1, list[0].Int)
+	require.NoError(t, err)
+	require.Len(t, list, 1)
+	require.Equal(t, 1, list[0].Int)
 
 	list = nil
 	err = db.Select().OrderBy("Str", "Int").Find(&list)
-	assert.NoError(t, err)
-	assert.Len(t, list, 6)
-	assert.Equal(t, "a", list[0].Str)
-	assert.Equal(t, 4, list[0].Int)
-	assert.Equal(t, "b", list[1].Str)
-	assert.Equal(t, 3, list[1].Int)
-	assert.Equal(t, "c", list[2].Str)
-	assert.Equal(t, 2, list[2].Int)
-	assert.Equal(t, "d", list[3].Str)
-	assert.Equal(t, 1, list[3].Int)
-	assert.Equal(t, "d", list[4].Str)
-	assert.Equal(t, 5, list[4].Int)
-	assert.Equal(t, "e", list[5].Str)
-	assert.Equal(t, 2, list[5].Int)
+	require.NoError(t, err)
+	require.Len(t, list, 6)
+	require.Equal(t, "a", list[0].Str)
+	require.Equal(t, 4, list[0].Int)
+	require.Equal(t, "b", list[1].Str)
+	require.Equal(t, 3, list[1].Int)
+	require.Equal(t, "c", list[2].Str)
+	require.Equal(t, 2, list[2].Int)
+	require.Equal(t, "d", list[3].Str)
+	require.Equal(t, 1, list[3].Int)
+	require.Equal(t, "d", list[4].Str)
+	require.Equal(t, 5, list[4].Int)
+	require.Equal(t, "e", list[5].Str)
+	require.Equal(t, 2, list[5].Int)
 }
 
 func TestSelectFirst(t *testing.T) {
@@ -339,8 +338,8 @@ func TestSelectFirst(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(2).First(&score)
-	assert.NoError(t, err)
-	assert.Equal(t, 2, score.Value)
+	require.NoError(t, err)
+	require.Equal(t, 2, score.Value)
 
 	err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -349,8 +348,8 @@ func TestSelectFirst(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(1).Reverse().First(&score)
-	assert.NoError(t, err)
-	assert.Equal(t, 18, score.Value)
+	require.NoError(t, err)
+	require.Equal(t, 18, score.Value)
 }
 
 func TestSelectFirstOrderBy(t *testing.T) {
@@ -370,37 +369,37 @@ func TestSelectFirstOrderBy(t *testing.T) {
 			Str: strs[i],
 			Int: ints[i],
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	var record T
 	err := db.Select().OrderBy("ID").First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, record.ID)
+	require.NoError(t, err)
+	require.Equal(t, 1, record.ID)
 
 	err = db.Select().OrderBy("Str").First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, "a", record.Str)
+	require.NoError(t, err)
+	require.Equal(t, "a", record.Str)
 
 	err = db.Select().OrderBy("Int").First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, record.Int)
+	require.NoError(t, err)
+	require.Equal(t, 1, record.Int)
 
 	err = db.Select().OrderBy("Int").Reverse().First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, 5, record.Int)
+	require.NoError(t, err)
+	require.Equal(t, 5, record.Int)
 
 	err = db.Select().OrderBy("Int").Reverse().Limit(2).First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, 5, record.Int)
+	require.NoError(t, err)
+	require.Equal(t, 5, record.Int)
 
 	err = db.Select().OrderBy("Int").Reverse().Skip(2).First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, 3, record.Int)
+	require.NoError(t, err)
+	require.Equal(t, 3, record.Int)
 
 	err = db.Select().OrderBy("Int").Reverse().Skip(4).Limit(2).First(&record)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, record.Int)
+	require.NoError(t, err)
+	require.Equal(t, 1, record.Int)
 }
 
 func TestSelectDelete(t *testing.T) {
@@ -414,7 +413,7 @@ func TestSelectDelete(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(2).Delete(&Score{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var scores []Score
 	err = db.Select(q.Or(
@@ -424,27 +423,27 @@ func TestSelectDelete(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Find(&scores)
-	assert.NoError(t, err)
-	assert.Len(t, scores, 2)
-	assert.Equal(t, 0, scores[0].Value)
-	assert.Equal(t, 1, scores[1].Value)
+	require.NoError(t, err)
+	require.Len(t, scores, 2)
+	require.Equal(t, 0, scores[0].Value)
+	require.Equal(t, 1, scores[1].Value)
 
 	for i := 0; i < 10; i++ {
 		w := User{ID: i + 1, Name: fmt.Sprintf("John%d", i+1)}
 		err = db.Save(&w)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	err = db.Select(q.Gte("ID", 5)).Delete(&User{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var user User
 	err = db.One("Name", "John6", &user)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotFound, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.One("Name", "John4", &user)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestSelectCount(t *testing.T) {
@@ -458,8 +457,8 @@ func TestSelectCount(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Count(&Score{})
-	assert.NoError(t, err)
-	assert.Equal(t, 6, total)
+	require.NoError(t, err)
+	require.Equal(t, 6, total)
 
 	total, err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -468,8 +467,8 @@ func TestSelectCount(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(2).Count(&Score{})
-	assert.NoError(t, err)
-	assert.Equal(t, 4, total)
+	require.NoError(t, err)
+	require.Equal(t, 4, total)
 
 	total, err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -478,8 +477,8 @@ func TestSelectCount(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(2).Limit(2).Count(&Score{})
-	assert.NoError(t, err)
-	assert.Equal(t, 2, total)
+	require.NoError(t, err)
+	require.Equal(t, 2, total)
 
 	total, err = db.Select(q.Or(
 		q.Eq("Value", 5),
@@ -488,8 +487,8 @@ func TestSelectCount(t *testing.T) {
 			q.Gte("Value", 18),
 		),
 	)).Skip(5).Limit(2).Count(&Score{})
-	assert.NoError(t, err)
-	assert.Equal(t, 1, total)
+	require.NoError(t, err)
+	require.Equal(t, 1, total)
 }
 
 func TestSelectRaw(t *testing.T) {
@@ -500,24 +499,24 @@ func TestSelectRaw(t *testing.T) {
 		err := db.Save(&Score{
 			Value: i,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	list, err := db.Select().Bucket("Score").Raw()
-	assert.NoError(t, err)
-	assert.Len(t, list, 20)
+	require.NoError(t, err)
+	require.Len(t, list, 20)
 
 	list, err = db.Select().Bucket("Score").Skip(18).Limit(5).Raw()
-	assert.NoError(t, err)
-	assert.Len(t, list, 2)
+	require.NoError(t, err)
+	require.Len(t, list, 2)
 
 	i := 0
 	err = db.Select().Bucket("Score").Skip(18).Limit(5).RawEach(func(k []byte, v []byte) error {
 		i++
 		return nil
 	})
-	assert.NoError(t, err)
-	assert.Equal(t, i, 2)
+	require.NoError(t, err)
+	require.Equal(t, i, 2)
 }
 
 func TestSelectEach(t *testing.T) {
@@ -528,7 +527,7 @@ func TestSelectEach(t *testing.T) {
 		err := db.Save(&Score{
 			Value: i,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	i := 0
diff --git a/scan_test.go b/scan_test.go
index f9e4d3e..1052641 100644
--- a/scan_test.go
+++ b/scan_test.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -27,26 +26,26 @@ func doTestPrefixScan(t *testing.T, node Node) {
 	for i := 1; i < 3; i++ {
 		n := node.From(fmt.Sprintf("%d%02d", 2015, i))
 		err := n.Save(&SimpleUser{ID: i, Name: "John"})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	for i := 1; i < 4; i++ {
 		n := node.From(fmt.Sprintf("%d%02d", 2016, i))
 		err := n.Save(&SimpleUser{ID: i, Name: "John"})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
-	assert.Len(t, node.PrefixScan("2015"), 2)
-	assert.Len(t, node.PrefixScan("20"), 5)
+	require.Len(t, node.PrefixScan("2015"), 2)
+	require.Len(t, node.PrefixScan("20"), 5)
 
 	buckets2016 := node.PrefixScan("2016")
-	assert.Len(t, buckets2016, 3)
+	require.Len(t, buckets2016, 3)
 	count, err := buckets2016[1].Count(&SimpleUser{})
 
-	assert.NoError(t, err)
-	assert.Equal(t, 1, count)
+	require.NoError(t, err)
+	require.Equal(t, 1, count)
 
-	assert.NoError(t, buckets2016[1].One("ID", 2, &SimpleUser{}))
+	require.NoError(t, buckets2016[1].One("ID", 2, &SimpleUser{}))
 }
 
 func TestPrefixScanWithEmptyPrefix(t *testing.T) {
@@ -89,17 +88,17 @@ func doTestRangeScan(t *testing.T, node Node) {
 	for y := 2012; y <= 2016; y++ {
 		for m := 1; m <= 12; m++ {
 			n := node.From(fmt.Sprintf("%d%02d", y, m))
-			assert.NoError(t, n.Save(&SimpleUser{ID: m, Name: "John"}))
+			require.NoError(t, n.Save(&SimpleUser{ID: m, Name: "John"}))
 		}
 	}
 
-	assert.Len(t, node.RangeScan("2015", "2016"), 12)
-	assert.Len(t, node.RangeScan("201201", "201203"), 3)
-	assert.Len(t, node.RangeScan("2012", "201612"), 60)
-	assert.Len(t, node.RangeScan("2012", "2017"), 60)
+	require.Len(t, node.RangeScan("2015", "2016"), 12)
+	require.Len(t, node.RangeScan("201201", "201203"), 3)
+	require.Len(t, node.RangeScan("2012", "201612"), 60)
+	require.Len(t, node.RangeScan("2012", "2017"), 60)
 
 	secondIn2015 := node.RangeScan("2015", "2016")[1]
-	assert.NoError(t, secondIn2015.One("ID", 2, &SimpleUser{}))
+	require.NoError(t, secondIn2015.One("ID", 2, &SimpleUser{}))
 }
 
 func TestRangeScanSkipValues(t *testing.T) {
diff --git a/store_test.go b/store_test.go
index 5950269..314a276 100644
--- a/store_test.go
+++ b/store_test.go
@@ -10,7 +10,6 @@ import (
 	"github.com/asdine/storm/codec/json"
 	"github.com/asdine/storm/q"
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -20,30 +19,30 @@ func TestInit(t *testing.T) {
 
 	var u IndexedNameUser
 	err := db.One("Name", "John", &u)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.Init(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "John", &u)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotFound, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.Init(&ClassicBadTags{})
-	assert.Error(t, err)
-	assert.Equal(t, ErrUnknownTag, err)
+	require.Error(t, err)
+	require.Equal(t, ErrUnknownTag, err)
 
 	err = db.Init(10)
-	assert.Error(t, err)
-	assert.Equal(t, ErrBadType, err)
+	require.Error(t, err)
+	require.Equal(t, ErrBadType, err)
 
 	err = db.Init(&ClassicNoTags{})
-	assert.Error(t, err)
-	assert.Equal(t, ErrNoID, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNoID, err)
 
 	err = db.Init(&struct{ ID string }{})
-	assert.Error(t, err)
-	assert.Equal(t, ErrNoName, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNoName, err)
 }
 
 func TestInitMetadata(t *testing.T) {
@@ -74,15 +73,15 @@ func TestReIndex(t *testing.T) {
 			Name: fmt.Sprintf("John%d", i),
 		}
 		err := db.Save(&u)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	db.Bolt.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte("User"))
-		assert.NotNil(t, bucket)
+		require.NotNil(t, bucket)
 
-		assert.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Name")))
-		assert.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Age")))
+		require.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Name")))
+		require.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Age")))
 		return nil
 	})
 
@@ -97,11 +96,11 @@ func TestReIndex(t *testing.T) {
 
 	db.Bolt.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte("User"))
-		assert.NotNil(t, bucket)
+		require.NotNil(t, bucket)
 
-		assert.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Name")))
-		assert.Nil(t, bucket.Bucket([]byte(indexPrefix+"Age")))
-		assert.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Group")))
+		require.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Name")))
+		require.Nil(t, bucket.Bucket([]byte(indexPrefix+"Age")))
+		require.NotNil(t, bucket.Bucket([]byte(indexPrefix+"Group")))
 		return nil
 	})
 }
@@ -111,53 +110,53 @@ func TestSave(t *testing.T) {
 	defer cleanup()
 
 	err := db.Save(&SimpleUser{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.Save(&SimpleUser{Name: "John"})
-	assert.Error(t, err)
-	assert.Equal(t, ErrZeroID, err)
+	require.Error(t, err)
+	require.Equal(t, ErrZeroID, err)
 
 	err = db.Save(&ClassicBadTags{ID: "id", PublicField: 100})
-	assert.Error(t, err)
-	assert.Equal(t, ErrUnknownTag, err)
+	require.Error(t, err)
+	require.Equal(t, ErrUnknownTag, err)
 
 	err = db.Save(&UserWithNoID{Name: "John"})
-	assert.Error(t, err)
-	assert.Equal(t, ErrNoID, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNoID, err)
 
 	err = db.Save(&UserWithIDField{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	u := UserWithEmbeddedIDField{}
 	u.ID = 150
 	u.Name = "Pete"
 	u.Age = 10
 	err = db.Save(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	v := UserWithIDField{ID: 10, Name: "John"}
 	err = db.Save(&v)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	w := UserWithEmbeddedField{}
 	w.ID = 150
 	w.Name = "John"
 	err = db.Save(&w)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db.Bolt.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte("UserWithIDField"))
-		assert.NotNil(t, bucket)
+		require.NotNil(t, bucket)
 
 		i, err := toBytes(10, json.Codec)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		val := bucket.Get(i)
-		assert.NotNil(t, val)
+		require.NotNil(t, val)
 
 		content, err := db.codec.Marshal(&v)
-		assert.NoError(t, err)
-		assert.Equal(t, content, val)
+		require.NoError(t, err)
+		require.Equal(t, content, val)
 		return nil
 	})
 }
@@ -168,31 +167,31 @@ func TestSaveUnique(t *testing.T) {
 
 	u1 := UniqueNameUser{ID: 10, Name: "John", Age: 10}
 	err := db.Save(&u1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	u2 := UniqueNameUser{ID: 11, Name: "John", Age: 100}
 	err = db.Save(&u2)
-	assert.Error(t, err)
-	assert.True(t, ErrAlreadyExists == err)
+	require.Error(t, err)
+	require.True(t, ErrAlreadyExists == err)
 
 	// same id
 	u3 := UniqueNameUser{ID: 10, Name: "Jake", Age: 100}
 	err = db.Save(&u3)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db.Bolt.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte("UniqueNameUser"))
 
 		uniqueBucket := bucket.Bucket([]byte(indexPrefix + "Name"))
-		assert.NotNil(t, uniqueBucket)
+		require.NotNil(t, uniqueBucket)
 
 		id := uniqueBucket.Get([]byte("Jake"))
 		i, err := toBytes(10, json.Codec)
-		assert.NoError(t, err)
-		assert.Equal(t, i, id)
+		require.NoError(t, err)
+		require.Equal(t, i, id)
 
 		id = uniqueBucket.Get([]byte("John"))
-		assert.Nil(t, id)
+		require.Nil(t, id)
 		return nil
 	})
 }
@@ -229,15 +228,15 @@ func TestSaveIndex(t *testing.T) {
 
 	u1 := IndexedNameUser{ID: 10, Name: "John", age: 10}
 	err := db.Save(&u1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	u1 = IndexedNameUser{ID: 10, Name: "John", age: 10}
 	err = db.Save(&u1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	u2 := IndexedNameUser{ID: 11, Name: "John", age: 100}
 	err = db.Save(&u2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	name1 := "Jake"
 	name2 := "Jane"
@@ -257,20 +256,20 @@ func TestSaveIndex(t *testing.T) {
 
 	var users []IndexedNameUser
 	err = db.Find("Name", name1, &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 50)
+	require.NoError(t, err)
+	require.Len(t, users, 50)
 
 	err = db.Find("Name", name2, &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 50)
+	require.NoError(t, err)
+	require.Len(t, users, 50)
 
 	err = db.Find("Name", name3, &users)
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotFound, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.Save(nil)
-	assert.Error(t, err)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 }
 
 func TestSaveEmptyValues(t *testing.T) {
@@ -281,36 +280,36 @@ func TestSaveEmptyValues(t *testing.T) {
 		ID: 10,
 	}
 	err := db.Save(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var v User
 	err = db.One("ID", 10, &v)
-	assert.NoError(t, err)
-	assert.Equal(t, 10, v.ID)
+	require.NoError(t, err)
+	require.Equal(t, 10, v.ID)
 
 	u.Name = "John"
 	u.Slug = "john"
 	err = db.Save(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "John", &v)
-	assert.NoError(t, err)
-	assert.Equal(t, "John", v.Name)
-	assert.Equal(t, "john", v.Slug)
+	require.NoError(t, err)
+	require.Equal(t, "John", v.Name)
+	require.Equal(t, "john", v.Slug)
 	err = db.One("Slug", "john", &v)
-	assert.NoError(t, err)
-	assert.Equal(t, "John", v.Name)
-	assert.Equal(t, "john", v.Slug)
+	require.NoError(t, err)
+	require.Equal(t, "John", v.Name)
+	require.Equal(t, "john", v.Slug)
 
 	u.Name = ""
 	u.Slug = ""
 	err = db.Save(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "John", &v)
-	assert.Error(t, err)
+	require.Error(t, err)
 	err = db.One("Slug", "john", &v)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestSaveAutoIncrement(t *testing.T) {
@@ -320,32 +319,32 @@ func TestSaveAutoIncrement(t *testing.T) {
 	for i := 1; i < 10; i++ {
 		s := SimpleUser{Name: "John"}
 		err := db.Save(&s)
-		assert.NoError(t, err)
-		assert.Equal(t, i, s.ID)
+		require.NoError(t, err)
+		require.Equal(t, i, s.ID)
 	}
 
 	u := UserWithUint64IDField{Name: "John"}
 	err := db.Save(&u)
-	assert.NoError(t, err)
-	assert.Equal(t, uint64(1), u.ID)
+	require.NoError(t, err)
+	require.Equal(t, uint64(1), u.ID)
 	v := UserWithUint64IDField{}
 	err = db.One("ID", uint64(1), &v)
-	assert.NoError(t, err)
-	assert.Equal(t, u, v)
+	require.NoError(t, err)
+	require.Equal(t, u, v)
 
 	ui := UserWithIDField{Name: "John"}
 	err = db.Save(&ui)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, ui.ID)
+	require.NoError(t, err)
+	require.Equal(t, 1, ui.ID)
 	vi := UserWithIDField{}
 	err = db.One("ID", 1, &vi)
-	assert.NoError(t, err)
-	assert.Equal(t, ui, vi)
+	require.NoError(t, err)
+	require.Equal(t, ui, vi)
 
 	us := UserWithStringIDField{Name: "John"}
 	err = db.Save(&us)
-	assert.Error(t, err)
-	assert.Equal(t, ErrZeroID, err)
+	require.Error(t, err)
+	require.Equal(t, ErrZeroID, err)
 }
 
 func TestSaveIncrement(t *testing.T) {
@@ -361,10 +360,10 @@ func TestSaveIncrement(t *testing.T) {
 	for i := 1; i < 10; i++ {
 		s1 := User{Name: fmt.Sprintf("John%d", i)}
 		err := db.Save(&s1)
-		assert.NoError(t, err)
-		assert.Equal(t, i, s1.Identifier)
-		assert.Equal(t, i-1+18, s1.Age)
-		assert.Equal(t, fmt.Sprintf("John%d", i), s1.Name)
+		require.NoError(t, err)
+		require.Equal(t, i, s1.Identifier)
+		require.Equal(t, i-1+18, s1.Age)
+		require.Equal(t, fmt.Sprintf("John%d", i), s1.Name)
 
 		var s2 User
 		err = db.One("Identifier", i, &s2)
@@ -383,17 +382,17 @@ func TestSaveDifferentBucketRoot(t *testing.T) {
 	db, cleanup := createDB(t)
 	defer cleanup()
 
-	assert.Len(t, db.rootBucket, 0)
+	require.Len(t, db.rootBucket, 0)
 
 	dbSub := db.From("sub").(*node)
 
-	assert.NotEqual(t, dbSub, db)
-	assert.Len(t, dbSub.rootBucket, 1)
+	require.NotEqual(t, dbSub, db)
+	require.Len(t, dbSub.rootBucket, 1)
 
 	err := db.Save(&User{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = dbSub.Save(&User{ID: 11, Name: "Paul"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var (
 		john User
@@ -401,14 +400,14 @@ func TestSaveDifferentBucketRoot(t *testing.T) {
 	)
 
 	err = db.One("Name", "John", &john)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.One("Name", "Paul", &paul)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = dbSub.One("Name", "Paul", &paul)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = dbSub.One("Name", "John", &john)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestSaveEmbedded(t *testing.T) {
@@ -438,8 +437,8 @@ func TestSaveEmbedded(t *testing.T) {
 	}
 
 	err := db.Save(&user)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, user.ID)
+	require.NoError(t, err)
+	require.Equal(t, 1, user.ID)
 }
 
 func TestSaveByValue(t *testing.T) {
@@ -448,8 +447,8 @@ func TestSaveByValue(t *testing.T) {
 
 	w := User{Name: "John"}
 	err := db.Save(w)
-	assert.Error(t, err)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Error(t, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 }
 
 func TestSaveWithBatch(t *testing.T) {
@@ -463,7 +462,7 @@ func TestSaveWithBatch(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			err := db.Save(&User{ID: i + 1, Name: "John"})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}()
 	}
 
@@ -498,41 +497,41 @@ func TestUpdate(t *testing.T) {
 	var u User
 
 	err := db.Save(&User{ID: 10, Name: "John", Age: 5, Group: "Staff", Slug: "john"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// nil
 	err = db.Update(nil)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	// no id
 	err = db.Update(&User{Name: "Jack"})
-	assert.Equal(t, ErrNoID, err)
+	require.Equal(t, ErrNoID, err)
 
 	// Unknown user
 	err = db.Update(&User{ID: 11, Name: "Jack"})
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	// actual user
 	err = db.Update(&User{ID: 10, Name: "Jack"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "John", &u)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.One("Name", "Jack", &u)
-	assert.NoError(t, err)
-	assert.Equal(t, "Jack", u.Name)
-	assert.Equal(t, uint64(5), u.Age)
+	require.NoError(t, err)
+	require.Equal(t, "Jack", u.Name)
+	require.Equal(t, uint64(5), u.Age)
 
 	// indexed field with zero value #170
 	err = db.Update(&User{ID: 10, Group: "Staff"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "Jack", &u)
-	assert.NoError(t, err)
-	assert.Equal(t, "Jack", u.Name)
-	assert.Equal(t, uint64(5), u.Age)
-	assert.Equal(t, "Staff", u.Group)
+	require.NoError(t, err)
+	require.Equal(t, "Jack", u.Name)
+	require.Equal(t, uint64(5), u.Age)
+	require.Equal(t, "Staff", u.Group)
 }
 
 func TestUpdateField(t *testing.T) {
@@ -551,59 +550,59 @@ func TestUpdateField(t *testing.T) {
 	var u User
 
 	err := db.Save(&User{ID: 10, Name: "John", Age: 5, Group: "Staff", Slug: "john"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// nil
 	err = db.UpdateField(nil, "", nil)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	// no id
 	err = db.UpdateField(&User{}, "Name", "Jack")
-	assert.Equal(t, ErrNoID, err)
+	require.Equal(t, ErrNoID, err)
 
 	// Unknown user
 	err = db.UpdateField(&User{ID: 11}, "Name", "Jack")
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	// Unknown field
 	err = db.UpdateField(&User{ID: 11}, "Address", "Jack")
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	// Incompatible value
 	err = db.UpdateField(&User{ID: 10}, "Name", 50)
-	assert.Equal(t, ErrIncompatibleValue, err)
+	require.Equal(t, ErrIncompatibleValue, err)
 
 	// actual user
 	err = db.UpdateField(&User{ID: 10}, "Name", "Jack")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "John", &u)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.One("Name", "Jack", &u)
-	assert.NoError(t, err)
-	assert.Equal(t, "Jack", u.Name)
+	require.NoError(t, err)
+	require.Equal(t, "Jack", u.Name)
 
 	// zero value
 	err = db.UpdateField(&User{ID: 10}, "Name", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("Name", "Jack", &u)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.One("ID", 10, &u)
-	assert.NoError(t, err)
-	assert.Equal(t, "", u.Name)
+	require.NoError(t, err)
+	require.Equal(t, "", u.Name)
 
 	// zero value with int and increment
 	err = db.UpdateField(&User{ID: 10}, "Age", uint64(0))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.Select(q.Eq("Age", uint64(5))).First(&u)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	err = db.Select(q.Eq("Age", uint64(0))).First(&u)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestDropByString(t *testing.T) {
@@ -612,29 +611,29 @@ func TestDropByString(t *testing.T) {
 
 	n := db.From("b1", "b2", "b3")
 	err := n.Save(&SimpleUser{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.From("b1").Drop("b2")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.From("b1").Drop("b2")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	n.From("b4").Drop("b5")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = db.Drop("b1")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db.Bolt.Update(func(tx *bolt.Tx) error {
-		assert.Nil(t, db.From().GetBucket(tx, "b1"))
+		require.Nil(t, db.From().GetBucket(tx, "b1"))
 		d := db.WithTransaction(tx)
 		n := d.From("a1")
 		err = n.Save(&SimpleUser{ID: 10, Name: "John"})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = d.Drop("a1")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		return nil
 	})
@@ -646,22 +645,22 @@ func TestDropByStruct(t *testing.T) {
 
 	n := db.From("b1", "b2", "b3")
 	err := n.Save(&SimpleUser{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = n.Drop(&SimpleUser{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db.Bolt.Update(func(tx *bolt.Tx) error {
-		assert.Nil(t, n.GetBucket(tx, "SimpleUser"))
+		require.Nil(t, n.GetBucket(tx, "SimpleUser"))
 		d := db.WithTransaction(tx)
 		n := d.From("a1")
 		err = n.Save(&SimpleUser{ID: 10, Name: "John"})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		err = n.Drop(&SimpleUser{})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
-		assert.Nil(t, n.GetBucket(tx, "SimpleUser"))
+		require.Nil(t, n.GetBucket(tx, "SimpleUser"))
 		return nil
 	})
 }
@@ -672,40 +671,40 @@ func TestDeleteStruct(t *testing.T) {
 
 	u1 := IndexedNameUser{ID: 10, Name: "John", age: 10}
 	err := db.Save(&u1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.DeleteStruct(u1)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	err = db.DeleteStruct(&u1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.DeleteStruct(&u1)
-	assert.Equal(t, ErrNotFound, err)
+	require.Equal(t, ErrNotFound, err)
 
 	u2 := IndexedNameUser{}
 	err = db.Get("IndexedNameUser", 10, &u2)
-	assert.True(t, ErrNotFound == err)
+	require.True(t, ErrNotFound == err)
 
 	err = db.DeleteStruct(nil)
-	assert.Equal(t, ErrStructPtrNeeded, err)
+	require.Equal(t, ErrStructPtrNeeded, err)
 
 	var users []User
 	for i := 0; i < 10; i++ {
 		user := User{Name: "John", ID: i + 1, Slug: fmt.Sprintf("John%d", i+1), DateOfBirth: time.Now().Add(-time.Duration(i*10) * time.Minute)}
 		err = db.Save(&user)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		users = append(users, user)
 	}
 
 	err = db.DeleteStruct(&users[0])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = db.DeleteStruct(&users[1])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	users = nil
 	err = db.All(&users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 8)
-	assert.Equal(t, 3, users[0].ID)
+	require.NoError(t, err)
+	require.Len(t, users, 8)
+	require.Equal(t, 3, users[0].ID)
 }
diff --git a/storm_test.go b/storm_test.go
index 7ab5be5..c2948d1 100644
--- a/storm_test.go
+++ b/storm_test.go
@@ -13,35 +13,34 @@ import (
 
 	"github.com/asdine/storm/codec/json"
 	"github.com/boltdb/bolt"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestNewStorm(t *testing.T) {
 	db, err := Open("")
 
-	assert.Error(t, err)
-	assert.Nil(t, db)
+	require.Error(t, err)
+	require.Nil(t, db)
 
 	dir, err := ioutil.TempDir(os.TempDir(), "storm")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(dir)
 
 	file := filepath.Join(dir, "storm.db")
 	db, err = Open(file)
 	defer db.Close()
 
-	assert.Implements(t, (*Node)(nil), db)
+	require.Implements(t, (*Node)(nil), db)
 
-	assert.NoError(t, err)
-	assert.Equal(t, file, db.Path)
-	assert.NotNil(t, db.Bolt)
-	assert.Equal(t, defaultCodec, db.Codec())
+	require.NoError(t, err)
+	require.Equal(t, file, db.Path)
+	require.NotNil(t, db.Bolt)
+	require.Equal(t, defaultCodec, db.Codec())
 
 	var v string
 	err = db.Get(dbinfo, "version", &v)
-	assert.NoError(t, err)
-	assert.Equal(t, Version, v)
+	require.NoError(t, err)
+	require.Equal(t, Version, v)
 }
 
 func TestNewStormWithStormOptions(t *testing.T) {
@@ -50,18 +49,18 @@ func TestNewStormWithStormOptions(t *testing.T) {
 
 	dc := new(dummyCodec)
 	db1, _ := Open(filepath.Join(dir, "storm1.db"), BoltOptions(0660, &bolt.Options{Timeout: 10 * time.Second}), Codec(dc), AutoIncrement(), Root("a", "b"))
-	assert.Equal(t, dc, db1.Codec())
-	assert.True(t, db1.autoIncrement)
-	assert.Equal(t, os.FileMode(0660), db1.boltMode)
-	assert.Equal(t, 10*time.Second, db1.boltOptions.Timeout)
-	assert.Equal(t, []string{"a", "b"}, db1.rootBucket)
-	assert.Equal(t, []string{"a", "b"}, db1.root.rootBucket)
+	require.Equal(t, dc, db1.Codec())
+	require.True(t, db1.autoIncrement)
+	require.Equal(t, os.FileMode(0660), db1.boltMode)
+	require.Equal(t, 10*time.Second, db1.boltOptions.Timeout)
+	require.Equal(t, []string{"a", "b"}, db1.rootBucket)
+	require.Equal(t, []string{"a", "b"}, db1.root.rootBucket)
 
 	err := db1.Save(&SimpleUser{ID: 1})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	db2, _ := Open(filepath.Join(dir, "storm2.db"), Codec(dc))
-	assert.Equal(t, dc, db2.Codec())
+	require.Equal(t, dc, db2.Codec())
 }
 
 func TestNewStormWithBatch(t *testing.T) {
@@ -71,30 +70,30 @@ func TestNewStormWithBatch(t *testing.T) {
 	db1, _ := Open(filepath.Join(dir, "storm1.db"), Batch())
 	defer db1.Close()
 
-	assert.True(t, db1.root.batchMode)
+	require.True(t, db1.root.batchMode)
 	n := db1.From().(*node)
-	assert.True(t, n.batchMode)
+	require.True(t, n.batchMode)
 	n = db1.WithBatch(true).(*node)
-	assert.True(t, n.batchMode)
+	require.True(t, n.batchMode)
 	n = db1.WithBatch(false).(*node)
-	assert.False(t, n.batchMode)
+	require.False(t, n.batchMode)
 	n = n.From().(*node)
-	assert.False(t, n.batchMode)
+	require.False(t, n.batchMode)
 	n = n.WithBatch(true).(*node)
-	assert.True(t, n.batchMode)
+	require.True(t, n.batchMode)
 }
 
 func TestBoltDB(t *testing.T) {
 	dir, _ := ioutil.TempDir(os.TempDir(), "storm")
 	defer os.RemoveAll(dir)
 	bDB, err := bolt.Open(filepath.Join(dir, "bolt.db"), 0600, &bolt.Options{Timeout: 10 * time.Second})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// no need to close bolt.DB Storm will take care of it
 	sDB, err := Open("my.db", UseDB(bDB))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer sDB.Close()
 	err = sDB.Save(&SimpleUser{ID: 10})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 type dummyCodec int
@@ -114,10 +113,10 @@ func (c dummyCodec) Name() string {
 func TestCodec(t *testing.T) {
 	u1 := &SimpleUser{Name: "John"}
 	encoded, err := defaultCodec.Marshal(u1)
-	assert.Nil(t, err)
+	require.Nil(t, err)
 	u2 := &SimpleUser{}
 	err = defaultCodec.Unmarshal(encoded, u2)
-	assert.Nil(t, err)
+	require.Nil(t, err)
 	if !reflect.DeepEqual(u1, u2) {
 		t.Fatal("Codec mismatch")
 	}
@@ -125,16 +124,16 @@ func TestCodec(t *testing.T) {
 
 func TestToBytes(t *testing.T) {
 	b, err := toBytes([]byte("a slice of bytes"), nil)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("a slice of bytes"), b)
+	require.NoError(t, err)
+	require.Equal(t, []byte("a slice of bytes"), b)
 
 	b, err = toBytes("a string", nil)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("a string"), b)
+	require.NoError(t, err)
+	require.Equal(t, []byte("a string"), b)
 
 	b, err = toBytes(&SimpleUser{ID: 10, Name: "John", age: 100}, json.Codec)
-	assert.NoError(t, err)
-	assert.Equal(t, `{"ID":10,"Name":"John"}`, string(b))
+	require.NoError(t, err)
+	require.Equal(t, `{"ID":10,"Name":"John"}`, string(b))
 
 	tests := map[interface{}]interface{}{
 		int(-math.MaxInt64):    int64(-math.MaxInt64),
diff --git a/transaction_test.go b/transaction_test.go
index d768d46..4f3e490 100644
--- a/transaction_test.go
+++ b/transaction_test.go
@@ -3,7 +3,7 @@ package storm
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestTransaction(t *testing.T) {
@@ -11,77 +11,77 @@ func TestTransaction(t *testing.T) {
 	defer cleanup()
 
 	err := db.Rollback()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = db.Commit()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	tx, err := db.Begin(true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ntx, ok := tx.(*node)
-	assert.True(t, ok)
-	assert.NotNil(t, ntx.tx)
+	require.True(t, ok)
+	require.NotNil(t, ntx.tx)
 
 	err = tx.Init(&SimpleUser{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Save(&User{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Save(&User{ID: 20, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Save(&User{ID: 30, Name: "Steve"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var user User
 	err = tx.One("ID", 10, &user)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var users []User
 	err = tx.AllByIndex("Name", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 3)
+	require.NoError(t, err)
+	require.Len(t, users, 3)
 
 	err = tx.All(&users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 3)
+	require.NoError(t, err)
+	require.Len(t, users, 3)
 
 	err = tx.Find("Name", "Steve", &users)
-	assert.NoError(t, err)
-	assert.Len(t, users, 1)
+	require.NoError(t, err)
+	require.Len(t, users, 1)
 
 	err = tx.DeleteStruct(&user)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.One("ID", 10, &user)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tx.Set("b1", "best friend's mail", "mail@provider.com")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var str string
 	err = tx.Get("b1", "best friend's mail", &str)
-	assert.NoError(t, err)
-	assert.Equal(t, "mail@provider.com", str)
+	require.NoError(t, err)
+	require.Equal(t, "mail@provider.com", str)
 
 	err = tx.Delete("b1", "best friend's mail")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Get("b1", "best friend's mail", &str)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tx.Commit()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Commit()
-	assert.Error(t, err)
-	assert.Equal(t, ErrNotInTransaction, err)
+	require.Error(t, err)
+	require.Equal(t, ErrNotInTransaction, err)
 
 	err = db.One("ID", 30, &user)
-	assert.NoError(t, err)
-	assert.Equal(t, 30, user.ID)
+	require.NoError(t, err)
+	require.Equal(t, 30, user.ID)
 }
 
 func TestTransactionRollback(t *testing.T) {
@@ -89,21 +89,21 @@ func TestTransactionRollback(t *testing.T) {
 	defer cleanup()
 
 	tx, err := db.Begin(true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Save(&User{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var user User
 	err = tx.One("ID", 10, &user)
-	assert.NoError(t, err)
-	assert.Equal(t, 10, user.ID)
+	require.NoError(t, err)
+	require.Equal(t, 10, user.ID)
 
 	err = tx.Rollback()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = db.One("ID", 10, &user)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestTransactionNotWritable(t *testing.T) {
@@ -111,18 +111,18 @@ func TestTransactionNotWritable(t *testing.T) {
 	defer cleanup()
 
 	err := db.Save(&User{ID: 10, Name: "John"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	tx, err := db.Begin(false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Save(&User{ID: 20, Name: "John"})
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	var user User
 	err = tx.One("ID", 10, &user)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tx.Rollback()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }