1package transakcio
  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		// deposits
 18		Deposit(1) A: 10
 19		Deposit(2) A: 20
 20		Deposit(1) B: 5
 21		CreateAccountDeposit(1) C: 5
 22		CreateAccountDepositTransfer(1) D-A: 15, 10 (3)
 23
 24		// L2 transactions
 25		Transfer(1) A-B: 6 (1)
 26		Transfer(1) B-D: 3 (1)
 27
 28		// set new batch
 29		> batch
 30
 31		DepositTransfer(1) A-B: 15, 10 (1)
 32		Transfer(1) C-A : 3 (1)
 33		Transfer(2) A-B: 15 (1)
 34
 35		Deposit(1) User0: 20
 36		Deposit(3) User1: 20
 37		Transfer(1) User0-User1: 15 (1)
 38		Transfer(3) User1-User0: 15 (1)
 39
 40		> batch
 41
 42		Transfer(1) User1-User0: 1 (1)
 43
 44		> batch
 45		> block
 46
 47		// Exits
 48		Exit(1) A: 5
 49	`
 50
 51	parser := newParser(strings.NewReader(s))
 52	instructions, err := parser.parse()
 53	require.Nil(t, err)
 54	assert.Equal(t, 20, len(instructions.instructions))
 55	assert.Equal(t, 6, len(instructions.accounts))
 56	assert.Equal(t, 3, len(instructions.tokenIDs))
 57
 58	if debug {
 59		fmt.Println(instructions)
 60		for _, instruction := range instructions.instructions {
 61			fmt.Println(instruction.raw())
 62		}
 63	}
 64
 65	assert.Equal(t, typeNewBatch, instructions.instructions[7].typ)
 66	assert.Equal(t, "Deposit(1)User0:20", instructions.instructions[11].raw())
 67	assert.Equal(t, "Type: DepositTransfer, From: A, To: B, LoadAmount: 15, Amount: 10, Fee: 1, TokenID: 1\n", instructions.instructions[8].String())
 68	assert.Equal(t, "Type: Transfer, From: User1, To: User0, Amount: 15, Fee: 1, TokenID: 3\n", instructions.instructions[14].String())
 69	assert.Equal(t, "Transfer(2)A-B:15(1)", instructions.instructions[10].raw())
 70	assert.Equal(t, "Type: Transfer, From: A, To: B, Amount: 15, Fee: 1, TokenID: 2\n", instructions.instructions[10].String())
 71	assert.Equal(t, "Exit(1)A:5", instructions.instructions[19].raw())
 72	assert.Equal(t, "Type: Exit, From: A, Amount: 5, TokenID: 1\n", instructions.instructions[19].String())
 73}
 74
 75func TestParsePoolTxs(t *testing.T) {
 76	s := `
 77		Type: PoolL2
 78		PoolTransfer(1) A-B: 6 (1)
 79		PoolTransfer(2) A-B: 3 (3)
 80		PoolTransfer(1) B-D: 3 (1)
 81		PoolTransfer(1) C-D: 3 (1)
 82		PoolExit(1) A: 5
 83	`
 84
 85	parser := newParser(strings.NewReader(s))
 86	instructions, err := parser.parse()
 87	require.Nil(t, err)
 88	assert.Equal(t, 5, len(instructions.instructions))
 89	assert.Equal(t, 4, len(instructions.accounts))
 90	assert.Equal(t, 2, len(instructions.tokenIDs))
 91
 92	if debug {
 93		fmt.Println(instructions)
 94		for _, instruction := range instructions.instructions {
 95			fmt.Println(instruction.raw())
 96		}
 97	}
 98
 99	assert.Equal(t, "Transfer(1)A-B:6(1)", instructions.instructions[0].raw())
100	assert.Equal(t, "Transfer(2)A-B:3(3)", instructions.instructions[1].raw())
101	assert.Equal(t, "Transfer(1)B-D:3(1)", instructions.instructions[2].raw())
102	assert.Equal(t, "Transfer(1)C-D:3(1)", instructions.instructions[3].raw())
103	assert.Equal(t, "Exit(1)A:5", instructions.instructions[4].raw())
104}
105
106func TestParseErrors(t *testing.T) {
107	s := `
108		Type: Blockchain
109		Deposit(1) A:: 10
110	`
111	parser := newParser(strings.NewReader(s))
112	_, err := parser.parse()
113	assert.Equal(t, "error parsing line 1: Deposit(1)A:: 10\n, err: strconv.Atoi: parsing \":\": invalid syntax", err.Error())
114
115	s = `
116		Type: Blockchain
117		Deposit(1) A: 10 20
118	`
119	parser = newParser(strings.NewReader(s))
120	_, err = parser.parse()
121	assert.Equal(t, "error parsing line 2: 20, err: Unexpected tx type: 20", err.Error())
122
123	s = `
124		Type: Blockchain
125		Transfer(1) A: 10
126	`
127	parser = newParser(strings.NewReader(s))
128	_, err = parser.parse()
129	assert.Equal(t, "error parsing line 1: Transfer(1)A:, err: Expected '-', found ':'", err.Error())
130
131	s = `
132		Type: Blockchain
133		Transfer(1) A B: 10
134	`
135	parser = newParser(strings.NewReader(s))
136	_, err = parser.parse()
137	assert.Equal(t, "error parsing line 1: Transfer(1)AB, err: Expected '-', found 'B'", err.Error())
138
139	s = `
140		Type: Blockchain
141		Transfer(1) A-B: 10 (255)
142	`
143	parser = newParser(strings.NewReader(s))
144	_, err = parser.parse()
145	assert.Nil(t, err)
146	s = `
147		Type: Blockchain
148		Transfer(1) A-B: 10 (256)
149	`
150	parser = newParser(strings.NewReader(s))
151	_, err = parser.parse()
152	assert.Equal(t, "error parsing line 1: Transfer(1)A-B:10(256)\n, err: Fee 256 can not be bigger than 255", err.Error())
153
154	// check that the PoolTransfer & Transfer are only accepted in the
155	// correct case case (PoolTxs/BlockchainTxs)
156	s = `
157		Type: PoolL2
158		Transfer(1) A-B: 10 (1)
159	`
160	parser = newParser(strings.NewReader(s))
161	_, err = parser.parse()
162	assert.Equal(t, "error parsing line 1: Transfer, err: Unexpected 'Transfer' in a non Blockchain set", err.Error())
163	s = `
164		Type: Blockchain
165		PoolTransfer(1) A-B: 10 (1)
166	`
167	parser = newParser(strings.NewReader(s))
168	_, err = parser.parse()
169	assert.Equal(t, "error parsing line 1: PoolTransfer, err: Unexpected 'PoolTransfer' in a non PoolL2 set", err.Error())
170
171	s = `
172		Type: Blockchain
173		> btch
174	`
175	parser = newParser(strings.NewReader(s))
176	_, err = parser.parse()
177	assert.Equal(t, "error parsing line 1: >, err: Unexpected '> btch', expected '> batch' or '> block'", err.Error())
178
179	// check definition of set Type
180	s = `PoolTransfer(1) A-B: 10 (1)`
181	parser = newParser(strings.NewReader(s))
182	_, err = parser.parse()
183	assert.Equal(t, "error parsing line 0: PoolTransfer, err: Set type not defined", err.Error())
184	s = `Type: PoolL1`
185	parser = newParser(strings.NewReader(s))
186	_, err = parser.parse()
187	assert.Equal(t, "error parsing line 0: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'", err.Error())
188	s = `Type: PoolL1
189		Type: Blockchain`
190	parser = newParser(strings.NewReader(s))
191	_, err = parser.parse()
192	assert.Equal(t, "error parsing line 0: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'", err.Error())
193}