hermez-node/api/parsers_test.go
api/parsers_test.goRaw
1package api
2
3import (
4 "encoding/base64"
5 "math/big"
6 "strconv"
7 "testing"
8
9 ethCommon "github.com/ethereum/go-ethereum/common"
10 "github.com/hermeznetwork/hermez-node/common"
11 "github.com/iden3/go-iden3-crypto/babyjub"
12 "github.com/stretchr/testify/assert"
13)
14
15type queryParser struct {
16 m map[string]string
17}
18
19func (qp *queryParser) Query(query string) string {
20 if val, ok := qp.m[query]; ok {
21 return val
22 }
23 return ""
24}
25
26func (qp *queryParser) Param(param string) string {
27 if val, ok := qp.m[param]; ok {
28 return val
29 }
30 return ""
31}
32
33func TestParseQueryUint(t *testing.T) {
34 name := "foo"
35 c := &queryParser{}
36 c.m = make(map[string]string)
37 var min uint = 1
38 var max uint = 10
39 var dflt *uint
40 // Not uint
41 c.m[name] = "-1"
42 _, err := parseQueryUint(name, dflt, min, max, c)
43 assert.Error(t, err)
44 c.m[name] = "a"
45 _, err = parseQueryUint(name, dflt, min, max, c)
46 assert.Error(t, err)
47 c.m[name] = "0.1"
48 _, err = parseQueryUint(name, dflt, min, max, c)
49 assert.Error(t, err)
50 c.m[name] = "1.0"
51 _, err = parseQueryUint(name, dflt, min, max, c)
52 assert.Error(t, err)
53 // Out of range
54 c.m[name] = strconv.Itoa(int(min) - 1)
55 _, err = parseQueryUint(name, dflt, min, max, c)
56 assert.Error(t, err)
57 c.m[name] = strconv.Itoa(int(max) + 1)
58 _, err = parseQueryUint(name, dflt, min, max, c)
59 assert.Error(t, err)
60 // Default nil
61 c.m[name] = ""
62 res, err := parseQueryUint(name, dflt, min, max, c)
63 assert.NoError(t, err)
64 assert.Nil(t, res)
65 // Default not nil
66 dflt = new(uint)
67 *dflt = uint(min)
68 res, err = parseQueryUint(name, dflt, min, max, c)
69 assert.NoError(t, err)
70 assert.Equal(t, uint(min), *res)
71 // Correct
72 c.m[name] = strconv.Itoa(int(max))
73 res, err = parseQueryUint(name, res, min, max, c)
74 assert.NoError(t, err)
75 assert.Equal(t, uint(max), *res)
76}
77
78func TestParseQueryBool(t *testing.T) {
79 name := "foo"
80 c := &queryParser{}
81 c.m = make(map[string]string)
82 var dflt *bool
83 // Not bool
84 c.m[name] = "x"
85 _, err := parseQueryBool(name, dflt, c)
86 assert.Error(t, err)
87 c.m[name] = "False"
88 _, err = parseQueryBool(name, dflt, c)
89 assert.Error(t, err)
90 c.m[name] = "0"
91 _, err = parseQueryBool(name, dflt, c)
92 assert.Error(t, err)
93 c.m[name] = "1"
94 _, err = parseQueryBool(name, dflt, c)
95 assert.Error(t, err)
96 // Default nil
97 c.m[name] = ""
98 res, err := parseQueryBool(name, dflt, c)
99 assert.NoError(t, err)
100 assert.Nil(t, res)
101 // Default not nil
102 dflt = new(bool)
103 *dflt = true
104 res, err = parseQueryBool(name, dflt, c)
105 assert.NoError(t, err)
106 assert.True(t, *res)
107 // Correct
108 c.m[name] = "false"
109 res, err = parseQueryBool(name, dflt, c)
110 assert.NoError(t, err)
111 assert.False(t, *res)
112 c.m[name] = "true"
113 res, err = parseQueryBool(name, dflt, c)
114 assert.NoError(t, err)
115 assert.True(t, *res)
116}
117
118func TestParsePagination(t *testing.T) {
119 c := &queryParser{}
120 c.m = make(map[string]string)
121 // fromItem out of range
122 c.m["fromItem"] = "-1"
123 _, _, _, err := parsePagination(c)
124 assert.Error(t, err)
125 c.m["fromItem"] = strconv.Itoa(maxUint32 + 1)
126 _, _, _, err = parsePagination(c)
127 assert.Error(t, err)
128 c.m["fromItem"] = ""
129 // Bad order
130 c.m["order"] = "0"
131 _, _, _, err = parsePagination(c)
132 assert.Error(t, err)
133 c.m["order"] = strconv.Itoa(int(maxLimit) + 1)
134 _, _, _, err = parsePagination(c)
135 assert.Error(t, err)
136 // Default
137 c.m["fromItem"] = ""
138 c.m["order"] = ""
139 c.m["limit"] = ""
140 fromItem, order, limit, err := parsePagination(c)
141 assert.NoError(t, err)
142 assert.Nil(t, fromItem)
143 assert.Equal(t, dfltOrder, order)
144 assert.Equal(t, dfltLimit, *limit)
145 // Correct
146 c.m["fromItem"] = ""
147 c.m["order"] = "ASC"
148 c.m["limit"] = "25"
149 fromItem, order, limit, err = parsePagination(c)
150 assert.NoError(t, err)
151 assert.Nil(t, fromItem)
152 assert.Equal(t, "ASC", order)
153 assert.Equal(t, 25, int(*limit))
154 c.m["fromItem"] = "25"
155 c.m["order"] = "DESC"
156 c.m["limit"] = "50"
157 fromItem, order, limit, err = parsePagination(c)
158 assert.NoError(t, err)
159 assert.Equal(t, 25, int(*fromItem))
160 assert.Equal(t, "DESC", order)
161 assert.Equal(t, 50, int(*limit))
162}
163
164func TestParseQueryHezEthAddr(t *testing.T) {
165 name := "hermezEthereumAddress"
166 c := &queryParser{}
167 c.m = make(map[string]string)
168 ethAddr := ethCommon.BigToAddress(big.NewInt(int64(347683)))
169 // Not HEZ Eth addr
170 c.m[name] = "hez:0xf"
171 _, err := parseQueryHezEthAddr(c)
172 assert.Error(t, err)
173 c.m[name] = ethAddr.String()
174 _, err = parseQueryHezEthAddr(c)
175 assert.Error(t, err)
176 c.m[name] = "hez:0xXX942cfcd25ad4d90a62358b0dd84f33b39826XX"
177 _, err = parseQueryHezEthAddr(c)
178 assert.Error(t, err)
179 // Default
180 c.m[name] = ""
181 res, err := parseQueryHezEthAddr(c)
182 assert.NoError(t, err)
183 assert.Nil(t, res)
184 // Correct
185 c.m[name] = "hez:" + ethAddr.String()
186 res, err = parseQueryHezEthAddr(c)
187 assert.NoError(t, err)
188 assert.Equal(t, ethAddr, *res)
189}
190
191func TestParseQueryBJJ(t *testing.T) {
192 name := "BJJ"
193 c := &queryParser{}
194 c.m = make(map[string]string)
195 privK := babyjub.NewRandPrivKey()
196 pubK := privK.Public()
197 pkComp := [32]byte(pubK.Compress())
198 // Not HEZ Eth addr
199 c.m[name] = "hez:abcd"
200 _, err := parseQueryBJJ(c)
201 assert.Error(t, err)
202 c.m[name] = pubK.String()
203 _, err = parseQueryBJJ(c)
204 assert.Error(t, err)
205 // Wrong checksum
206 bjjSum := append(pkComp[:], byte(1))
207 c.m[name] = "hez:" + base64.RawStdEncoding.EncodeToString(bjjSum)
208 _, err = parseQueryBJJ(c)
209 assert.Error(t, err)
210 // Default
211 c.m[name] = ""
212 res, err := parseQueryBJJ(c)
213 assert.NoError(t, err)
214 assert.Nil(t, res)
215 // Correct
216 c.m[name] = bjjToString(pubK)
217 res, err = parseQueryBJJ(c)
218 assert.NoError(t, err)
219 assert.Equal(t, *pubK, *res)
220}
221
222func TestParseQueryTxType(t *testing.T) {
223 name := "type"
224 c := &queryParser{}
225 c.m = make(map[string]string)
226 // Incorrect values
227 c.m[name] = "deposit"
228 _, err := parseQueryTxType(c)
229 assert.Error(t, err)
230 c.m[name] = "1"
231 _, err = parseQueryTxType(c)
232 assert.Error(t, err)
233 // Default
234 c.m[name] = ""
235 res, err := parseQueryTxType(c)
236 assert.NoError(t, err)
237 assert.Nil(t, res)
238 // Correct values
239 c.m[name] = string(common.TxTypeExit)
240 res, err = parseQueryTxType(c)
241 assert.NoError(t, err)
242 assert.Equal(t, common.TxTypeExit, *res)
243 c.m[name] = string(common.TxTypeTransfer)
244 res, err = parseQueryTxType(c)
245 assert.NoError(t, err)
246 assert.Equal(t, common.TxTypeTransfer, *res)
247 c.m[name] = string(common.TxTypeDeposit)
248 res, err = parseQueryTxType(c)
249 assert.NoError(t, err)
250 assert.Equal(t, common.TxTypeDeposit, *res)
251 c.m[name] = string(common.TxTypeCreateAccountDeposit)
252 res, err = parseQueryTxType(c)
253 assert.NoError(t, err)
254 assert.Equal(t, common.TxTypeCreateAccountDeposit, *res)
255 c.m[name] = string(common.TxTypeCreateAccountDepositTransfer)
256 res, err = parseQueryTxType(c)
257 assert.NoError(t, err)
258 assert.Equal(t, common.TxTypeCreateAccountDepositTransfer, *res)
259 c.m[name] = string(common.TxTypeDepositTransfer)
260 res, err = parseQueryTxType(c)
261 assert.NoError(t, err)
262 assert.Equal(t, common.TxTypeDepositTransfer, *res)
263 c.m[name] = string(common.TxTypeForceTransfer)
264 res, err = parseQueryTxType(c)
265 assert.NoError(t, err)
266 assert.Equal(t, common.TxTypeForceTransfer, *res)
267 c.m[name] = string(common.TxTypeForceExit)
268 res, err = parseQueryTxType(c)
269 assert.NoError(t, err)
270 assert.Equal(t, common.TxTypeForceExit, *res)
271 c.m[name] = string(common.TxTypeTransferToEthAddr)
272 res, err = parseQueryTxType(c)
273 assert.NoError(t, err)
274 assert.Equal(t, common.TxTypeTransferToEthAddr, *res)
275 c.m[name] = string(common.TxTypeTransferToBJJ)
276 res, err = parseQueryTxType(c)
277 assert.NoError(t, err)
278 assert.Equal(t, common.TxTypeTransferToBJJ, *res)
279}
280
281func TestParseTokenFilters(t *testing.T) {
282 ids := "ids"
283 symbols := "symbols"
284 name := "name"
285 nameValue := "1"
286 symbolsValue := "1,2,3"
287 idsValue := "2,3,4"
288 c := &queryParser{}
289 c.m = make(map[string]string)
290 // Incorrect values
291 c.m[name] = nameValue
292 c.m[ids] = idsValue
293 c.m[symbols] = symbolsValue
294
295 idsParse, symbolsParse, nameParse, err := parseTokenFilters(c)
296 assert.NoError(t, err)
297
298 // Correct values
299 var tokenIds []common.TokenID = []common.TokenID{2, 3, 4}
300 assert.Equal(t, tokenIds, idsParse)
301 var symbolsArray []string = []string{"1", "2", "3"}
302 assert.Equal(t, symbolsArray, symbolsParse)
303 assert.Equal(t, nameValue, nameParse)
304}
305func TestParseEthAddr(t *testing.T) {
306 name := "forgerAddr"
307 c := &queryParser{}
308 c.m = make(map[string]string)
309 ethAddr := ethCommon.BigToAddress(big.NewInt(int64(123456)))
310 // Default
311 c.m[name] = ""
312 res, err := parseQueryEthAddr(name, c)
313 assert.NoError(t, err)
314 assert.Nil(t, res)
315 // Incorrect
316 c.m[name] = "0x12345678"
317 _, err = parseQueryEthAddr(name, c)
318 assert.Error(t, err)
319 // Correct
320 c.m[name] = ethAddr.String()
321 res, err = parseQueryEthAddr(name, c)
322 assert.NoError(t, err)
323 assert.Equal(t, ethAddr, *res)
324}