1//nolint:gomnd
  2package test
  3
  4import (
  5	"testing"
  6
  7	"github.com/iden3/go-merkletree/db"
  8	"github.com/stretchr/testify/assert"
  9)
 10
 11// TestReturnKnownErrIfNotExists checks that the implementation of the
 12// db.Storage interface returns the expected error in the case that the value
 13// is not found
 14func TestReturnKnownErrIfNotExists(t *testing.T, sto db.Storage) {
 15	k := []byte("key")
 16
 17	tx, err := sto.NewTx()
 18	assert.Nil(t, err)
 19	_, err = tx.Get(k)
 20	assert.EqualError(t, err, db.ErrNotFound.Error())
 21}
 22
 23// TestStorageInsertGet checks that the implementation of the db.Storage
 24// interface behaves as expected
 25func TestStorageInsertGet(t *testing.T, sto db.Storage) {
 26	key := []byte("key")
 27	value := []byte("data")
 28
 29	tx, err := sto.NewTx()
 30	assert.Nil(t, err)
 31	tx.Put(key, value)
 32	v, err := tx.Get(key)
 33	assert.Nil(t, err)
 34	assert.Equal(t, value, v)
 35	assert.Nil(t, tx.Commit())
 36
 37	tx, err = sto.NewTx()
 38	assert.Nil(t, err)
 39	v, err = tx.Get(key)
 40	assert.Nil(t, err)
 41	assert.Equal(t, value, v)
 42}
 43
 44// TestStorageWithPrefix checks that the implementation of the db.Storage
 45// interface behaves as expected for the WithPrefix method
 46func TestStorageWithPrefix(t *testing.T, sto db.Storage) {
 47	k := []byte{9}
 48
 49	sto1 := sto.WithPrefix([]byte{1})
 50	sto2 := sto.WithPrefix([]byte{2})
 51
 52	// check within tx
 53
 54	sto1tx, err := sto1.NewTx()
 55	assert.Nil(t, err)
 56	sto1tx.Put(k, []byte{4, 5, 6})
 57	v1, err := sto1tx.Get(k)
 58	assert.Nil(t, err)
 59	assert.Equal(t, v1, []byte{4, 5, 6})
 60	assert.Nil(t, sto1tx.Commit())
 61
 62	sto2tx, err := sto2.NewTx()
 63	assert.Nil(t, err)
 64	sto2tx.Put(k, []byte{8, 9})
 65	v2, err := sto2tx.Get(k)
 66	assert.Nil(t, err)
 67	assert.Equal(t, v2, []byte{8, 9})
 68	assert.Nil(t, sto2tx.Commit())
 69
 70	// check outside tx
 71
 72	v1, err = sto1.Get(k)
 73	assert.Nil(t, err)
 74	assert.Equal(t, v1, []byte{4, 5, 6})
 75
 76	v2, err = sto2.Get(k)
 77	assert.Nil(t, err)
 78	assert.Equal(t, v2, []byte{8, 9})
 79}
 80
 81// TestIterate checks that the implementation of the db.Storage interface
 82// behaves as expected for the Iterate method
 83func TestIterate(t *testing.T, sto db.Storage) {
 84	r := []db.KV{}
 85	lister := func(k []byte, v []byte) (bool, error) {
 86		r = append(r, db.KV{K: db.Clone(k), V: db.Clone(v)})
 87		return true, nil
 88	}
 89
 90	sto1 := sto.WithPrefix([]byte{1})
 91	err := sto1.Iterate(lister)
 92	assert.Nil(t, err)
 93	assert.Equal(t, 0, len(r))
 94
 95	sto1tx, _ := sto1.NewTx()
 96	sto1tx.Put([]byte{1}, []byte{4})
 97	sto1tx.Put([]byte{2}, []byte{5})
 98	sto1tx.Put([]byte{3}, []byte{6})
 99	assert.Nil(t, sto1tx.Commit())
100
101	sto2 := sto.WithPrefix([]byte{2})
102	sto2tx, _ := sto2.NewTx()
103	sto2tx.Put([]byte{1}, []byte{7})
104	sto2tx.Put([]byte{2}, []byte{8})
105	sto2tx.Put([]byte{3}, []byte{9})
106	assert.Nil(t, sto2tx.Commit())
107
108	r = []db.KV{}
109	err = sto1.Iterate(lister)
110	assert.Nil(t, err)
111	assert.Equal(t, 3, len(r))
112	assert.Equal(t, db.KV{K: []byte{1}, V: []byte{4}}, r[0])
113	assert.Equal(t, db.KV{K: []byte{2}, V: []byte{5}}, r[1])
114	assert.Equal(t, db.KV{K: []byte{3}, V: []byte{6}}, r[2])
115
116	r = []db.KV{}
117	err = sto2.Iterate(lister)
118	assert.Nil(t, err)
119	assert.Equal(t, 3, len(r))
120	assert.Equal(t, db.KV{K: []byte{1}, V: []byte{7}}, r[0])
121	assert.Equal(t, db.KV{K: []byte{2}, V: []byte{8}}, r[1])
122	assert.Equal(t, db.KV{K: []byte{3}, V: []byte{9}}, r[2])
123}
124
125// TestConcatTx checks that the implementation of the db.Storage interface
126// behaves as expected
127func TestConcatTx(t *testing.T, sto db.Storage) {
128	k := []byte{9}
129
130	sto1 := sto.WithPrefix([]byte{1})
131	sto2 := sto.WithPrefix([]byte{2})
132
133	// check within tx
134
135	sto1tx, err := sto1.NewTx()
136	if err != nil {
137		panic(err)
138	}
139	sto1tx.Put(k, []byte{4, 5, 6})
140	sto2tx, err := sto2.NewTx()
141	if err != nil {
142		panic(err)
143	}
144	sto2tx.Put(k, []byte{8, 9})
145
146	sto1tx.Add(sto2tx)
147	assert.Nil(t, sto1tx.Commit())
148
149	// check outside tx
150
151	v1, err := sto1.Get(k)
152	assert.Nil(t, err)
153	assert.Equal(t, v1, []byte{4, 5, 6})
154
155	v2, err := sto2.Get(k)
156	assert.Nil(t, err)
157	assert.Equal(t, v2, []byte{8, 9})
158}
159
160// TestList checks that the implementation of the db.Storage interface behaves
161// as expected
162func TestList(t *testing.T, sto db.Storage) {
163	sto1 := sto.WithPrefix([]byte{1})
164	r1, err := sto1.List(100)
165	assert.Nil(t, err)
166	assert.Equal(t, 0, len(r1))
167
168	sto1tx, _ := sto1.NewTx()
169	sto1tx.Put([]byte{1}, []byte{4})
170	sto1tx.Put([]byte{2}, []byte{5})
171	sto1tx.Put([]byte{3}, []byte{6})
172	assert.Nil(t, sto1tx.Commit())
173
174	sto2 := sto.WithPrefix([]byte{2})
175	sto2tx, _ := sto2.NewTx()
176	sto2tx.Put([]byte{1}, []byte{7})
177	sto2tx.Put([]byte{2}, []byte{8})
178	sto2tx.Put([]byte{3}, []byte{9})
179	assert.Nil(t, sto2tx.Commit())
180
181	r, err := sto1.List(100)
182	assert.Nil(t, err)
183	assert.Equal(t, 3, len(r))
184	assert.Equal(t, r[0], db.KV{K: []byte{1}, V: []byte{4}})
185	assert.Equal(t, r[1], db.KV{K: []byte{2}, V: []byte{5}})
186	assert.Equal(t, r[2], db.KV{K: []byte{3}, V: []byte{6}})
187
188	r, err = sto1.List(2)
189	assert.Nil(t, err)
190	assert.Equal(t, 2, len(r))
191	assert.Equal(t, r[0], db.KV{K: []byte{1}, V: []byte{4}})
192	assert.Equal(t, r[1], db.KV{K: []byte{2}, V: []byte{5}})
193}