1package apitypes
  2
  3import (
  4	"database/sql"
  5	"io/ioutil"
  6	"math/big"
  7	"os"
  8	"testing"
  9
 10	ethCommon "github.com/ethereum/go-ethereum/common"
 11	dbUtils "github.com/hermeznetwork/hermez-node/db"
 12	"github.com/iden3/go-iden3-crypto/babyjub"
 13	_ "github.com/mattn/go-sqlite3" //nolint sqlite driver
 14	"github.com/russross/meddler"
 15	"github.com/stretchr/testify/assert"
 16)
 17
 18var db *sql.DB
 19
 20func TestMain(m *testing.M) {
 21	// Register meddler
 22	meddler.Default = meddler.SQLite
 23	meddler.Register("bigint", dbUtils.BigIntMeddler{})
 24	meddler.Register("bigintnull", dbUtils.BigIntNullMeddler{})
 25	// Create temporary sqlite DB
 26	dir, err := ioutil.TempDir("", "db")
 27	if err != nil {
 28		panic(err)
 29	}
 30	db, err = sql.Open("sqlite3", dir+"sqlite.db")
 31	if err != nil {
 32		panic(err)
 33	}
 34	defer os.RemoveAll(dir) //nolint
 35	schema := `CREATE TABLE test (i BLOB);`
 36	if _, err := db.Exec(schema); err != nil {
 37		panic(err)
 38	}
 39	// Run tests
 40	result := m.Run()
 41	os.Exit(result)
 42}
 43
 44func TestBigIntStrScannerValuer(t *testing.T) {
 45	// Clean DB
 46	_, err := db.Exec("delete from test")
 47	assert.NoError(t, err)
 48	// Example structs
 49	type bigInMeddlerStruct struct {
 50		I *big.Int `meddler:"i,bigint"` // note the bigint that instructs meddler to use BigIntMeddler
 51	}
 52	type bigIntStrStruct struct {
 53		I BigIntStr `meddler:"i"` // note that no meddler is specified, and Scan/Value will be used
 54	}
 55	type bigInMeddlerStructNil struct {
 56		I *big.Int `meddler:"i,bigintnull"` // note the bigint that instructs meddler to use BigIntNullMeddler
 57	}
 58	type bigIntStrStructNil struct {
 59		I *BigIntStr `meddler:"i"` // note that no meddler is specified, and Scan/Value will be used
 60	}
 61
 62	// Not nil case
 63	// Insert into DB using meddler
 64	const x = int64(12345)
 65	fromMeddler := bigInMeddlerStruct{
 66		I: big.NewInt(x),
 67	}
 68	err = meddler.Insert(db, "test", &fromMeddler)
 69	assert.NoError(t, err)
 70	// Read from DB using BigIntStr
 71	toBigIntStr := bigIntStrStruct{}
 72	err = meddler.QueryRow(db, &toBigIntStr, "select * from test")
 73	assert.NoError(t, err)
 74	assert.Equal(t, fromMeddler.I.String(), string(toBigIntStr.I))
 75	// Clean DB
 76	_, err = db.Exec("delete from test")
 77	assert.NoError(t, err)
 78	// Insert into DB using BigIntStr
 79	fromBigIntStr := bigIntStrStruct{
 80		I: "54321",
 81	}
 82	err = meddler.Insert(db, "test", &fromBigIntStr)
 83	assert.NoError(t, err)
 84	// Read from DB using meddler
 85	toMeddler := bigInMeddlerStruct{}
 86	err = meddler.QueryRow(db, &toMeddler, "select * from test")
 87	assert.NoError(t, err)
 88	assert.Equal(t, string(fromBigIntStr.I), toMeddler.I.String())
 89
 90	// Nil case
 91	// Clean DB
 92	_, err = db.Exec("delete from test")
 93	assert.NoError(t, err)
 94	// Insert into DB using meddler
 95	fromMeddlerNil := bigInMeddlerStructNil{
 96		I: nil,
 97	}
 98	err = meddler.Insert(db, "test", &fromMeddlerNil)
 99	assert.NoError(t, err)
100	// Read from DB using BigIntStr
101	foo := BigIntStr("foo")
102	toBigIntStrNil := bigIntStrStructNil{
103		I: &foo, // check that this will be set to nil, not because of not being initialized
104	}
105	err = meddler.QueryRow(db, &toBigIntStrNil, "select * from test")
106	assert.NoError(t, err)
107	assert.Nil(t, toBigIntStrNil.I)
108	// Clean DB
109	_, err = db.Exec("delete from test")
110	assert.NoError(t, err)
111	// Insert into DB using BigIntStr
112	fromBigIntStrNil := bigIntStrStructNil{
113		I: nil,
114	}
115	err = meddler.Insert(db, "test", &fromBigIntStrNil)
116	assert.NoError(t, err)
117	// Read from DB using meddler
118	toMeddlerNil := bigInMeddlerStructNil{
119		I: big.NewInt(x), // check that this will be set to nil, not because of not being initialized
120	}
121	err = meddler.QueryRow(db, &toMeddlerNil, "select * from test")
122	assert.NoError(t, err)
123	assert.Nil(t, toMeddlerNil.I)
124}
125
126func TestHezEthAddr(t *testing.T) {
127	// Clean DB
128	_, err := db.Exec("delete from test")
129	assert.NoError(t, err)
130	// Example structs
131	type ethAddrStruct struct {
132		I ethCommon.Address `meddler:"i"`
133	}
134	type hezEthAddrStruct struct {
135		I HezEthAddr `meddler:"i"`
136	}
137	type ethAddrStructNil struct {
138		I *ethCommon.Address `meddler:"i"`
139	}
140	type hezEthAddrStructNil struct {
141		I *HezEthAddr `meddler:"i"`
142	}
143
144	// Not nil case
145	// Insert into DB using ethCommon.Address Scan/Value
146	fromEth := ethAddrStruct{
147		I: ethCommon.BigToAddress(big.NewInt(73737373)),
148	}
149	err = meddler.Insert(db, "test", &fromEth)
150	assert.NoError(t, err)
151	// Read from DB using HezEthAddr Scan/Value
152	toHezEth := hezEthAddrStruct{}
153	err = meddler.QueryRow(db, &toHezEth, "select * from test")
154	assert.NoError(t, err)
155	assert.Equal(t, NewHezEthAddr(fromEth.I), toHezEth.I)
156	// Clean DB
157	_, err = db.Exec("delete from test")
158	assert.NoError(t, err)
159	// Insert into DB using HezEthAddr Scan/Value
160	fromHezEth := hezEthAddrStruct{
161		I: NewHezEthAddr(ethCommon.BigToAddress(big.NewInt(3786872586))),
162	}
163	err = meddler.Insert(db, "test", &fromHezEth)
164	assert.NoError(t, err)
165	// Read from DB using ethCommon.Address Scan/Value
166	toEth := ethAddrStruct{}
167	err = meddler.QueryRow(db, &toEth, "select * from test")
168	assert.NoError(t, err)
169	assert.Equal(t, fromHezEth.I, NewHezEthAddr(toEth.I))
170
171	// Nil case
172	// Clean DB
173	_, err = db.Exec("delete from test")
174	assert.NoError(t, err)
175	// Insert into DB using ethCommon.Address Scan/Value
176	fromEthNil := ethAddrStructNil{
177		I: nil,
178	}
179	err = meddler.Insert(db, "test", &fromEthNil)
180	assert.NoError(t, err)
181	// Read from DB using HezEthAddr Scan/Value
182	foo := HezEthAddr("foo")
183	toHezEthNil := hezEthAddrStructNil{
184		I: &foo, // check that this will be set to nil, not because of not being initialized
185	}
186	err = meddler.QueryRow(db, &toHezEthNil, "select * from test")
187	assert.NoError(t, err)
188	assert.Nil(t, toHezEthNil.I)
189	// Clean DB
190	_, err = db.Exec("delete from test")
191	assert.NoError(t, err)
192	// Insert into DB using HezEthAddr Scan/Value
193	fromHezEthNil := hezEthAddrStructNil{
194		I: nil,
195	}
196	err = meddler.Insert(db, "test", &fromHezEthNil)
197	assert.NoError(t, err)
198	// Read from DB using ethCommon.Address Scan/Value
199	fooAddr := ethCommon.BigToAddress(big.NewInt(1))
200	toEthNil := ethAddrStructNil{
201		I: &fooAddr, // check that this will be set to nil, not because of not being initialized
202	}
203	err = meddler.QueryRow(db, &toEthNil, "select * from test")
204	assert.NoError(t, err)
205	assert.Nil(t, toEthNil.I)
206}
207
208func TestHezBJJ(t *testing.T) {
209	// Clean DB
210	_, err := db.Exec("delete from test")
211	assert.NoError(t, err)
212	// Example structs
213	type bjjStruct struct {
214		I *babyjub.PublicKey `meddler:"i"`
215	}
216	type hezBJJStruct struct {
217		I HezBJJ `meddler:"i"`
218	}
219	type hezBJJStructNil struct {
220		I *HezBJJ `meddler:"i"`
221	}
222
223	// Not nil case
224	// Insert into DB using *babyjub.PublicKey Scan/Value
225	priv := babyjub.NewRandPrivKey()
226	fromBJJ := bjjStruct{
227		I: priv.Public(),
228	}
229	err = meddler.Insert(db, "test", &fromBJJ)
230	assert.NoError(t, err)
231	// Read from DB using HezBJJ Scan/Value
232	toHezBJJ := hezBJJStruct{}
233	err = meddler.QueryRow(db, &toHezBJJ, "select * from test")
234	assert.NoError(t, err)
235	assert.Equal(t, NewHezBJJ(fromBJJ.I), toHezBJJ.I)
236	// Clean DB
237	_, err = db.Exec("delete from test")
238	assert.NoError(t, err)
239	// Insert into DB using HezBJJ Scan/Value
240	fromHezBJJ := hezBJJStruct{
241		I: NewHezBJJ(priv.Public()),
242	}
243	err = meddler.Insert(db, "test", &fromHezBJJ)
244	assert.NoError(t, err)
245	// Read from DB using *babyjub.PublicKey Scan/Value
246	toBJJ := bjjStruct{}
247	err = meddler.QueryRow(db, &toBJJ, "select * from test")
248	assert.NoError(t, err)
249	assert.Equal(t, fromHezBJJ.I, NewHezBJJ(toBJJ.I))
250
251	// Nil case
252	// Clean DB
253	_, err = db.Exec("delete from test")
254	assert.NoError(t, err)
255	// Insert into DB using *babyjub.PublicKey Scan/Value
256	fromBJJNil := bjjStruct{
257		I: nil,
258	}
259	err = meddler.Insert(db, "test", &fromBJJNil)
260	assert.NoError(t, err)
261	// Read from DB using HezBJJ Scan/Value
262	foo := HezBJJ("foo")
263	toHezBJJNil := hezBJJStructNil{
264		I: &foo, // check that this will be set to nil, not because of not being initialized
265	}
266	err = meddler.QueryRow(db, &toHezBJJNil, "select * from test")
267	assert.NoError(t, err)
268	assert.Nil(t, toHezBJJNil.I)
269	// Clean DB
270	_, err = db.Exec("delete from test")
271	assert.NoError(t, err)
272	// Insert into DB using HezBJJ Scan/Value
273	fromHezBJJNil := hezBJJStructNil{
274		I: nil,
275	}
276	err = meddler.Insert(db, "test", &fromHezBJJNil)
277	assert.NoError(t, err)
278	// Read from DB using *babyjub.PublicKey Scan/Value
279	toBJJNil := bjjStruct{
280		I: priv.Public(), // check that this will be set to nil, not because of not being initialized
281	}
282	err = meddler.QueryRow(db, &toBJJNil, "select * from test")
283	assert.NoError(t, err)
284	assert.Nil(t, toBJJNil.I)
285}