basic_grc1155_token_test.gno
10.58 Kb ยท 299 lines
1package grc1155
2
3import (
4 "std"
5 "testing"
6
7 "gno.land/p/demo/testutils"
8 "gno.land/p/demo/uassert"
9)
10
11const dummyURI = "ipfs://xyz"
12
13func TestNewBasicGRC1155Token(t *testing.T) {
14 dummy := NewBasicGRC1155Token(dummyURI)
15 uassert.True(t, dummy != nil, "should not be nil")
16}
17
18func TestUri(t *testing.T) {
19 dummy := NewBasicGRC1155Token(dummyURI)
20 uassert.True(t, dummy != nil, "should not be nil")
21 uassert.Equal(t, dummyURI, dummy.Uri())
22}
23
24func TestBalanceOf(t *testing.T) {
25 dummy := NewBasicGRC1155Token(dummyURI)
26 uassert.True(t, dummy != nil, "should not be nil")
27
28 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
29 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
30
31 tid1 := TokenID("1")
32 tid2 := TokenID("2")
33
34 _, err := dummy.BalanceOf(zeroAddress, tid1)
35 uassert.Error(t, err, "should result in error")
36
37 balanceAddr1OfToken1, err := dummy.BalanceOf(addr1, tid1)
38 uassert.NoError(t, err, "should not result in error")
39 uassert.Equal(t, int64(0), balanceAddr1OfToken1)
40
41 dummy.mintBatch(addr1, []TokenID{tid1, tid2}, []int64{10, 100})
42 dummy.mintBatch(addr2, []TokenID{tid1}, []int64{20})
43
44 balanceAddr1OfToken1, err = dummy.BalanceOf(addr1, tid1)
45 uassert.NoError(t, err, "should not result in error")
46 balanceAddr1OfToken2, err := dummy.BalanceOf(addr1, tid2)
47 uassert.NoError(t, err, "should not result in error")
48 balanceAddr2OfToken1, err := dummy.BalanceOf(addr2, tid1)
49 uassert.NoError(t, err, "should not result in error")
50
51 uassert.Equal(t, int64(10), balanceAddr1OfToken1)
52 uassert.Equal(t, int64(100), balanceAddr1OfToken2)
53 uassert.Equal(t, int64(20), balanceAddr2OfToken1)
54}
55
56func TestBalanceOfBatch(t *testing.T) {
57 dummy := NewBasicGRC1155Token(dummyURI)
58 uassert.True(t, dummy != nil, "should not be nil")
59
60 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
61 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
62
63 tid1 := TokenID("1")
64 tid2 := TokenID("2")
65
66 balanceBatch, err := dummy.BalanceOfBatch([]std.Address{addr1, addr2}, []TokenID{tid1, tid2})
67 uassert.NoError(t, err, "should not result in error")
68 uassert.Equal(t, int64(0), balanceBatch[0])
69 uassert.Equal(t, int64(0), balanceBatch[1])
70
71 dummy.mintBatch(addr1, []TokenID{tid1}, []int64{10})
72 dummy.mintBatch(addr2, []TokenID{tid2}, []int64{20})
73
74 balanceBatch, err = dummy.BalanceOfBatch([]std.Address{addr1, addr2}, []TokenID{tid1, tid2})
75 uassert.NoError(t, err, "should not result in error")
76 uassert.Equal(t, int64(10), balanceBatch[0])
77 uassert.Equal(t, int64(20), balanceBatch[1])
78}
79
80func TestIsApprovedForAll(t *testing.T) {
81 dummy := NewBasicGRC1155Token(dummyURI)
82 uassert.True(t, dummy != nil, "should not be nil")
83
84 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
85 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
86
87 isApprovedForAll := dummy.IsApprovedForAll(addr1, addr2)
88 uassert.False(t, isApprovedForAll)
89}
90
91func TestSetApprovalForAll(t *testing.T) {
92 //alice := testutils.TestAddress("alice")
93 //testing.SetOriginCaller(alice)
94
95 dummy := NewBasicGRC1155Token(dummyURI)
96 uassert.True(t, dummy != nil, "should not be nil")
97
98 caller := std.OriginCaller()
99 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
100
101 isApprovedForAll := dummy.IsApprovedForAll(caller, addr)
102 uassert.False(t, isApprovedForAll)
103
104 err := dummy.SetApprovalForAll(addr, true)
105 uassert.NoError(t, err, "should not result in error")
106
107 isApprovedForAll = dummy.IsApprovedForAll(caller, addr)
108 uassert.True(t, isApprovedForAll)
109
110 err = dummy.SetApprovalForAll(addr, false)
111 uassert.NoError(t, err, "should not result in error")
112
113 isApprovedForAll = dummy.IsApprovedForAll(caller, addr)
114 uassert.False(t, isApprovedForAll)
115}
116
117func TestSafeTransferFrom(t *testing.T) {
118 alice := testutils.TestAddress("alice")
119 testing.SetOriginCaller(alice)
120
121 dummy := NewBasicGRC1155Token(dummyURI)
122 uassert.True(t, dummy != nil, "should not be nil")
123
124 caller := std.OriginCaller()
125 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
126
127 tid := TokenID("1")
128
129 dummy.mintBatch(caller, []TokenID{tid}, []int64{100})
130
131 err := dummy.SafeTransferFrom(caller, zeroAddress, tid, 10)
132 uassert.Error(t, err, "should result in error")
133
134 err = dummy.SafeTransferFrom(caller, addr, tid, 160)
135 uassert.Error(t, err, "should result in error")
136
137 err = dummy.SafeTransferFrom(caller, addr, tid, 60)
138 uassert.NoError(t, err, "should not result in error")
139
140 // Check balance of caller after transfer
141 balanceOfCaller, err := dummy.BalanceOf(caller, tid)
142 uassert.NoError(t, err, "should not result in error")
143 uassert.Equal(t, int64(40), balanceOfCaller)
144
145 // Check balance of addr after transfer
146 balanceOfAddr, err := dummy.BalanceOf(addr, tid)
147 uassert.NoError(t, err, "should not result in error")
148 uassert.Equal(t, int64(60), balanceOfAddr)
149}
150
151func TestSafeBatchTransferFrom(t *testing.T) {
152 alice := testutils.TestAddress("alice")
153 testing.SetOriginCaller(alice)
154
155 dummy := NewBasicGRC1155Token(dummyURI)
156 uassert.True(t, dummy != nil, "should not be nil")
157
158 caller := std.OriginCaller()
159 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
160
161 tid1 := TokenID("1")
162 tid2 := TokenID("2")
163
164 dummy.mintBatch(caller, []TokenID{tid1, tid2}, []int64{10, 100})
165
166 err := dummy.SafeBatchTransferFrom(caller, zeroAddress, []TokenID{tid1, tid2}, []int64{4, 60})
167 uassert.Error(t, err, "should result in error")
168 err = dummy.SafeBatchTransferFrom(caller, addr, []TokenID{tid1, tid2}, []int64{40, 60})
169 uassert.Error(t, err, "should result in error")
170 err = dummy.SafeBatchTransferFrom(caller, addr, []TokenID{tid1}, []int64{40, 60})
171 uassert.Error(t, err, "should result in error")
172 err = dummy.SafeBatchTransferFrom(caller, addr, []TokenID{tid1, tid2}, []int64{4, 60})
173 uassert.NoError(t, err, "should not result in error")
174
175 balanceBatch, err := dummy.BalanceOfBatch([]std.Address{caller, addr, caller, addr}, []TokenID{tid1, tid1, tid2, tid2})
176 uassert.NoError(t, err, "should not result in error")
177
178 // Check token1's balance of caller after batch transfer
179 uassert.Equal(t, int64(6), balanceBatch[0])
180
181 // Check token1's balance of addr after batch transfer
182 uassert.Equal(t, int64(4), balanceBatch[1])
183
184 // Check token2's balance of caller after batch transfer
185 uassert.Equal(t, int64(40), balanceBatch[2])
186
187 // Check token2's balance of addr after batch transfer
188 uassert.Equal(t, int64(60), balanceBatch[3])
189}
190
191func TestSafeMint(t *testing.T) {
192 dummy := NewBasicGRC1155Token(dummyURI)
193 uassert.True(t, dummy != nil, "should not be nil")
194
195 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
196 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
197
198 tid1 := TokenID("1")
199 tid2 := TokenID("2")
200
201 err := dummy.SafeMint(zeroAddress, tid1, 100)
202 uassert.Error(t, err, "should result in error")
203 err = dummy.SafeMint(addr1, tid1, 100)
204 uassert.NoError(t, err, "should not result in error")
205 err = dummy.SafeMint(addr1, tid2, 200)
206 uassert.NoError(t, err, "should not result in error")
207 err = dummy.SafeMint(addr2, tid1, 50)
208 uassert.NoError(t, err, "should not result in error")
209
210 balanceBatch, err := dummy.BalanceOfBatch([]std.Address{addr1, addr2, addr1}, []TokenID{tid1, tid1, tid2})
211 uassert.NoError(t, err, "should not result in error")
212 // Check token1's balance of addr1 after mint
213 uassert.Equal(t, int64(100), balanceBatch[0])
214 // Check token1's balance of addr2 after mint
215 uassert.Equal(t, int64(50), balanceBatch[1])
216 // Check token2's balance of addr1 after mint
217 uassert.Equal(t, int64(200), balanceBatch[2])
218}
219
220func TestSafeBatchMint(t *testing.T) {
221 dummy := NewBasicGRC1155Token(dummyURI)
222 uassert.True(t, dummy != nil, "should not be nil")
223
224 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
225 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
226
227 tid1 := TokenID("1")
228 tid2 := TokenID("2")
229
230 err := dummy.SafeBatchMint(zeroAddress, []TokenID{tid1, tid2}, []int64{100, 200})
231 uassert.Error(t, err, "should result in error")
232 err = dummy.SafeBatchMint(addr1, []TokenID{tid1, tid2}, []int64{100, 200})
233 uassert.NoError(t, err, "should not result in error")
234 err = dummy.SafeBatchMint(addr2, []TokenID{tid1, tid2}, []int64{300, 400})
235 uassert.NoError(t, err, "should not result in error")
236
237 balanceBatch, err := dummy.BalanceOfBatch([]std.Address{addr1, addr2, addr1, addr2}, []TokenID{tid1, tid1, tid2, tid2})
238 uassert.NoError(t, err, "should not result in error")
239 // Check token1's balance of addr1 after batch mint
240 uassert.Equal(t, int64(100), balanceBatch[0])
241 // Check token1's balance of addr2 after batch mint
242 uassert.Equal(t, int64(300), balanceBatch[1])
243 // Check token2's balance of addr1 after batch mint
244 uassert.Equal(t, int64(200), balanceBatch[2])
245 // Check token2's balance of addr2 after batch mint
246 uassert.Equal(t, int64(400), balanceBatch[3])
247}
248
249func TestBurn(t *testing.T) {
250 dummy := NewBasicGRC1155Token(dummyURI)
251 uassert.True(t, dummy != nil, "should not be nil")
252
253 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
254
255 tid1 := TokenID("1")
256 tid2 := TokenID("2")
257
258 dummy.mintBatch(addr, []TokenID{tid1, tid2}, []int64{100, 200})
259 err := dummy.Burn(zeroAddress, tid1, int64(60))
260 uassert.Error(t, err, "should result in error")
261 err = dummy.Burn(addr, tid1, int64(160))
262 uassert.Error(t, err, "should result in error")
263 err = dummy.Burn(addr, tid1, int64(60))
264 uassert.NoError(t, err, "should not result in error")
265 err = dummy.Burn(addr, tid2, int64(60))
266 uassert.NoError(t, err, "should not result in error")
267 balanceBatch, err := dummy.BalanceOfBatch([]std.Address{addr, addr}, []TokenID{tid1, tid2})
268 uassert.NoError(t, err, "should not result in error")
269
270 // Check token1's balance of addr after burn
271 uassert.Equal(t, int64(40), balanceBatch[0])
272 // Check token2's balance of addr after burn
273 uassert.Equal(t, int64(140), balanceBatch[1])
274}
275
276func TestBatchBurn(t *testing.T) {
277 dummy := NewBasicGRC1155Token(dummyURI)
278 uassert.True(t, dummy != nil, "should not be nil")
279
280 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
281
282 tid1 := TokenID("1")
283 tid2 := TokenID("2")
284
285 dummy.mintBatch(addr, []TokenID{tid1, tid2}, []int64{100, 200})
286 err := dummy.BatchBurn(zeroAddress, []TokenID{tid1, tid2}, []int64{60, 60})
287 uassert.Error(t, err, "should result in error")
288 err = dummy.BatchBurn(addr, []TokenID{tid1, tid2}, []int64{160, 60})
289 uassert.Error(t, err, "should result in error")
290 err = dummy.BatchBurn(addr, []TokenID{tid1, tid2}, []int64{60, 60})
291 uassert.NoError(t, err, "should not result in error")
292 balanceBatch, err := dummy.BalanceOfBatch([]std.Address{addr, addr}, []TokenID{tid1, tid2})
293 uassert.NoError(t, err, "should not result in error")
294
295 // Check token1's balance of addr after batch burn
296 uassert.Equal(t, int64(40), balanceBatch[0])
297 // Check token2's balance of addr after batch burn
298 uassert.Equal(t, int64(140), balanceBatch[1])
299}
