zishuo/storm
1
0
Fork 0
mirror of https://github.com/asdine/storm.git synced 2025-09-26 19:01:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replacing testify/assert by testify/require

Browse Source
This commit is contained in:
Asdine El Hrychy
2017-09-09 11:29:50 +02:00
parent a49d0b2cdc
commit a6718ade82
15 changed files with 997 additions and 1003 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
bucket_test.go
View File

@@ -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

16
codec/protobuf/protobuf_test.go
View File

@@ -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)
}

4
codec/sereal/sereal_test.go
View File

@@ -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)
}

110
extract_test.go
View File

@@ -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)
}

439
finder_test.go
View File

@@ -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)
}

246
index/list_test.go
View File

@@ -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
})

116
index/unique_test.go
View File

@@ -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)
}

77
kv_test.go
View File

@@ -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)
}

34
node_test.go
View File

@@ -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)
}

156
q/tree_test.go
View File

@@ -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)
}

287
query_test.go
View File

@@ -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

29
scan_test.go
View File

@@ -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) {

311
store_test.go
View File

@@ -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)
}

71
storm_test.go
View File

@@ -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),

80
transaction_test.go
View File

@@ -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)
}