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	err = tx.Put(key, value)
 32	assert.Nil(t, err)
 33	v, err := tx.Get(key)
 34	assert.Nil(t, err)
 35	assert.Equal(t, value, v)
 36	assert.Nil(t, tx.Commit())
 37
 38	tx, err = sto.NewTx()
 39	assert.Nil(t, err)
 40	v, err = tx.Get(key)
 41	assert.Nil(t, err)
 42	assert.Equal(t, value, v)
 43}
 44
 45// TestStorageWithPrefix checks that the implementation of the db.Storage
 46// interface behaves as expected for the WithPrefix method
 47func TestStorageWithPrefix(t *testing.T, sto db.Storage) {
 48	k := []byte{9}
 49
 50	sto1 := sto.WithPrefix([]byte{1})
 51	sto2 := sto.WithPrefix([]byte{2})
 52
 53	// check within tx
 54
 55	sto1tx, err := sto1.NewTx()
 56	assert.Nil(t, err)
 57	err = sto1tx.Put(k, []byte{4, 5, 6})
 58	assert.Nil(t, err)
 59	v1, err := sto1tx.Get(k)
 60	assert.Nil(t, err)
 61	assert.Equal(t, v1, []byte{4, 5, 6})
 62	assert.Nil(t, sto1tx.Commit())
 63
 64	sto2tx, err := sto2.NewTx()
 65	assert.Nil(t, err)
 66	err = sto2tx.Put(k, []byte{8, 9})
 67	assert.Nil(t, err)
 68	v2, err := sto2tx.Get(k)
 69	assert.Nil(t, err)
 70	assert.Equal(t, v2, []byte{8, 9})
 71	assert.Nil(t, sto2tx.Commit())
 72
 73	// check outside tx
 74
 75	v1, err = sto1.Get(k)
 76	assert.Nil(t, err)
 77	assert.Equal(t, v1, []byte{4, 5, 6})
 78
 79	v2, err = sto2.Get(k)
 80	assert.Nil(t, err)
 81	assert.Equal(t, v2, []byte{8, 9})
 82}
 83
 84// TestIterate checks that the implementation of the db.Storage interface
 85// behaves as expected for the Iterate method
 86func TestIterate(t *testing.T, sto db.Storage) {
 87	r := []db.KV{}
 88	lister := func(k []byte, v []byte) (bool, error) {
 89		r = append(r, db.KV{K: db.Clone(k), V: db.Clone(v)})
 90		return true, nil
 91	}
 92
 93	sto1 := sto.WithPrefix([]byte{1})
 94	err := sto1.Iterate(lister)
 95	assert.Nil(t, err)
 96	assert.Equal(t, 0, len(r))
 97
 98	sto1tx, _ := sto1.NewTx()
 99	err = sto1tx.Put([]byte{1}, []byte{4})
100	assert.Nil(t, err)
101	err = sto1tx.Put([]byte{2}, []byte{5})
102	assert.Nil(t, err)
103	err = sto1tx.Put([]byte{3}, []byte{6})
104	assert.Nil(t, err)
105	assert.Nil(t, sto1tx.Commit())
106
107	sto2 := sto.WithPrefix([]byte{2})
108	sto2tx, _ := sto2.NewTx()
109	err = sto2tx.Put([]byte{1}, []byte{7})
110	assert.Nil(t, err)
111	err = sto2tx.Put([]byte{2}, []byte{8})
112	assert.Nil(t, err)
113	err = sto2tx.Put([]byte{3}, []byte{9})
114	assert.Nil(t, err)
115	assert.Nil(t, sto2tx.Commit())
116
117	r = []db.KV{}
118	err = sto1.Iterate(lister)
119	assert.Nil(t, err)
120	assert.Equal(t, 3, len(r))
121	assert.Equal(t, db.KV{K: []byte{1}, V: []byte{4}}, r[0])
122	assert.Equal(t, db.KV{K: []byte{2}, V: []byte{5}}, r[1])
123	assert.Equal(t, db.KV{K: []byte{3}, V: []byte{6}}, r[2])
124
125	r = []db.KV{}
126	err = sto2.Iterate(lister)
127	assert.Nil(t, err)
128	assert.Equal(t, 3, len(r))
129	assert.Equal(t, db.KV{K: []byte{1}, V: []byte{7}}, r[0])
130	assert.Equal(t, db.KV{K: []byte{2}, V: []byte{8}}, r[1])
131	assert.Equal(t, db.KV{K: []byte{3}, V: []byte{9}}, r[2])
132}
133
134// TestConcatTx checks that the implementation of the db.Storage interface
135// behaves as expected
136func TestConcatTx(t *testing.T, sto db.Storage) {
137	k := []byte{9}
138
139	sto1 := sto.WithPrefix([]byte{1})
140	sto2 := sto.WithPrefix([]byte{2})
141
142	// check within tx
143
144	sto1tx, err := sto1.NewTx()
145	if err != nil {
146		panic(err)
147	}
148	err = sto1tx.Put(k, []byte{4, 5, 6})
149	assert.Nil(t, err)
150	sto2tx, err := sto2.NewTx()
151	if err != nil {
152		panic(err)
153	}
154	err = sto2tx.Put(k, []byte{8, 9})
155	assert.Nil(t, err)
156
157	err = sto1tx.Add(sto2tx)
158	assert.Nil(t, err)
159	assert.Nil(t, sto1tx.Commit())
160
161	// check outside tx
162
163	v1, err := sto1.Get(k)
164	assert.Nil(t, err)
165	assert.Equal(t, v1, []byte{4, 5, 6})
166
167	v2, err := sto2.Get(k)
168	assert.Nil(t, err)
169	assert.Equal(t, v2, []byte{8, 9})
170}
171
172// TestList checks that the implementation of the db.Storage interface behaves
173// as expected
174func TestList(t *testing.T, sto db.Storage) {
175	sto1 := sto.WithPrefix([]byte{1})
176	r1, err := sto1.List(100)
177	assert.Nil(t, err)
178	assert.Equal(t, 0, len(r1))
179
180	sto1tx, _ := sto1.NewTx()
181	err = sto1tx.Put([]byte{1}, []byte{4})
182	assert.Nil(t, err)
183	err = sto1tx.Put([]byte{2}, []byte{5})
184	assert.Nil(t, err)
185	err = sto1tx.Put([]byte{3}, []byte{6})
186	assert.Nil(t, err)
187	assert.Nil(t, sto1tx.Commit())
188
189	sto2 := sto.WithPrefix([]byte{2})
190	sto2tx, _ := sto2.NewTx()
191	err = sto2tx.Put([]byte{1}, []byte{7})
192	assert.Nil(t, err)
193	err = sto2tx.Put([]byte{2}, []byte{8})
194	assert.Nil(t, err)
195	err = sto2tx.Put([]byte{3}, []byte{9})
196	assert.Nil(t, err)
197	assert.Nil(t, sto2tx.Commit())
198
199	r, err := sto1.List(100)
200	assert.Nil(t, err)
201	assert.Equal(t, 3, len(r))
202	assert.Equal(t, r[0], db.KV{K: []byte{1}, V: []byte{4}})
203	assert.Equal(t, r[1], db.KV{K: []byte{2}, V: []byte{5}})
204	assert.Equal(t, r[2], db.KV{K: []byte{3}, V: []byte{6}})
205
206	r, err = sto1.List(2)
207	assert.Nil(t, err)
208	assert.Equal(t, 2, len(r))
209	assert.Equal(t, r[0], db.KV{K: []byte{1}, V: []byte{4}})
210	assert.Equal(t, r[1], db.KV{K: []byte{2}, V: []byte{5}})
211}