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