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