2018-03-17 11:53:21 +00:00
|
|
|
package storage
|
|
|
|
|
|
|
|
import (
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/stretchr/testify/assert"
|
2019-09-16 15:52:47 +00:00
|
|
|
"github.com/stretchr/testify/require"
|
2018-03-17 11:53:21 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
func TestGetPut(t *testing.T) {
|
|
|
|
var (
|
|
|
|
s = NewMemoryStore()
|
|
|
|
key = []byte("sparse")
|
|
|
|
value = []byte("rocks")
|
|
|
|
)
|
|
|
|
|
2019-01-25 11:20:35 +00:00
|
|
|
if err := s.Put(key, value); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2018-03-17 11:53:21 +00:00
|
|
|
|
|
|
|
newVal, err := s.Get(key)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
assert.Equal(t, value, newVal)
|
2019-09-16 15:52:47 +00:00
|
|
|
require.NoError(t, s.Close())
|
2018-03-17 11:53:21 +00:00
|
|
|
}
|
|
|
|
|
2018-03-21 16:11:04 +00:00
|
|
|
func TestKeyNotExist(t *testing.T) {
|
|
|
|
var (
|
|
|
|
s = NewMemoryStore()
|
|
|
|
key = []byte("sparse")
|
|
|
|
)
|
|
|
|
|
|
|
|
_, err := s.Get(key)
|
|
|
|
assert.NotNil(t, err)
|
|
|
|
assert.Equal(t, err.Error(), "key not found")
|
2019-09-16 15:52:47 +00:00
|
|
|
require.NoError(t, s.Close())
|
2018-03-21 16:11:04 +00:00
|
|
|
}
|
|
|
|
|
2018-03-17 11:53:21 +00:00
|
|
|
func TestPutBatch(t *testing.T) {
|
|
|
|
var (
|
|
|
|
s = NewMemoryStore()
|
|
|
|
key = []byte("sparse")
|
|
|
|
value = []byte("rocks")
|
|
|
|
batch = s.Batch()
|
|
|
|
)
|
|
|
|
|
|
|
|
batch.Put(key, value)
|
|
|
|
|
2019-01-25 11:20:35 +00:00
|
|
|
if err := s.PutBatch(batch); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2018-03-17 11:53:21 +00:00
|
|
|
newVal, err := s.Get(key)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
assert.Equal(t, value, newVal)
|
2019-09-16 15:52:47 +00:00
|
|
|
require.NoError(t, s.Close())
|
2018-03-17 11:53:21 +00:00
|
|
|
}
|
2019-09-18 15:20:41 +00:00
|
|
|
|
|
|
|
func TestMemoryStore_Seek(t *testing.T) {
|
|
|
|
var (
|
|
|
|
s = NewMemoryStore()
|
|
|
|
key = []byte("sparse")
|
|
|
|
value = []byte("rocks")
|
|
|
|
)
|
|
|
|
|
|
|
|
if err := s.Put(key, value); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
s.Seek(key, func(k, v []byte) {
|
|
|
|
assert.Equal(t, value, v)
|
|
|
|
})
|
|
|
|
}
|
2019-09-26 15:14:00 +00:00
|
|
|
|
|
|
|
func TestMemoryStorePersist(t *testing.T) {
|
|
|
|
// temporary Store
|
|
|
|
ts := NewMemoryStore()
|
|
|
|
// persistent Store
|
|
|
|
ps := NewMemoryStore()
|
|
|
|
// persisting nothing should do nothing
|
|
|
|
c, err := ts.Persist(ps)
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, 0, c)
|
|
|
|
// persisting one key should result in one key in ps and nothing in ts
|
|
|
|
assert.NoError(t, ts.Put([]byte("key"), []byte("value")))
|
|
|
|
c, err = ts.Persist(ps)
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, 1, c)
|
|
|
|
v, err := ps.Get([]byte("key"))
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, []byte("value"), v)
|
|
|
|
v, err = ts.Get([]byte("key"))
|
|
|
|
assert.Equal(t, ErrKeyNotFound, err)
|
|
|
|
assert.Equal(t, []byte(nil), v)
|
|
|
|
// now we overwrite the previous `key` contents and also add `key2`,
|
|
|
|
assert.NoError(t, ts.Put([]byte("key"), []byte("newvalue")))
|
|
|
|
assert.NoError(t, ts.Put([]byte("key2"), []byte("value2")))
|
|
|
|
// this is to check that now key is written into the ps before we do
|
|
|
|
// persist
|
|
|
|
v, err = ps.Get([]byte("key2"))
|
|
|
|
assert.Equal(t, ErrKeyNotFound, err)
|
|
|
|
assert.Equal(t, []byte(nil), v)
|
|
|
|
// two keys should be persisted (one overwritten and one new) and
|
|
|
|
// available in the ps
|
|
|
|
c, err = ts.Persist(ps)
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, 2, c)
|
|
|
|
v, err = ts.Get([]byte("key"))
|
|
|
|
assert.Equal(t, ErrKeyNotFound, err)
|
|
|
|
assert.Equal(t, []byte(nil), v)
|
|
|
|
v, err = ts.Get([]byte("key2"))
|
|
|
|
assert.Equal(t, ErrKeyNotFound, err)
|
|
|
|
assert.Equal(t, []byte(nil), v)
|
|
|
|
v, err = ps.Get([]byte("key"))
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, []byte("newvalue"), v)
|
|
|
|
v, err = ps.Get([]byte("key2"))
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, []byte("value2"), v)
|
|
|
|
// we've persisted some values, make sure successive persist is a no-op
|
|
|
|
c, err = ts.Persist(ps)
|
|
|
|
assert.Equal(t, nil, err)
|
|
|
|
assert.Equal(t, 0, c)
|
|
|
|
}
|