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