Branch data Line data Source code
1 : : // SPDX-License-Identifier: UNLICENSED
2 : : pragma solidity ^0.8.10;
3 : :
4 : : import "forge-std/Test.sol";
5 : : import "../src/contracts/PurchaseToken.sol";
6 : : import "../src/contracts/TicketNFT.sol";
7 : :
8 : : contract BaseTicketNFTTest is Test {
9 : : // TicketNFT Events
10 : : event Transfer(
11 : : address indexed from,
12 : : address indexed to,
13 : : uint256 indexed ticketID
14 : : );
15 : : event Approval(
16 : : address indexed holder,
17 : : address indexed approved,
18 : : uint256 indexed ticketID
19 : : );
20 : :
21 : : // Primary Market Events
22 : : event Purchase(address indexed holder, string indexed holderName);
23 : :
24 : : // Secondary Market Events
25 : : event Listing(
26 : : uint256 indexed ticketID,
27 : : address indexed holder,
28 : : uint256 price
29 : : );
30 : : event Purchase(
31 : : address indexed purchaser,
32 : : uint256 indexed ticketID,
33 : : uint256 price,
34 : : string newName
35 : : );
36 : : event Delisting(uint256 indexed ticketID);
37 : :
38 : : uint256 public ticketPriceEth = 1e18;
39 : : uint256 public ticketPrice = 100e18;
40 : :
41 : : PurchaseToken public token;
42 : : TicketNFT public nft;
43 : :
44 : : address public alice = makeAddr("alice");
45 : : address public bob = makeAddr("bob");
46 : : address public charlie = makeAddr("charlie");
47 : :
48 : : function setUp() public {
49 : 0 : token = new PurchaseToken();
50 : 0 : nft = new TicketNFT(token);
51 : : }
52 : :
53 : : // Add Purchase Tokens to `recipient` to afford `amount` tickets
54 : : function _topUpTokens(address recipient, uint256 amount) internal {
55 : 0 : vm.deal(recipient, amount * ticketPriceEth);
56 : 0 : vm.prank(recipient);
57 : 0 : token.mint{value: amount * ticketPriceEth}();
58 : : }
59 : :
60 : : function _buyTicket(address recipient, string memory recipientName)
61 : : internal
62 : : {
63 : 0 : _topUpTokens(recipient, 1);
64 : 0 : vm.prank(recipient);
65 : 0 : token.approve(address(nft), ticketPrice);
66 : 0 : vm.prank(recipient);
67 : 0 : nft.purchase(recipientName);
68 : : }
69 : : }
70 : :
71 : : contract TicketNFTTest is BaseTicketNFTTest {
72 : : function testMint() public {
73 : : vm.prank(address(nft));
74 : : vm.expectEmit(true, true, true, false);
75 : : emit Transfer(address(0), alice, 1);
76 : : nft.mint(alice, "alice");
77 : : assertEq(nft.balanceOf(alice), 1);
78 : : assertEq(nft.holderOf(1), alice);
79 : : assertEq(nft.getApproved(1), address(0));
80 : : assertEq(nft.holderNameOf(1), "alice");
81 : : assertEq(nft.isExpiredOrUsed(1), false);
82 : : }
83 : :
84 : : function testMintUnauthorized() public {
85 : : _topUpTokens(alice, 1);
86 : : vm.prank(alice);
87 : : vm.expectRevert("mint: can only be called by primary market");
88 : : nft.mint(alice, "alice");
89 : : assertEq(nft.balanceOf(alice), 0);
90 : : }
91 : :
92 : : function testBalanceOf() public {
93 : : assertEq(nft.balanceOf(alice), 0);
94 : : _buyTicket(alice, "alice");
95 : : assertEq(nft.balanceOf(alice), 1);
96 : : }
97 : :
98 : : function testHolderOf() public {
99 : : _buyTicket(alice, "alice");
100 : : assertEq(nft.holderOf(1), alice);
101 : : vm.expectRevert("holderOf: ticket doesn't exist");
102 : : nft.holderOf(2);
103 : : }
104 : :
105 : : function testHolderNameOf() public {
106 : : _buyTicket(alice, "alice");
107 : : assertEq(nft.holderNameOf(1), "alice");
108 : : vm.expectRevert("holderNameOf: ticket doesn't exist");
109 : : nft.holderNameOf(2);
110 : : }
111 : :
112 : : function testUpdateHolderName() public {
113 : : _buyTicket(alice, "alice1");
114 : : assertEq(nft.holderNameOf(1), "alice1");
115 : : vm.prank(alice);
116 : : nft.updateHolderName(1, "alice2");
117 : : assertEq(nft.holderNameOf(1), "alice2");
118 : : }
119 : :
120 : : function testUpdateHolderNameInvalid() public {
121 : : _buyTicket(alice, "alice1");
122 : : assertEq(nft.holderNameOf(1), "alice1");
123 : : vm.prank(alice);
124 : : vm.expectRevert("updateHolderName: ticket doesn't exist");
125 : : nft.updateHolderName(2, "alice2");
126 : : }
127 : :
128 : : function testUpdateHolderNameUnauthorized() public {
129 : : _buyTicket(alice, "alice");
130 : : assertEq(nft.holderNameOf(1), "alice");
131 : : vm.prank(bob);
132 : : vm.expectRevert("updateHolderName: msg.sender doesn't own ticket");
133 : : nft.updateHolderName(1, "bob");
134 : : assertEq(nft.holderNameOf(1), "alice");
135 : : }
136 : :
137 : : function testTransfer() public {
138 : : _buyTicket(alice, "alice");
139 : : vm.prank(alice);
140 : : vm.expectEmit(true, true, true, false);
141 : : emit Transfer(alice, bob, 1);
142 : : vm.expectEmit(true, true, true, false);
143 : : emit Approval(bob, address(0), 1);
144 : : nft.transferFrom(alice, bob, 1);
145 : : assertEq(nft.balanceOf(alice), 0);
146 : : assertEq(nft.balanceOf(bob), 1);
147 : : assertEq(nft.holderOf(1), bob);
148 : : assertEq(nft.getApproved(1), address(0));
149 : : assertEq(nft.holderNameOf(1), "alice");
150 : : assertEq(nft.isExpiredOrUsed(1), false);
151 : : }
152 : :
153 : : function testTransferInvalid() public {
154 : : _buyTicket(alice, "alice");
155 : : vm.prank(alice);
156 : : vm.expectRevert("transferFrom: from cannot be 0");
157 : : nft.transferFrom(address(0), bob, 2);
158 : : vm.prank(alice);
159 : : vm.expectRevert("transferFrom: to cannot be 0");
160 : : nft.transferFrom(alice, address(0), 2);
161 : : }
162 : :
163 : : function testTransferUnauthorized() public {
164 : : _buyTicket(alice, "alice");
165 : : vm.prank(bob);
166 : : vm.expectRevert(
167 : : "transferFrom: msg.sender must be current holder or approved sender"
168 : : );
169 : : nft.transferFrom(alice, bob, 1);
170 : : }
171 : :
172 : : function testApproval() public {
173 : : _buyTicket(alice, "alice");
174 : : vm.prank(alice);
175 : : vm.expectEmit(true, true, true, false);
176 : : emit Approval(alice, bob, 1);
177 : : nft.approve(bob, 1);
178 : : assertEq(nft.getApproved(1), bob);
179 : : }
180 : :
181 : : function testApprovalInvalid() public {
182 : : _buyTicket(alice, "alice");
183 : : vm.prank(alice);
184 : : vm.expectRevert("approve: ticket doesn't exist");
185 : : nft.approve(bob, 2);
186 : : }
187 : :
188 : : function testApprovalUnauthorized() public {
189 : : _buyTicket(alice, "alice");
190 : : vm.prank(bob);
191 : : vm.expectRevert("approve: msg.sender doesn't own ticket");
192 : : nft.approve(bob, 1);
193 : : assertEq(nft.getApproved(1), address(0));
194 : : }
195 : :
196 : : function testGetApprovedInvalid() public {
197 : : vm.expectRevert("getApproved: ticket doesn't exist");
198 : : nft.getApproved(1);
199 : : }
200 : :
201 : : function testTransferFrom() public {
202 : : _buyTicket(alice, "alice");
203 : : vm.prank(alice);
204 : : nft.approve(bob, 1);
205 : : vm.prank(bob);
206 : : vm.expectEmit(true, true, true, false);
207 : : emit Transfer(alice, charlie, 1);
208 : : vm.expectEmit(true, true, true, false);
209 : : emit Approval(charlie, address(0), 1);
210 : : nft.transferFrom(alice, charlie, 1);
211 : : assertEq(nft.balanceOf(alice), 0);
212 : : assertEq(nft.balanceOf(bob), 0);
213 : : assertEq(nft.balanceOf(charlie), 1);
214 : : assertEq(nft.holderOf(1), charlie);
215 : : assertEq(nft.getApproved(1), address(0));
216 : : }
217 : :
218 : : function testTransferFromInvalid() public {
219 : : _buyTicket(alice, "alice");
220 : : vm.prank(alice);
221 : : nft.approve(bob, 1);
222 : : assertEq(nft.getApproved(1), bob);
223 : : vm.prank(bob);
224 : : vm.expectRevert("transferFrom: from cannot be 0");
225 : : nft.transferFrom(address(0), charlie, 1);
226 : : vm.prank(bob);
227 : : vm.expectRevert("transferFrom: to cannot be 0");
228 : : nft.transferFrom(alice, address(0), 1);
229 : : vm.prank(bob);
230 : : vm.expectRevert("transferFrom: ticket not owned by from");
231 : : nft.transferFrom(bob, charlie, 1);
232 : : vm.prank(bob);
233 : : vm.expectRevert("transferFrom: ticket not owned by from");
234 : : nft.transferFrom(charlie, bob, 1);
235 : : assertEq(nft.balanceOf(alice), 1);
236 : : assertEq(nft.balanceOf(bob), 0);
237 : : assertEq(nft.balanceOf(charlie), 0);
238 : : assertEq(nft.holderOf(1), alice);
239 : : assertEq(nft.getApproved(1), bob);
240 : : }
241 : :
242 : : function testTransferFromUnauthorized() public {
243 : : _buyTicket(alice, "alice");
244 : : vm.prank(alice);
245 : : nft.approve(bob, 1);
246 : : assertEq(nft.getApproved(1), bob);
247 : : vm.prank(charlie);
248 : : vm.expectRevert(
249 : : "transferFrom: msg.sender must be current holder or approved sender"
250 : : );
251 : : nft.transferFrom(alice, charlie, 1);
252 : : assertEq(nft.balanceOf(alice), 1);
253 : : assertEq(nft.balanceOf(bob), 0);
254 : : assertEq(nft.balanceOf(charlie), 0);
255 : : assertEq(nft.holderOf(1), alice);
256 : : assertEq(nft.getApproved(1), bob);
257 : : }
258 : :
259 : : function testIsExpiredOrUsedInvalid() public {
260 : : vm.expectRevert("isExpiredOrUsed: ticket doesn't exist");
261 : : nft.isExpiredOrUsed(1);
262 : : }
263 : :
264 : : function testExpiry() public {
265 : : _buyTicket(alice, "alice");
266 : : assertEq(nft.isExpiredOrUsed(1), false);
267 : : vm.warp(block.timestamp + 10 days);
268 : : assertEq(nft.isExpiredOrUsed(1), false);
269 : : vm.warp(block.timestamp + 1);
270 : : assertEq(nft.isExpiredOrUsed(1), true);
271 : : }
272 : :
273 : : function testSetUsed() public {
274 : : _buyTicket(alice, "alice");
275 : : assertEq(nft.isExpiredOrUsed(1), false);
276 : : vm.prank(address(this));
277 : : nft.setUsed(1);
278 : : assertEq(nft.isExpiredOrUsed(1), true);
279 : : }
280 : :
281 : : function testSetUsedNonExistent() public {
282 : : vm.expectRevert("setUsed: ticket doesn't exist");
283 : : nft.setUsed(1);
284 : : }
285 : :
286 : : function testSetUsedAlreadyUsed() public {
287 : : _buyTicket(alice, "alice");
288 : : assertEq(nft.isExpiredOrUsed(1), false);
289 : : vm.prank(address(this));
290 : : nft.setUsed(1);
291 : : assertEq(nft.isExpiredOrUsed(1), true);
292 : : vm.prank(address(this));
293 : : vm.expectRevert("setUsed: ticket already used");
294 : : nft.setUsed(1);
295 : : }
296 : :
297 : : function testSetUsedExpired() public {
298 : : _buyTicket(alice, "alice");
299 : : assertEq(nft.isExpiredOrUsed(1), false);
300 : : vm.warp(block.timestamp + 10 days + 1);
301 : : vm.prank(address(this));
302 : : vm.expectRevert("setUsed: ticket expired");
303 : : nft.setUsed(1);
304 : : }
305 : :
306 : : function testSetUsedUnauthorized() public {
307 : : _buyTicket(alice, "alice");
308 : : assertEq(nft.isExpiredOrUsed(1), false);
309 : : vm.warp(block.timestamp + 10 days);
310 : : vm.prank(bob);
311 : : vm.expectRevert("setUsed: only admin can setUsed");
312 : : nft.setUsed(1);
313 : : }
314 : : }
315 : :
316 : : contract PrimaryMarketTest is BaseTicketNFTTest {
317 : : function testAdmin() public {
318 : : assertEq(address(this), nft.admin());
319 : : }
320 : :
321 : : function testPrimaryPurchase() public {
322 : : _topUpTokens(alice, 1);
323 : : vm.prank(alice);
324 : : token.approve(address(nft), ticketPrice);
325 : : vm.prank(alice);
326 : : vm.expectEmit(true, true, true, false);
327 : : emit Transfer(address(0), alice, 1);
328 : : vm.expectEmit(true, true, false, false);
329 : : emit Purchase(alice, "alice");
330 : : nft.purchase("alice");
331 : : assertEq(nft.balanceOf(alice), 1);
332 : : assertEq(nft.holderOf(1), alice);
333 : : assertEq(nft.getApproved(1), address(0));
334 : : assertEq(nft.holderNameOf(1), "alice");
335 : : assertEq(nft.isExpiredOrUsed(1), false);
336 : : }
337 : :
338 : : function testPrimaryPurchaseInsufficientBalance() public {
339 : : vm.deal(alice, ticketPriceEth);
340 : : vm.prank(alice);
341 : : token.mint{value: ticketPriceEth - 1}();
342 : : vm.prank(alice);
343 : : token.approve(address(nft), ticketPrice);
344 : : vm.prank(alice);
345 : : vm.expectRevert("ERC20: transfer amount exceeds balance");
346 : : nft.purchase("alice");
347 : : assertEq(nft.balanceOf(alice), 0);
348 : : }
349 : :
350 : : function testPrimaryPurchaseInsufficientAllowance() public {
351 : : vm.deal(alice, ticketPriceEth);
352 : : vm.prank(alice);
353 : : token.mint{value: ticketPriceEth}();
354 : : vm.prank(alice);
355 : : token.approve(address(nft), ticketPrice - 1);
356 : : vm.prank(alice);
357 : : vm.expectRevert("purchase: insufficient token allowance");
358 : : nft.purchase("alice");
359 : : assertEq(nft.balanceOf(alice), 0);
360 : : }
361 : :
362 : : function testPrimaryPurchases() public {
363 : : _topUpTokens(alice, 2);
364 : : vm.prank(alice);
365 : : token.approve(address(nft), ticketPrice * 2);
366 : : vm.prank(alice);
367 : : nft.purchase("alice");
368 : : vm.prank(alice);
369 : : vm.expectEmit(true, true, true, false);
370 : : emit Transfer(address(0), alice, 2);
371 : : vm.expectEmit(true, true, false, false);
372 : : emit Purchase(alice, "alice's plus one");
373 : : nft.purchase("alice's plus one");
374 : : assertEq(nft.balanceOf(alice), 2);
375 : : assertEq(nft.holderOf(2), alice);
376 : : assertEq(nft.getApproved(2), address(0));
377 : : assertEq(nft.holderNameOf(2), "alice's plus one");
378 : : assertEq(nft.isExpiredOrUsed(2), false);
379 : : }
380 : :
381 : : function testPurchaseLimit() public {
382 : : // Set contract totalSupply to 999 using foundry cheats rather than minting repeatedly
383 : : vm.store(address(nft), bytes32(uint256(1)), bytes32(uint256(999)));
384 : : // for (uint256 i = 0; i < 999; i++) {
385 : : // _buyTicket(alice, "alice");
386 : : // }
387 : : _buyTicket(alice, "alice"); // Buy 1000th ticket
388 : : _topUpTokens(alice, 1);
389 : : vm.prank(alice);
390 : : token.approve(address(nft), ticketPrice);
391 : : vm.prank(alice);
392 : : vm.expectRevert("purchase: maximum tickets reached");
393 : : nft.purchase("alice");
394 : : }
395 : : }
396 : :
397 : : contract SecondaryMarketTest is BaseTicketNFTTest {
398 : : function testList() public {
399 : : _buyTicket(alice, "alice");
400 : : vm.prank(alice);
401 : : vm.expectEmit(true, true, true, false);
402 : : emit Transfer(alice, address(nft), 1);
403 : : vm.expectEmit(true, true, true, false);
404 : : emit Approval(address(nft), address(0), 1);
405 : : vm.expectEmit(true, true, false, false);
406 : : emit Listing(1, alice, 200e18);
407 : : nft.listTicket(1, 200e18); // Got a flipper here :)
408 : : assertEq(nft.balanceOf(alice), 0);
409 : : assertEq(nft.balanceOf(address(nft)), 1);
410 : : assertEq(nft.holderOf(1), address(nft));
411 : : assertEq(nft.getApproved(1), address(0));
412 : : assertEq(nft.holderNameOf(1), "alice");
413 : : assertEq(nft.isExpiredOrUsed(1), false);
414 : : }
415 : :
416 : : function testListFree() public {
417 : : _buyTicket(alice, "alice");
418 : : vm.prank(alice);
419 : : vm.expectRevert("listTicket: price cannot be 0");
420 : : nft.listTicket(1, 0); // What's the opposite of a flipper?
421 : : assertEq(nft.balanceOf(alice), 1);
422 : : assertEq(nft.holderOf(1), alice);
423 : : }
424 : :
425 : : function testListUsed() public {
426 : : _buyTicket(alice, "alice");
427 : : vm.prank(address(this));
428 : : nft.setUsed(1);
429 : : vm.prank(alice);
430 : : vm.expectRevert("listTicket: ticket is expired/used");
431 : : nft.listTicket(1, 200e19);
432 : : assertEq(nft.balanceOf(alice), 1);
433 : : assertEq(nft.holderOf(1), alice);
434 : : assertEq(nft.isExpiredOrUsed(1), true);
435 : : }
436 : :
437 : : function testListExpired() public {
438 : : _buyTicket(alice, "alice");
439 : : vm.warp(block.timestamp + 10 days + 1);
440 : : vm.prank(alice);
441 : : vm.expectRevert("listTicket: ticket is expired/used");
442 : : nft.listTicket(1, 200e19);
443 : : assertEq(nft.balanceOf(alice), 1);
444 : : assertEq(nft.holderOf(1), alice);
445 : : assertEq(nft.isExpiredOrUsed(1), true);
446 : : }
447 : :
448 : : function testListUnauthorized() public {
449 : : _buyTicket(alice, "alice");
450 : : vm.prank(bob);
451 : : vm.expectRevert("listTicket: msg.sender doesn't own ticket");
452 : : nft.listTicket(1, 200e19);
453 : : assertEq(nft.balanceOf(alice), 1);
454 : : assertEq(nft.holderOf(1), alice);
455 : : }
456 : :
457 : : function testDelist() public {
458 : : _buyTicket(alice, "alice");
459 : : vm.prank(alice);
460 : : nft.listTicket(1, 200e18);
461 : : vm.prank(alice);
462 : : vm.expectEmit(true, true, true, false);
463 : : emit Transfer(address(nft), alice, 1);
464 : : vm.expectEmit(true, true, true, false);
465 : : emit Approval(alice, address(0), 1);
466 : : vm.expectEmit(true, false, false, false);
467 : : emit Delisting(1);
468 : : nft.delistTicket(1);
469 : : assertEq(nft.balanceOf(alice), 1);
470 : : assertEq(nft.balanceOf(address(nft)), 0);
471 : : assertEq(nft.holderOf(1), alice);
472 : : }
473 : :
474 : : function testDelistUnauthorized() public {
475 : : _buyTicket(alice, "alice");
476 : : vm.prank(alice);
477 : : nft.listTicket(1, 200e18);
478 : : vm.prank(bob);
479 : : vm.expectRevert("delistTicket: msg.sender didn't list ticket");
480 : : nft.delistTicket(1);
481 : : assertEq(nft.balanceOf(alice), 0);
482 : : assertEq(nft.balanceOf(bob), 0);
483 : : assertEq(nft.balanceOf(address(nft)), 1);
484 : : assertEq(nft.holderOf(1), address(nft));
485 : : }
486 : :
487 : : function testPurchase() public {
488 : : uint256 ticketResalePrice = 200e18;
489 : : uint256 ticketResaleFee = 50 * (ticketResalePrice / 1000);
490 : : uint256 ticketResaleRevenue = ticketResalePrice - ticketResaleFee;
491 : : _buyTicket(alice, "alice");
492 : : vm.prank(alice);
493 : : nft.listTicket(1, ticketResalePrice);
494 : : _topUpTokens(bob, ticketResalePrice / 100e18);
495 : : vm.prank(bob);
496 : : token.approve(address(nft), ticketResalePrice);
497 : : vm.prank(bob);
498 : : vm.expectEmit(true, true, false, true);
499 : : emit Purchase(bob, 1, ticketResalePrice, "bob");
500 : : nft.purchase(1, "bob");
501 : : assertEq(token.balanceOf(alice), ticketResaleRevenue);
502 : : assertEq(token.balanceOf(bob), 0);
503 : : assertEq(token.balanceOf(address(this)), ticketPrice + ticketResaleFee);
504 : : assertEq(nft.balanceOf(alice), 0);
505 : : assertEq(nft.balanceOf(bob), 1);
506 : : assertEq(nft.balanceOf(address(nft)), 0);
507 : : assertEq(nft.holderOf(1), bob);
508 : : assertEq(nft.getApproved(1), address(0));
509 : : assertEq(nft.holderNameOf(1), "bob");
510 : : assertEq(nft.isExpiredOrUsed(1), false);
511 : : }
512 : :
513 : : function testPurchaseUsed() public {
514 : : _buyTicket(alice, "alice");
515 : : vm.prank(alice);
516 : : nft.listTicket(1, 200e18);
517 : : _topUpTokens(bob, 2);
518 : : vm.prank(address(this));
519 : : nft.setUsed(1);
520 : : vm.prank(bob);
521 : : token.approve(address(nft), 200e18);
522 : : vm.prank(bob);
523 : : vm.expectRevert("purchase: ticket is expired/used");
524 : : nft.purchase(1, "bob");
525 : : assertEq(nft.balanceOf(alice), 0);
526 : : assertEq(nft.balanceOf(bob), 0);
527 : : assertEq(nft.balanceOf(address(nft)), 1);
528 : : }
529 : :
530 : : function testPurchaseExpired() public {
531 : : _buyTicket(alice, "alice");
532 : : vm.prank(alice);
533 : : nft.listTicket(1, 200e18);
534 : : _topUpTokens(bob, 2);
535 : : vm.warp(block.timestamp + 10 days + 1);
536 : : vm.prank(bob);
537 : : token.approve(address(nft), 200e18);
538 : : vm.prank(bob);
539 : : vm.expectRevert("purchase: ticket is expired/used");
540 : : nft.purchase(1, "bob");
541 : : assertEq(nft.balanceOf(alice), 0);
542 : : assertEq(nft.balanceOf(bob), 0);
543 : : assertEq(nft.balanceOf(address(nft)), 1);
544 : : }
545 : :
546 : : function testPurchaseInsufficientBalance() public {
547 : : _buyTicket(alice, "alice");
548 : : vm.prank(alice);
549 : : nft.listTicket(1, 200e18);
550 : : _topUpTokens(bob, 1);
551 : : vm.prank(bob);
552 : : token.approve(address(nft), 200e18);
553 : : vm.prank(bob);
554 : : vm.expectRevert("ERC20: transfer amount exceeds balance");
555 : : nft.purchase(1, "bob");
556 : : assertEq(nft.balanceOf(alice), 0);
557 : : assertEq(nft.balanceOf(bob), 0);
558 : : assertEq(nft.balanceOf(address(nft)), 1);
559 : : }
560 : :
561 : : function testPurchaseInsufficientAllowance() public {
562 : : _buyTicket(alice, "alice");
563 : : vm.prank(alice);
564 : : nft.listTicket(1, 200e18);
565 : : _topUpTokens(bob, 2);
566 : : vm.prank(bob);
567 : : token.approve(address(nft), 100e18);
568 : : vm.prank(bob);
569 : : vm.expectRevert("purchase: insufficient token allowance");
570 : : nft.purchase(1, "bob");
571 : : assertEq(nft.balanceOf(alice), 0);
572 : : assertEq(nft.balanceOf(bob), 0);
573 : : assertEq(nft.balanceOf(address(nft)), 1);
574 : : }
575 : :
576 : : function testPurchaseUnlisted() public {
577 : : _buyTicket(alice, "alice");
578 : : vm.prank(alice);
579 : : nft.listTicket(1, 200e18);
580 : : vm.prank(alice);
581 : : nft.delistTicket(1);
582 : : _topUpTokens(bob, 2);
583 : : vm.prank(bob);
584 : : token.approve(address(nft), 200e18);
585 : : vm.prank(bob);
586 : : vm.expectRevert(
587 : : "purchase: ticket is not listed, missing lister address or price"
588 : : );
589 : : nft.purchase(1, "bob");
590 : : assertEq(nft.balanceOf(alice), 1);
591 : : assertEq(nft.balanceOf(bob), 0);
592 : : assertEq(nft.balanceOf(address(nft)), 0);
593 : : }
594 : : }
|
