hermez-node/test/til/lang_test.go
test/til/lang_test.goRaw
1package til
2
3import (
4 "fmt"
5 "strings"
6 "testing"
7
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10)
11
12var debug = false
13
14func TestParseBlockchainTxs(t *testing.T) {
15 s := `
16 Type: Blockchain
17
18 // token registrations
19 AddToken(1)
20 AddToken(2)
21
22 // deposits
23 Deposit(1) A: 10
24 Deposit(2) A: 20
25 Deposit(1) B: 5
26 CreateAccountDeposit(1) C: 5
27 CreateAccountDepositTransfer(1) D-A: 15, 10
28 CreateAccountCoordinator(1) E
29
30 // L2 transactions
31 Transfer(1) A-B: 6 (1)
32 Transfer(1) B-D: 3 (1)
33 Transfer(1) A-E: 1 (1)
34
35 // set new batch
36 > batch
37 AddToken(3)
38
39 DepositTransfer(1) A-B: 15, 10
40 Transfer(1) C-A : 3 (1)
41 Transfer(2) A-B: 15 (1)
42
43 Deposit(1) User0: 20
44 Deposit(3) User1: 20
45 Transfer(1) User0-User1: 15 (1)
46 Transfer(3) User1-User0: 15 (1)
47
48 > batch
49
50 Transfer(1) User1-User0: 1 (1)
51
52 > batch
53 > block
54
55 // Exits
56 Exit(1) A: 5 (1)
57 `
58
59 parser := newParser(strings.NewReader(s))
60 instructions, err := parser.parse()
61 require.NoError(t, err)
62 assert.Equal(t, 25, len(instructions.instructions))
63 assert.Equal(t, 7, len(instructions.users))
64
65 if debug {
66 fmt.Println(instructions)
67 for _, instruction := range instructions.instructions {
68 fmt.Println(instruction.raw())
69 }
70 }
71
72 assert.Equal(t, TxTypeCreateAccountDepositCoordinator, instructions.instructions[7].Typ)
73 assert.Equal(t, TypeNewBatch, instructions.instructions[11].Typ)
74 assert.Equal(t, "Deposit(1)User0:20", instructions.instructions[16].raw())
75 assert.Equal(t,
76 "Type: DepositTransfer, From: A, To: B, DepositAmount: 15, Amount: 10, Fee: 0, TokenID: 1\n",
77 instructions.instructions[13].String())
78 assert.Equal(t,
79 "Type: Transfer, From: User1, To: User0, Amount: 15, Fee: 1, TokenID: 3\n",
80 instructions.instructions[19].String())
81 assert.Equal(t, "Transfer(2)A-B:15(1)", instructions.instructions[15].raw())
82 assert.Equal(t,
83 "Type: Transfer, From: A, To: B, Amount: 15, Fee: 1, TokenID: 2\n",
84 instructions.instructions[15].String())
85 assert.Equal(t, "Exit(1)A:5", instructions.instructions[24].raw())
86 assert.Equal(t, "Type: Exit, From: A, Amount: 5, TokenID: 1\n",
87 instructions.instructions[24].String())
88}
89
90func TestParsePoolTxs(t *testing.T) {
91 s := `
92 Type: PoolL2
93 PoolTransfer(1) A-B: 6 (1)
94 PoolTransfer(2) A-B: 3 (3)
95 PoolTransfer(1) B-D: 3 (1)
96 PoolTransfer(1) C-D: 3 (1)
97 PoolExit(1) A: 5 (1)
98 `
99
100 parser := newParser(strings.NewReader(s))
101 instructions, err := parser.parse()
102 require.NoError(t, err)
103 assert.Equal(t, 5, len(instructions.instructions))
104 assert.Equal(t, 4, len(instructions.users))
105
106 if debug {
107 fmt.Println(instructions)
108 for _, instruction := range instructions.instructions {
109 fmt.Println(instruction.raw())
110 }
111 }
112
113 assert.Equal(t, "Transfer(1)A-B:6(1)", instructions.instructions[0].raw())
114 assert.Equal(t, "Transfer(2)A-B:3(3)", instructions.instructions[1].raw())
115 assert.Equal(t, "Transfer(1)B-D:3(1)", instructions.instructions[2].raw())
116 assert.Equal(t, "Transfer(1)C-D:3(1)", instructions.instructions[3].raw())
117 assert.Equal(t, "Exit(1)A:5", instructions.instructions[4].raw())
118}
119
120func TestParseErrors(t *testing.T) {
121 s := `
122 Type: Blockchain
123 Deposit(1) A:: 10
124 `
125 parser := newParser(strings.NewReader(s))
126 _, err := parser.parse()
127 assert.Equal(t, "Line 2: Deposit(1)A:: 10\n, err: Can not parse number for Amount: :", err.Error())
128
129 s = `
130 Type: Blockchain
131 AddToken(1)
132 Deposit(1) A: 10 20
133 `
134 parser = newParser(strings.NewReader(s))
135 _, err = parser.parse()
136 assert.Equal(t, "Line 4: 20, err: Unexpected Blockchain tx type: 20", err.Error())
137
138 s = `
139 Type: Blockchain
140 Transfer(1) A: 10
141 `
142 parser = newParser(strings.NewReader(s))
143 _, err = parser.parse()
144 assert.Equal(t, "Line 2: Transfer(1)A:, err: Expected '-', found ':'", err.Error())
145
146 s = `
147 Type: Blockchain
148 Transfer(1) A B: 10
149 `
150 parser = newParser(strings.NewReader(s))
151 _, err = parser.parse()
152 assert.Equal(t, "Line 2: Transfer(1)AB, err: Expected '-', found 'B'", err.Error())
153
154 s = `
155 Type: Blockchain
156 AddToken(1)
157 Transfer(1) A-B: 10 (255)
158 `
159 parser = newParser(strings.NewReader(s))
160 _, err = parser.parse()
161 assert.NoError(t, err)
162 s = `
163 Type: Blockchain
164 Transfer(1) A-B: 10 (256)
165 `
166 parser = newParser(strings.NewReader(s))
167 _, err = parser.parse()
168 assert.Equal(t,
169 "Line 2: Transfer(1)A-B:10(256)\n, err: Fee 256 can not be bigger than 255",
170 err.Error())
171
172 // check that the PoolTransfer & Transfer are only accepted in the
173 // correct case case (PoolTxs/BlockchainTxs)
174 s = `
175 Type: PoolL2
176 Transfer(1) A-B: 10 (1)
177 `
178 parser = newParser(strings.NewReader(s))
179 _, err = parser.parse()
180 assert.Equal(t, "Line 2: Transfer, err: Unexpected PoolL2 tx type: Transfer", err.Error())
181 s = `
182 Type: Blockchain
183 PoolTransfer(1) A-B: 10 (1)
184 `
185 parser = newParser(strings.NewReader(s))
186 _, err = parser.parse()
187 assert.Equal(t,
188 "Line 2: PoolTransfer, err: Unexpected Blockchain tx type: PoolTransfer",
189 err.Error())
190
191 s = `
192 Type: Blockchain
193 > btch
194 `
195 parser = newParser(strings.NewReader(s))
196 _, err = parser.parse()
197 assert.Equal(t,
198 "Line 2: >, err: Unexpected '> btch', expected '> batch' or '> block'",
199 err.Error())
200
201 // check definition of set Type
202 s = `PoolTransfer(1) A-B: 10 (1)`
203 parser = newParser(strings.NewReader(s))
204 _, err = parser.parse()
205 assert.Equal(t, "Line 1: PoolTransfer, err: Set type not defined", err.Error())
206 s = `Type: PoolL1`
207 parser = newParser(strings.NewReader(s))
208 _, err = parser.parse()
209 assert.Equal(t,
210 "Line 1: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'",
211 err.Error())
212 s = `Type: PoolL1
213 Type: Blockchain`
214 parser = newParser(strings.NewReader(s))
215 _, err = parser.parse()
216 assert.Equal(t,
217 "Line 1: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'",
218 err.Error())
219 s = `Type: PoolL2
220 Type: Blockchain`
221 parser = newParser(strings.NewReader(s))
222 _, err = parser.parse()
223 assert.Equal(t,
224 "Line 2: Instruction of 'Type: Blockchain' when there is already a previous "+
225 "instruction 'Type: PoolL2' defined", err.Error())
226
227 s = `Type: Blockchain
228 AddToken(1)
229 AddToken(0)
230 `
231 parser = newParser(strings.NewReader(s))
232 _, err = parser.parse()
233 assert.Equal(t, "Line 3: AddToken can not register TokenID 0", err.Error())
234}