func TestS3Store(t *testing.T) {
var store chainstore.Store
var err error
ctx := context.Background()
assert := assert.New(t)
store = chainstore.New(New(bucketID, accessKey, secretKey))
err = store.Open()
assert.Nil(err)
defer store.Close()
// Put a bunch of objects
e1 := store.Put(ctx, "hi", []byte{1, 2, 3})
e2 := store.Put(ctx, "bye", []byte{4, 5, 6})
assert.Nil(e1)
assert.Nil(e2)
// Get those objects
v1, _ := store.Get(ctx, "hi")
v2, _ := store.Get(ctx, "bye")
assert.Equal(v1, []byte{1, 2, 3})
assert.Equal(v2, []byte{4, 5, 6})
// Delete those objects
e1 = store.Del(ctx, "hi")
e2 = store.Del(ctx, "bye")
assert.Equal(e1, nil)
assert.Equal(e2, nil)
}
func TestMetricsMgrStore(t *testing.T) {
var store chainstore.Store
var err error
ctx := context.Background()
assert := assert.New(t)
store = chainstore.New(New("ns"))
err = store.Open()
assert.Nil(err)
defer store.Close()
// Put a bunch of objects
e1 := store.Put(ctx, "hi", []byte{1, 2, 3})
e2 := store.Put(ctx, "bye", []byte{4, 5, 6})
assert.Nil(e1)
assert.Nil(e2)
// Delete those objects
e1 = store.Del(ctx, "hi")
e2 = store.Del(ctx, "bye")
assert.Equal(e1, nil)
assert.Equal(e2, nil)
}
func TestBasicChain(t *testing.T) {
var ms, fs, chain chainstore.Store
var err error
ctx := context.Background()
logger := log.New(os.Stdout, "", log.LstdFlags)
storeDir := tempDir()
err = nil
ms = memstore.New(100)
fs = filestore.New(storeDir+"/filestore", 0755)
chain = chainstore.New(
logmgr.New(logger, ""),
ms,
fs,
)
assert := assert.New(t)
err = chain.Open()
assert.Nil(err)
v := []byte("value")
err = chain.Put(ctx, "k", v)
assert.Nil(err)
val, err := chain.Get(ctx, "k")
assert.Nil(err)
assert.Equal(val, v)
val, err = ms.Get(ctx, "k")
assert.Nil(err)
assert.Equal(val, v)
val, err = fs.Get(ctx, "k")
assert.Nil(err)
assert.Equal(val, v)
err = chain.Del(ctx, "k")
assert.Nil(err)
val, err = fs.Get(ctx, "k")
assert.Nil(err)
assert.Equal(len(val), 0)
val, err = chain.Get(ctx, "woo!@#")
assert.NotNil(err)
}
func TestBasicChain(t *testing.T) {
var ms, fs, chain chainstore.Store
var err error
logger := log.New(os.Stdout, "", log.LstdFlags)
Convey("Basic chain", t, func() {
storeDir := chainstore.TempDir()
err = nil
ms = memstore.New(100)
fs = filestore.New(storeDir+"/filestore", 0755)
chain = chainstore.New(
logmgr.New(logger, ""),
ms,
fs,
)
err = chain.Open()
So(err, ShouldEqual, nil)
Convey("Put/Get/Del", func() {
v := []byte("value")
err = chain.Put("k", v)
So(err, ShouldEqual, nil)
val, err := chain.Get("k")
So(err, ShouldEqual, nil)
So(v, ShouldResemble, v)
val, err = ms.Get("k")
So(err, ShouldEqual, nil)
So(val, ShouldResemble, v)
val, err = fs.Get("k")
So(err, ShouldEqual, nil)
So(val, ShouldResemble, v)
err = chain.Del("k")
So(err, ShouldEqual, nil)
val, err = fs.Get("k")
So(err, ShouldEqual, nil)
So(len(val), ShouldEqual, 0)
val, err = chain.Get("woo!@#")
So(err, ShouldNotBeNil)
})
})
}
// TestMockStoreCancelWithFunc creates and test a mockstore that succeeds at
// first but then is cancelled.
func TestMockStoreCancelWithFunc(t *testing.T) {
var store chainstore.Store
var err error
ctx, cancel := context.WithCancel(context.Background())
store = chainstore.New(New(&Config{
Capacity: 100,
SuccessRate: 1.0, // always succeeds.
Delay: time.Second * 1, // any operation takes 1s.
}))
go func() {
time.Sleep(time.Millisecond * 1500)
cancel()
}()
assert := assert.New(t)
// This is going to succeed.
err = store.Put(ctx, "notnil", []byte("something"))
assert.Nil(err)
// This will fail because after 1.5s the context will send a cancellation signal.
err = store.Put(ctx, "hi", []byte{1, 2, 3})
assert.NotNil(err)
_, err = store.Get(ctx, "hi")
assert.NotNil(err)
err = store.Put(ctx, "bye", []byte{5, 6, 7, 8, 9, 10, 11, 12})
assert.NotNil(err)
err = store.Del(ctx, "hi")
assert.NotNil(err)
_, err = store.Get(ctx, "hi")
assert.NotNil(err)
_, err = store.Get(ctx, "bye")
assert.NotNil(err)
_, err = store.Get(ctx, "notnil")
assert.NotNil(err)
}
// TestMockStoreSuccess creates and test a mockstore that always succeeds.
func TestMockStoreSuccess(t *testing.T) {
var store chainstore.Store
var err error
var obj []byte
ctx := context.Background()
store = chainstore.New(New(&Config{
Capacity: 100,
SuccessRate: 1.0, // always succeeds.
}))
assert := assert.New(t)
err = store.Put(ctx, "notnil", []byte("something"))
assert.Nil(err)
err = store.Put(ctx, "hi", []byte{1, 2, 3})
assert.Nil(err)
obj, err = store.Get(ctx, "hi")
assert.Nil(err)
assert.Equal(obj, []byte{1, 2, 3})
err = store.Put(ctx, "bye", []byte{5, 6, 7, 8, 9, 10, 11, 12})
assert.Nil(err)
err = store.Del(ctx, "hi")
assert.Nil(err)
obj, err = store.Get(ctx, "hi")
assert.NotNil(err)
assert.Equal(len(obj), 0)
obj, err = store.Get(ctx, "bye")
assert.Nil(err)
assert.Equal(len(obj), 8)
obj, err = store.Get(ctx, "notnil")
assert.Nil(err)
assert.Equal(len(obj), 9)
}
// TestMockStoreCancelWithTimeout creates and test a mockstore with that after
// a while gets cancelled.
func TestMockStoreCancelWithTimeout(t *testing.T) {
var store chainstore.Store
var err error
assert := assert.New(t)
store = chainstore.New(New(&Config{
Capacity: 100,
SuccessRate: 1.0, // always succeeds.
Delay: time.Second * 1, // any operation takes 1s.
}))
ctx, _ := context.WithTimeout(context.Background(), time.Millisecond*500)
// After 0.5s this all is going to fail, because the context timed out.
err = store.Put(ctx, "notnil", []byte("something"))
assert.NotNil(err)
err = store.Put(ctx, "hi", []byte{1, 2, 3})
assert.NotNil(err)
_, err = store.Get(ctx, "hi")
assert.NotNil(err)
err = store.Put(ctx, "bye", []byte{5, 6, 7, 8, 9, 10, 11, 12})
assert.NotNil(err)
err = store.Del(ctx, "hi")
assert.NotNil(err)
_, err = store.Get(ctx, "hi")
assert.NotNil(err)
_, err = store.Get(ctx, "bye")
assert.NotNil(err)
_, err = store.Get(ctx, "notnil")
assert.NotNil(err)
}
func TestBoltStore(t *testing.T) {
var store chainstore.Store
var err error
store = boltstore.New(chainstore.TempDir()+"/test.db", "test")
err = store.Open()
if err != nil {
t.Error(err)
}
defer store.Close() // does this get called?
Convey("Boltdb Open", t, func() {
Convey("Put a bunch of objects", func() {
e1 := store.Put("hi", []byte{1, 2, 3})
e2 := store.Put("bye", []byte{4, 5, 6})
So(e1, ShouldEqual, nil)
So(e2, ShouldEqual, nil)
})
Convey("Get those objects", func() {
v1, _ := store.Get("hi")
v2, _ := store.Get("bye")
So(v1, ShouldResemble, []byte{1, 2, 3})
So(v2, ShouldResemble, []byte{4, 5, 6})
})
Convey("Delete those objects", func() {
e1 := store.Del("hi")
e2 := store.Del("bye")
So(e1, ShouldEqual, nil)
So(e2, ShouldEqual, nil)
v, _ := store.Get("hi")
So(len(v), ShouldEqual, 0)
})
})
}
func TestBoltStore(t *testing.T) {
var store chainstore.Store
var err error
ctx := context.Background()
store = chainstore.New(New(tempDir()+"/test.db", "test"))
assert := assert.New(t)
err = store.Open()
assert.Nil(err)
defer store.Close() // does this get called?
// Put a bunch of objects
e1 := store.Put(ctx, "hi", []byte{1, 2, 3})
e2 := store.Put(ctx, "bye", []byte{4, 5, 6})
assert.Equal(e1, nil)
assert.Equal(e2, nil)
// Get those objects
v1, _ := store.Get(ctx, "hi")
v2, _ := store.Get(ctx, "bye")
assert.Equal(v1, []byte{1, 2, 3})
assert.Equal(v2, []byte{4, 5, 6})
// Delete those objects
e1 = store.Del(ctx, "hi")
e2 = store.Del(ctx, "bye")
assert.Equal(e1, nil)
assert.Equal(e2, nil)
v, _ := store.Get(ctx, "hi")
assert.Equal(len(v), 0)
}
func TestLevelStore(t *testing.T) {
var store chainstore.Store
var err error
store = levelstore.New(chainstore.TempDir())
err = store.Open()
if err != nil {
t.Error(err)
}
defer store.Close()
Convey("Leveldb Open", t, func() {
Convey("Put a bunch of objects", func() {
e1 := store.Put("hi", []byte{1, 2, 3})
e2 := store.Put("bye", []byte{4, 5, 6})
So(e1, ShouldEqual, nil)
So(e2, ShouldEqual, nil)
})
Convey("Get those objects", func() {
v1, _ := store.Get("hi")
v2, _ := store.Get("bye")
So(v1, ShouldResemble, []byte{1, 2, 3})
So(v2, ShouldResemble, []byte{4, 5, 6})
})
Convey("Delete those objects", func() {
e1 := store.Del("hi")
e2 := store.Del("bye")
So(e1, ShouldEqual, nil)
So(e2, ShouldEqual, nil)
})
})
}
