basic_nft_test.gno
11.49 Kb ยท 377 lines
1package grc721
2
3import (
4 "std"
5 "testing"
6
7 "gno.land/p/nt/testutils"
8 "gno.land/p/nt/uassert"
9)
10
11var (
12 dummyNFTName = "DummyNFT"
13 dummyNFTSymbol = "DNFT"
14)
15
16func TestNewBasicNFT(t *testing.T) {
17 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
18 uassert.True(t, dummy != nil, "should not be nil")
19}
20
21func TestName(t *testing.T) {
22 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
23 uassert.True(t, dummy != nil, "should not be nil")
24
25 name := dummy.Name()
26 uassert.Equal(t, dummyNFTName, name)
27}
28
29func TestSymbol(t *testing.T) {
30 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
31 uassert.True(t, dummy != nil, "should not be nil")
32
33 symbol := dummy.Symbol()
34 uassert.Equal(t, dummyNFTSymbol, symbol)
35}
36
37func TestTokenCount(t *testing.T) {
38 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
39 uassert.True(t, dummy != nil, "should not be nil")
40
41 count := dummy.TokenCount()
42 uassert.Equal(t, int64(0), count)
43
44 dummy.mint("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm", TokenID("1"))
45 dummy.mint("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm", TokenID("2"))
46
47 count = dummy.TokenCount()
48 uassert.Equal(t, int64(2), count)
49}
50
51func TestBalanceOf(t *testing.T) {
52 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
53 uassert.True(t, dummy != nil, "should not be nil")
54
55 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
56 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
57
58 balanceAddr1, err := dummy.BalanceOf(addr1)
59 uassert.NoError(t, err, "should not result in error")
60 uassert.Equal(t, int64(0), balanceAddr1)
61
62 dummy.mint(addr1, TokenID("1"))
63 dummy.mint(addr1, TokenID("2"))
64 dummy.mint(addr2, TokenID("3"))
65
66 balanceAddr1, err = dummy.BalanceOf(addr1)
67 uassert.NoError(t, err, "should not result in error")
68
69 balanceAddr2, err := dummy.BalanceOf(addr2)
70 uassert.NoError(t, err, "should not result in error")
71
72 uassert.Equal(t, int64(2), balanceAddr1)
73 uassert.Equal(t, int64(1), balanceAddr2)
74}
75
76func TestOwnerOf(t *testing.T) {
77 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
78 uassert.True(t, dummy != nil, "should not be nil")
79
80 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
81 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
82
83 owner, err := dummy.OwnerOf(TokenID("invalid"))
84 uassert.Error(t, err, "should not result in error")
85
86 dummy.mint(addr1, TokenID("1"))
87 dummy.mint(addr2, TokenID("2"))
88
89 // Checking for token id "1"
90 owner, err = dummy.OwnerOf(TokenID("1"))
91 uassert.NoError(t, err, "should not result in error")
92 uassert.Equal(t, addr1.String(), owner.String())
93
94 // Checking for token id "2"
95 owner, err = dummy.OwnerOf(TokenID("2"))
96 uassert.NoError(t, err, "should not result in error")
97 uassert.Equal(t, addr2.String(), owner.String())
98}
99
100func TestIsApprovedForAll(t *testing.T) {
101 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
102 uassert.True(t, dummy != nil, "should not be nil")
103
104 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
105 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
106
107 isApprovedForAll := dummy.IsApprovedForAll(addr1, addr2)
108 uassert.False(t, isApprovedForAll)
109}
110
111func TestSetApprovalForAll(t *testing.T) {
112 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
113 uassert.True(t, dummy != nil, "should not be nil")
114
115 caller := std.CurrentRealm().Address()
116 testing.SetOriginCaller(caller)
117 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
118
119 // Test setting approval to true
120 isApprovedForAll := dummy.IsApprovedForAll(caller, addr)
121 uassert.False(t, isApprovedForAll)
122
123 // set beyond origin caller
124 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
125 err := dummy.SetApprovalForAll(addr, true)
126 uassert.NoError(t, err, "should not result in error")
127
128 isApprovedForAll = dummy.IsApprovedForAll(caller, addr)
129 uassert.True(t, isApprovedForAll)
130
131 // Test setting approval to false
132 err = dummy.SetApprovalForAll(addr, false)
133 uassert.NoError(t, err, "should not result in error")
134
135 isApprovedForAll = dummy.IsApprovedForAll(caller, addr)
136 uassert.False(t, isApprovedForAll)
137}
138
139func TestGetApproved(t *testing.T) {
140 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
141 uassert.True(t, dummy != nil, "should not be nil")
142
143 _, err := dummy.GetApproved(TokenID("invalid"))
144 uassert.Error(t, err, "should result in error")
145}
146
147func TestApprove(t *testing.T) {
148 alice := testutils.TestAddress("alice")
149 testing.SetOriginCaller(alice)
150
151 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
152 uassert.True(t, dummy != nil, "should not be nil")
153
154 caller := std.CurrentRealm().Address()
155 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
156
157 err := dummy.mint(caller, TokenID("1"))
158 uassert.NoError(t, err, "failed to mint")
159
160 _, err = dummy.GetApproved(TokenID("1"))
161 uassert.Error(t, err, "should result in error")
162
163 testing.SetRealm(std.NewUserRealm(alice))
164 func() {
165 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
166 err = dummy.Approve(addr, TokenID("1"))
167 uassert.NoError(t, err, "should not result in error")
168
169 approvedAddr, err := dummy.GetApproved(TokenID("1"))
170 uassert.NoError(t, err, "should result in error")
171 uassert.Equal(t, addr.String(), approvedAddr.String())
172 }()
173}
174
175func TestTransferFrom(t *testing.T) {
176 alice := testutils.TestAddress("alice")
177 testing.SetOriginCaller(alice)
178
179 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
180 uassert.True(t, dummy != nil, "should not be nil")
181
182 caller := std.CurrentRealm().Address()
183 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
184
185 dummy.mint(caller, TokenID("1"))
186 dummy.mint(caller, TokenID("2"))
187
188 testing.SetRealm(std.NewUserRealm(alice))
189 func() {
190 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
191
192 err := dummy.TransferFrom(caller, addr, TokenID("1"))
193 uassert.NoError(t, err, "should result in error")
194
195 // Check balance of caller after transfer
196 balanceOfCaller, err := dummy.BalanceOf(caller)
197 uassert.NoError(t, err, "should result in error")
198 uassert.Equal(t, int64(1), balanceOfCaller)
199
200 // Check balance of addr after transfer
201 balanceOfAddr, err := dummy.BalanceOf(addr)
202 uassert.NoError(t, err, "should not result in error")
203 uassert.Equal(t, int64(1), balanceOfAddr)
204
205 // Check Owner of transferred Token id
206 owner, err := dummy.OwnerOf(TokenID("1"))
207 uassert.NoError(t, err, "should result in error")
208 uassert.Equal(t, addr.String(), owner.String())
209 }()
210}
211
212func TestSafeTransferFrom(t *testing.T) {
213 alice := testutils.TestAddress("alice")
214 testing.SetOriginCaller(alice)
215
216 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
217 uassert.True(t, dummy != nil, "should not be nil")
218
219 caller := std.CurrentRealm().Address()
220 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
221
222 dummy.mint(caller, TokenID("1"))
223 dummy.mint(caller, TokenID("2"))
224
225 testing.SetRealm(std.NewUserRealm(alice))
226 func() {
227 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
228
229 err := dummy.SafeTransferFrom(caller, addr, TokenID("1"))
230 uassert.NoError(t, err, "should not result in error")
231
232 // Check balance of caller after transfer
233 balanceOfCaller, err := dummy.BalanceOf(caller)
234 uassert.NoError(t, err, "should not result in error")
235 uassert.Equal(t, int64(1), balanceOfCaller)
236
237 // Check balance of addr after transfer
238 balanceOfAddr, err := dummy.BalanceOf(addr)
239 uassert.NoError(t, err, "should not result in error")
240 uassert.Equal(t, int64(1), balanceOfAddr)
241
242 // Check Owner of transferred Token id
243 owner, err := dummy.OwnerOf(TokenID("1"))
244 uassert.NoError(t, err, "should not result in error")
245 uassert.Equal(t, addr.String(), owner.String())
246 }()
247}
248
249func TestMint(t *testing.T) {
250 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
251 uassert.True(t, dummy != nil, "should not be nil")
252
253 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
254 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
255
256 err := dummy.Mint(addr1, TokenID("1"))
257 uassert.NoError(t, err, "should not result in error")
258 err = dummy.Mint(addr1, TokenID("2"))
259 uassert.NoError(t, err, "should not result in error")
260 err = dummy.Mint(addr2, TokenID("3"))
261 uassert.NoError(t, err, "should not result in error")
262
263 // Try minting duplicate token id
264 err = dummy.Mint(addr2, TokenID("1"))
265 uassert.Error(t, err, "should not result in error")
266
267 // Check Owner of Token id
268 owner, err := dummy.OwnerOf(TokenID("1"))
269 uassert.NoError(t, err, "should not result in error")
270 uassert.Equal(t, addr1.String(), owner.String())
271}
272
273func TestBurn(t *testing.T) {
274 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
275 uassert.True(t, dummy != nil, "should not be nil")
276
277 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
278
279 dummy.mint(addr, TokenID("1"))
280 dummy.mint(addr, TokenID("2"))
281
282 err := dummy.Burn(TokenID("1"))
283 uassert.NoError(t, err, "should not result in error")
284
285 // Check Owner of Token id
286 _, err = dummy.OwnerOf(TokenID("1"))
287 uassert.Error(t, err, "should result in error")
288}
289
290func TestSetTokenURI(t *testing.T) {
291 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
292 uassert.True(t, dummy != nil, "should not be nil")
293
294 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
295 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
296 tokenURI := "http://example.com/token"
297
298 testing.SetOriginCaller(addr1) // addr1
299
300 dummy.mint(addr1, TokenID("1"))
301
302 testing.SetRealm(std.NewUserRealm(addr1))
303 func() {
304 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
305
306 _, derr := dummy.SetTokenURI(TokenID("1"), TokenURI(tokenURI))
307 uassert.NoError(t, derr, "should not result in error")
308
309 // Test case: Invalid token ID
310 _, err := dummy.SetTokenURI(TokenID("3"), TokenURI(tokenURI))
311 uassert.ErrorIs(t, err, ErrInvalidTokenId)
312
313 testing.SetOriginCaller(addr2) // addr2
314 func() {
315 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
316 _, cerr := dummy.SetTokenURI(TokenID("1"), TokenURI(tokenURI)) // addr2 trying to set URI for token 1
317 uassert.ErrorIs(t, cerr, ErrCallerIsNotOwner)
318
319 // Test case: Retrieving TokenURI
320 testing.SetOriginCaller(addr1) // addr1
321
322 dummyTokenURI, err := dummy.TokenURI(TokenID("1"))
323 uassert.NoError(t, err, "TokenURI error")
324 uassert.Equal(t, string(tokenURI), string(dummyTokenURI))
325 }()
326 }()
327}
328
329func TestIsApprovedOrOwner(t *testing.T) {
330 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
331 uassert.True(t, dummy != nil, "should not be nil")
332
333 var (
334 owner = testutils.TestAddress("owner")
335 operator = testutils.TestAddress("operator")
336 approved = testutils.TestAddress("approved")
337 other = testutils.TestAddress("other")
338 )
339
340 tid := TokenID("1")
341
342 err := dummy.mint(owner, tid)
343 uassert.NoError(t, err)
344
345 // check owner
346 isApprovedOrOwner := dummy.isApprovedOrOwner(owner, tid)
347 uassert.True(t, isApprovedOrOwner, "owner should be approved")
348
349 // check operator
350 testing.SetOriginCaller(owner)
351 func() {
352 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
353
354 err = dummy.SetApprovalForAll(operator, true)
355 uassert.NoError(t, err)
356 isApprovedOrOwner = dummy.isApprovedOrOwner(operator, tid)
357 uassert.True(t, isApprovedOrOwner, "operator should be approved")
358
359 // check approved
360 testing.SetOriginCaller(owner)
361 func() {
362 testing.SetRealm(std.NewCodeRealm("gno.land/r/test/test"))
363 err = dummy.Approve(approved, tid)
364 uassert.NoError(t, err)
365 isApprovedOrOwner = dummy.isApprovedOrOwner(approved, tid)
366 uassert.True(t, isApprovedOrOwner, "approved address should be approved")
367
368 // check other
369 isApprovedOrOwner = dummy.isApprovedOrOwner(other, tid)
370 uassert.False(t, isApprovedOrOwner, "other address should not be approved")
371
372 // check non-existent token
373 isApprovedOrOwner = dummy.isApprovedOrOwner(owner, TokenID("999"))
374 uassert.False(t, isApprovedOrOwner, "non-existent token should not be approved")
375 }()
376 }()
377}
