basic_nft_test.gno
10.35 Kb ยท 335 lines
1package grc721
2
3import (
4 "std"
5 "testing"
6
7 "gno.land/p/demo/testutils"
8 "gno.land/p/demo/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, uint64(0), count)
43
44 dummy.mint("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm", TokenID("1"))
45 dummy.mint("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm", TokenID("2"))
46
47 count = dummy.TokenCount()
48 uassert.Equal(t, uint64(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, uint64(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, uint64(2), balanceAddr1)
73 uassert.Equal(t, uint64(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.PreviousRealm().Address()
116 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
117
118 // Test setting approval to true
119 isApprovedForAll := dummy.IsApprovedForAll(caller, addr)
120 uassert.False(t, isApprovedForAll)
121
122 err := dummy.SetApprovalForAll(addr, true)
123 uassert.NoError(t, err, "should not result in error")
124
125 isApprovedForAll = dummy.IsApprovedForAll(caller, addr)
126 uassert.True(t, isApprovedForAll)
127
128 // Test setting approval to false
129 err = dummy.SetApprovalForAll(addr, false)
130 uassert.NoError(t, err, "should not result in error")
131
132 isApprovedForAll = dummy.IsApprovedForAll(caller, addr)
133 uassert.False(t, isApprovedForAll)
134}
135
136func TestGetApproved(t *testing.T) {
137 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
138 uassert.True(t, dummy != nil, "should not be nil")
139
140 _, err := dummy.GetApproved(TokenID("invalid"))
141 uassert.Error(t, err, "should result in error")
142}
143
144func TestApprove(t *testing.T) {
145 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
146 uassert.True(t, dummy != nil, "should not be nil")
147
148 caller := std.PreviousRealm().Address()
149 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
150
151 dummy.mint(caller, TokenID("1"))
152
153 _, err := dummy.GetApproved(TokenID("1"))
154 uassert.Error(t, err, "should result in error")
155
156 err = dummy.Approve(addr, TokenID("1"))
157 uassert.NoError(t, err, "should not result in error")
158
159 approvedAddr, err := dummy.GetApproved(TokenID("1"))
160 uassert.NoError(t, err, "should result in error")
161 uassert.Equal(t, addr.String(), approvedAddr.String())
162}
163
164func TestTransferFrom(t *testing.T) {
165 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
166 uassert.True(t, dummy != nil, "should not be nil")
167
168 caller := std.PreviousRealm().Address()
169 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
170
171 dummy.mint(caller, TokenID("1"))
172 dummy.mint(caller, TokenID("2"))
173
174 err := dummy.TransferFrom(caller, addr, TokenID("1"))
175 uassert.NoError(t, err, "should result in error")
176
177 // Check balance of caller after transfer
178 balanceOfCaller, err := dummy.BalanceOf(caller)
179 uassert.NoError(t, err, "should result in error")
180 uassert.Equal(t, uint64(1), balanceOfCaller)
181
182 // Check balance of addr after transfer
183 balanceOfAddr, err := dummy.BalanceOf(addr)
184 uassert.NoError(t, err, "should not result in error")
185 uassert.Equal(t, uint64(1), balanceOfAddr)
186
187 // Check Owner of transferred Token id
188 owner, err := dummy.OwnerOf(TokenID("1"))
189 uassert.NoError(t, err, "should result in error")
190 uassert.Equal(t, addr.String(), owner.String())
191}
192
193func TestSafeTransferFrom(t *testing.T) {
194 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
195 uassert.True(t, dummy != nil, "should not be nil")
196
197 caller := std.PreviousRealm().Address()
198 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
199
200 dummy.mint(caller, TokenID("1"))
201 dummy.mint(caller, TokenID("2"))
202
203 err := dummy.SafeTransferFrom(caller, addr, TokenID("1"))
204 uassert.NoError(t, err, "should not result in error")
205
206 // Check balance of caller after transfer
207 balanceOfCaller, err := dummy.BalanceOf(caller)
208 uassert.NoError(t, err, "should not result in error")
209 uassert.Equal(t, uint64(1), balanceOfCaller)
210
211 // Check balance of addr after transfer
212 balanceOfAddr, err := dummy.BalanceOf(addr)
213 uassert.NoError(t, err, "should not result in error")
214 uassert.Equal(t, uint64(1), balanceOfAddr)
215
216 // Check Owner of transferred Token id
217 owner, err := dummy.OwnerOf(TokenID("1"))
218 uassert.NoError(t, err, "should not result in error")
219 uassert.Equal(t, addr.String(), owner.String())
220}
221
222func TestMint(t *testing.T) {
223 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
224 uassert.True(t, dummy != nil, "should not be nil")
225
226 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
227 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
228
229 err := dummy.Mint(addr1, TokenID("1"))
230 uassert.NoError(t, err, "should not result in error")
231 err = dummy.Mint(addr1, TokenID("2"))
232 uassert.NoError(t, err, "should not result in error")
233 err = dummy.Mint(addr2, TokenID("3"))
234 uassert.NoError(t, err, "should not result in error")
235
236 // Try minting duplicate token id
237 err = dummy.Mint(addr2, TokenID("1"))
238 uassert.Error(t, err, "should not result in error")
239
240 // Check Owner of Token id
241 owner, err := dummy.OwnerOf(TokenID("1"))
242 uassert.NoError(t, err, "should not result in error")
243 uassert.Equal(t, addr1.String(), owner.String())
244}
245
246func TestBurn(t *testing.T) {
247 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
248 uassert.True(t, dummy != nil, "should not be nil")
249
250 addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
251
252 dummy.mint(addr, TokenID("1"))
253 dummy.mint(addr, TokenID("2"))
254
255 err := dummy.Burn(TokenID("1"))
256 uassert.NoError(t, err, "should not result in error")
257
258 // Check Owner of Token id
259 _, err = dummy.OwnerOf(TokenID("1"))
260 uassert.Error(t, err, "should result in error")
261}
262
263func TestSetTokenURI(t *testing.T) {
264 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
265 uassert.True(t, dummy != nil, "should not be nil")
266
267 addr1 := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
268 addr2 := std.Address("g1us8428u2a5satrlxzagqqa5m6vmuze025anjlj")
269 tokenURI := "http://example.com/token"
270
271 testing.SetOriginCaller(addr1) // addr1
272
273 dummy.mint(addr1, TokenID("1"))
274 _, derr := dummy.SetTokenURI(TokenID("1"), TokenURI(tokenURI))
275 uassert.NoError(t, derr, "should not result in error")
276
277 // Test case: Invalid token ID
278 _, err := dummy.SetTokenURI(TokenID("3"), TokenURI(tokenURI))
279 uassert.ErrorIs(t, err, ErrInvalidTokenId)
280
281 testing.SetOriginCaller(addr2) // addr2
282
283 _, cerr := dummy.SetTokenURI(TokenID("1"), TokenURI(tokenURI)) // addr2 trying to set URI for token 1
284 uassert.ErrorIs(t, cerr, ErrCallerIsNotOwner)
285
286 // Test case: Retrieving TokenURI
287 testing.SetOriginCaller(addr1) // addr1
288
289 dummyTokenURI, err := dummy.TokenURI(TokenID("1"))
290 uassert.NoError(t, err, "TokenURI error")
291 uassert.Equal(t, string(tokenURI), string(dummyTokenURI))
292}
293
294func TestIsApprovedOrOwner(t *testing.T) {
295 dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
296 uassert.True(t, dummy != nil, "should not be nil")
297
298 var (
299 owner = testutils.TestAddress("owner")
300 operator = testutils.TestAddress("operator")
301 approved = testutils.TestAddress("approved")
302 other = testutils.TestAddress("other")
303 )
304
305 tid := TokenID("1")
306
307 err := dummy.mint(owner, tid)
308 uassert.NoError(t, err)
309
310 // check owner
311 isApprovedOrOwner := dummy.isApprovedOrOwner(owner, tid)
312 uassert.True(t, isApprovedOrOwner, "owner should be approved")
313
314 // check operator
315 testing.SetOriginCaller(owner)
316 err = dummy.SetApprovalForAll(operator, true)
317 uassert.NoError(t, err)
318 isApprovedOrOwner = dummy.isApprovedOrOwner(operator, tid)
319 uassert.True(t, isApprovedOrOwner, "operator should be approved")
320
321 // check approved
322 testing.SetOriginCaller(owner)
323 err = dummy.Approve(approved, tid)
324 uassert.NoError(t, err)
325 isApprovedOrOwner = dummy.isApprovedOrOwner(approved, tid)
326 uassert.True(t, isApprovedOrOwner, "approved address should be approved")
327
328 // check other
329 isApprovedOrOwner = dummy.isApprovedOrOwner(other, tid)
330 uassert.False(t, isApprovedOrOwner, "other address should not be approved")
331
332 // check non-existent token
333 isApprovedOrOwner = dummy.isApprovedOrOwner(owner, TokenID("999"))
334 uassert.False(t, isApprovedOrOwner, "non-existent token should not be approved")
335}
