basic_nft_test.gno

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