Skip to content

Commit

Permalink
Merge pull request #7 from iden3/cleanup_storage_interface
Browse files Browse the repository at this point in the history 
remove useless methods from Storage interface
  • Loading branch information
@olomix
olomix authored Jul 29, 2022
2 parents eb9e071 + d200350 commit a614fbf
Show file tree
Hide file tree
Showing 2 changed files with 0 additions and 244 deletions.
3 changes: 0 additions & 3 deletions db.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,13 +15,10 @@ var ErrNotFound = errors.New("key not found")
// the merkletree. Examples of the interface implementation can be found at
// db/memory and db/leveldb directories.
type Storage interface {
WithPrefix(prefix []byte) Storage
Get(context.Context, []byte) (*Node, error)
Put(ctx context.Context, k []byte, v *Node) error
GetRoot(context.Context) (*Hash, error)
SetRoot(context.Context, *Hash) error
List(context.Context, int) ([]KV, error)
Iterate(context.Context, func([]byte, *Node) (bool, error)) error
}

// KV contains a key (K) and a value (V)
Expand Down
241 changes: 0 additions & 241 deletions db/test/test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,6 @@ import (
"encoding/json"
"fmt"
"math/big"
"sort"
"testing"

"github.com/iden3/go-iden3-crypto/constants"
Expand Down Expand Up @@ -38,15 +37,6 @@ func TestAll(t *testing.T, sb StorageBuilder) {
t.Run("TestStorageInsertGet", func(t *testing.T) {
TestStorageInsertGet(t, sb.NewStorage(t))
})
t.Run("TestStorageWithPrefix", func(t *testing.T) {
TestStorageWithPrefix(t, sb.NewStorage(t))
})
t.Run("TestList", func(t *testing.T) {
TestList(t, sb.NewStorage(t))
})
t.Run("TestIterate", func(t *testing.T) {
TestIterate(t, sb.NewStorage(t))
})
t.Run("TestNewTree", func(t *testing.T) {
TestNewTree(t, sb.NewStorage(t))
})
Expand Down Expand Up @@ -153,237 +143,6 @@ func TestStorageInsertGet(t *testing.T, sto merkletree.Storage) {
assert.Equal(t, value, *v.ChildR)
}

// TestStorageWithPrefix checks that the implementation of the db.Storage
// interface behaves as expected for the WithPrefix method
func TestStorageWithPrefix(t *testing.T, sto merkletree.Storage) {
sto1 := sto.WithPrefix([]byte{1})
sto2 := sto.WithPrefix([]byte{2})

ctx := context.Background()

node := merkletree.NewNodeLeaf(
&merkletree.Hash{1, 2, 3},
&merkletree.Hash{4, 5, 6})
k, err := node.Key()
require.NoError(t, err)
err = sto1.Put(ctx, k[:], node)
assert.NoError(t, err)
v1, err := sto1.Get(ctx, k[:])
assert.NoError(t, err)
assert.Equal(t, merkletree.Hash{4, 5, 6}, *v1.Entry[1])

_, err = sto2.Get(ctx, k[:])
assert.Equal(t, merkletree.ErrNotFound, err)

err = sto2.Put(ctx, k[:], node)
assert.NoError(t, err)
v2, err := sto2.Get(ctx, k[:])
assert.NoError(t, err)
assert.Equal(t, merkletree.Hash{4, 5, 6}, *v2.Entry[1])

v1, err = sto1.Get(ctx, k[:])
assert.NoError(t, err)
require.NotNil(t, v1)
assert.Equal(t, merkletree.Hash{4, 5, 6}, *v1.Entry[1])

v2, err = sto2.Get(ctx, k[:])
assert.NoError(t, err)
require.NotNil(t, v2)
assert.Equal(t, merkletree.Hash{4, 5, 6}, *v2.Entry[1])
}

// TestIterate checks that the implementation of the db.Storage interface
// behaves as expected for the Iterate method
func TestIterate(t *testing.T, sto merkletree.Storage) {
r := []merkletree.KV{}
lister := func(k []byte, v *merkletree.Node) (bool, error) {
r = append(r, merkletree.KV{K: merkletree.Clone(k), V: *v})
return true, nil
}

sto1 := sto.WithPrefix([]byte{1})
ctx := context.Background()
err := sto1.Iterate(ctx, lister)
assert.Nil(t, err)
assert.Equal(t, 0, len(r))

err = sto1.Put(ctx, []byte{1}, merkletree.NewNodeMiddle(&merkletree.Hash{4},
&merkletree.Hash{5}))
assert.Nil(t, err)
err = sto1.Put(ctx, []byte{2}, merkletree.NewNodeMiddle(&merkletree.Hash{5},
&merkletree.Hash{6}))
assert.Nil(t, err)
err = sto1.Put(ctx, []byte{3}, merkletree.NewNodeMiddle(&merkletree.Hash{6},
&merkletree.Hash{7}))
assert.Nil(t, err)

sto2 := sto.WithPrefix([]byte{2})
err = sto2.Put(ctx, []byte{1}, merkletree.NewNodeMiddle(&merkletree.Hash{7},
&merkletree.Hash{8}))
assert.Nil(t, err)
err = sto2.Put(ctx, []byte{2}, merkletree.NewNodeMiddle(&merkletree.Hash{8},
&merkletree.Hash{9}))
assert.Nil(t, err)
err = sto2.Put(ctx, []byte{3}, merkletree.NewNodeMiddle(&merkletree.Hash{9},
&merkletree.Hash{10}))
assert.Nil(t, err)

r = []merkletree.KV{}
err = sto1.Iterate(ctx, lister)
require.Nil(t, err)
assert.Equal(t, 3, len(r))
sort.Slice(r, func(i, j int) bool { return r[i].K[0] < r[j].K[0] })
assert.EqualValues(t,
merkletree.KV{
K: []byte{1},
V: *merkletree.NewNodeMiddle(
&merkletree.Hash{4}, &merkletree.Hash{5})},
r[0])
assert.EqualValues(t,
merkletree.KV{
K: []byte{2},
V: *merkletree.NewNodeMiddle(
&merkletree.Hash{5}, &merkletree.Hash{6})},
r[1])
assert.EqualValues(t,
merkletree.KV{
K: []byte{3},
V: *merkletree.NewNodeMiddle(
&merkletree.Hash{6}, &merkletree.Hash{7})},
r[2])

r = []merkletree.KV{}
err = sto2.Iterate(ctx, lister)
require.Nil(t, err)
sort.Slice(r, func(i, j int) bool { return r[i].K[0] < r[j].K[0] })
assert.Equal(t, 3, len(r))
assert.EqualValues(t,
merkletree.KV{
K: []byte{1},
V: *merkletree.NewNodeMiddle(
&merkletree.Hash{7}, &merkletree.Hash{8})},
r[0])
assert.EqualValues(t,
merkletree.KV{
K: []byte{2},
V: *merkletree.NewNodeMiddle(
&merkletree.Hash{8}, &merkletree.Hash{9})},
r[1])
assert.EqualValues(t,
merkletree.KV{
K: []byte{3},
V: *merkletree.NewNodeMiddle(
&merkletree.Hash{9}, &merkletree.Hash{10})},
r[2])
}

// TestList checks that the implementation of the db.Storage interface behaves
// as expected
func TestList(t *testing.T, sto merkletree.Storage) {
ctx := context.Background()

sto1 := sto.WithPrefix([]byte{1})
r1, err := sto1.List(ctx, 100)
assert.Nil(t, err)
assert.Equal(t, 0, len(r1))

n1 := merkletree.NewNodeMiddle(&merkletree.Hash{4}, &merkletree.Hash{5})
n2 := merkletree.NewNodeMiddle(&merkletree.Hash{5}, &merkletree.Hash{6})
n3 := merkletree.NewNodeMiddle(&merkletree.Hash{6}, &merkletree.Hash{7})
n1k, _ := n1.Key()
n2k, _ := n2.Key()
n3k, _ := n3.Key()
err = sto1.Put(ctx, n1k[:], n1)
assert.Nil(t, err)
err = sto1.Put(ctx, n2k[:], n2)
assert.Nil(t, err)
err = sto1.Put(ctx, n3k[:], n3)
assert.Nil(t, err)

sto2 := sto.WithPrefix([]byte{2})
err = sto2.Put(ctx, n1k[:], n1)
assert.Nil(t, err)
err = sto2.Put(ctx, n2k[:], n2)
assert.Nil(t, err)

// Test that storage with prefix 1 has only 3 records and they are expected ones
r, err := sto1.List(ctx, 100)
require.Nil(t, err)
assert.Equal(t, 3, len(r))
nodeMap := make(merkletree.KvMap)
for _, v := range r {
nodeMap.Put(v.K, v.V)
}
ri1, ok := nodeMap.Get(n1k[:])
require.True(t, ok)
ri2, ok := nodeMap.Get(n2k[:])
require.True(t, ok)
ri3, ok := nodeMap.Get(n3k[:])
require.True(t, ok)

assert.Equal(t, merkletree.Hash{4}, *ri1.ChildL)
assert.Equal(t, merkletree.Hash{5}, *ri1.ChildR)
assert.Equal(t, merkletree.NodeTypeMiddle, ri1.Type)
k1, _ := ri1.Key()
assert.Equal(t, n1k, k1)

assert.Equal(t, merkletree.Hash{5}, *ri2.ChildL)
assert.Equal(t, merkletree.Hash{6}, *ri2.ChildR)
assert.Equal(t, merkletree.NodeTypeMiddle, ri2.Type)
k2, _ := ri2.Key()
assert.Equal(t, n2k, k2)

assert.Equal(t, merkletree.Hash{6}, *ri3.ChildL)
assert.Equal(t, merkletree.Hash{7}, *ri3.ChildR)
assert.Equal(t, merkletree.NodeTypeMiddle, ri3.Type)
k3, _ := ri3.Key()
assert.Equal(t, n3k, k3)

// Test that list respects the specified limit
r, err = sto1.List(ctx, 2)
require.Nil(t, err)
assert.Equal(t, 2, len(r))
nodeMap2 := make(merkletree.KvMap)
for _, v := range r {
nodeMap2.Put(v.K, v.V)
}
okCount := 0
_, ok = nodeMap2.Get(n1k[:])
if ok {
okCount++
}
_, ok = nodeMap2.Get(n2k[:])
if ok {
okCount++
}
_, ok = nodeMap2.Get(n3k[:])
if ok {
okCount++
}
assert.Equal(t, 2, okCount)

// Test that storage with prefix 2 has only 2 records and they are expected ones
r, err = sto2.List(ctx, 100)
require.Nil(t, err)
assert.Equal(t, 2, len(r))
nodeMap3 := make(merkletree.KvMap)
for _, v := range r {
nodeMap3.Put(v.K, v.V)
}
ri4, ok := nodeMap3.Get(n1k[:])
require.True(t, ok)
ri5, ok := nodeMap3.Get(n2k[:])
require.True(t, ok)

assert.Equal(t, merkletree.Hash{4}, *ri4.ChildL)
assert.Equal(t, merkletree.Hash{5}, *ri4.ChildR)
assert.Equal(t, merkletree.NodeTypeMiddle, ri4.Type)

assert.Equal(t, merkletree.Hash{5}, *ri5.ChildL)
assert.Equal(t, merkletree.Hash{6}, *ri5.ChildR)
assert.Equal(t, merkletree.NodeTypeMiddle, ri5.Type)
}

//
// TODO: Add tests for each storage
//
Expand Down

0 comments on commit a614fbf

Please sign in to comment.