started on fuzz testing

Author: Axel Valavaara

foundry.toml

@@ -7,6 +7,6 @@ remappings = ["@openzeppelin/contracts=lib/openzeppelin-contracts/contracts"]
 [invariant]
 runs = 128
 depth = 20
-fail_on_revert = false
+fail_on_revert = true
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

src/MerchantNft.sol

@@ -82,6 +82,13 @@ contract MerchantNft is ERC721 {
         return "ipfs://bafkreidn7tkkov6iykgq5kb7zbfb77tg7lza5exutuufoozebeg7gwz22u";
     }
 
+    function ownerBurn(uint256 tokenId) external onlyOwner {
+        if (_ownerOf(tokenId) == address(0)) {
+            revert MerchantNft__TokenDoesNotExist();
+        }
+        _burn(tokenId);
+    }
+
     /*//////////////////////////////////////////////////////////////
                             GETTER FUNCTIONS
     //////////////////////////////////////////////////////////////*/

test/fuzz/Handler.t.sol

@@ -0,0 +1,63 @@
+//SPDX-License-Identifier: MIT
+
+import {OrderContract} from "../../src/OrderContract.sol";
+import {Test, console} from "forge-std/Test.sol";
+import {A3AToken} from "../../src/A3Atoken.sol";
+
+
+pragma solidity ^0.8.18;
+
+
+contract FuzzHandler is Test {
+    
+    A3AToken public tokenContract;
+    OrderContract public orderContract;
+
+    uint64 public orderIdCounter = 0;
+    uint64[] public orderIdArray;
+
+    constructor(address orderContractAddress, address tokenAddress) {
+        orderContract = OrderContract(orderContractAddress);
+        tokenContract = A3AToken(tokenAddress);
+        
+    }
+
+    function proposeOrder(bytes32 promptHash, address userWalletAddress) external {
+        if (userWalletAddress == address(0)) {
+            return;
+        }
+        orderIdCounter++;
+        vm.prank(address(orderContract));
+        tokenContract.mint(userWalletAddress, 1000 ether);
+        vm.prank(userWalletAddress);
+        tokenContract.approve(address(orderContract), 500 ether);
+        vm.startPrank(address(5));
+        orderContract.proposeOrder(promptHash, userWalletAddress);
+        vm.stopPrank();
+        orderIdCounter++;
+        orderIdArray.push(orderIdCounter);
+
+       
+        
+    }
+
+    function proposeOrderAnswer(bytes32 answerHash, uint64 offerId, uint256 priceForOffer, address seller) external {
+        if (seller == address(0)) {
+            return;
+        }
+        if (orderIdArray.length == 0) {
+            return;
+        }
+        uint64 offerID = orderIdArray[offerId % orderIdArray.length];
+        
+        if (offerID == 0) {
+            return;
+        }
+        if (orderContract.getOfferStatus(offerID) != OrderContract.OrderStatus.InProgress) {
+            return;
+        }
+        vm.prank(address(5));
+        orderContract.proposeOrderAnswer(answerHash, offerID, priceForOffer, seller);
+    }
+
+}

test/fuzz/InvariantsTest.t.sol

@@ -8,15 +8,20 @@ import {HelperConfig} from "script/HelperConfig.s.sol";
 import {DeployOrderContract} from "script/DeployOrderContract.s.sol";
 import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
 import {StdInvariant} from "forge-std/StdInvariant.sol";
+import {FuzzHandler} from "./Handler.t.sol";
+import {A3AToken} from "../../src/A3Atoken.sol";
 
 contract InvariantsTest is StdInvariant, Test {
     OrderContract orderContract;
     HelperConfig helperConfig;
+    FuzzHandler handler;
+    A3AToken token;
 
     function setUp() public {
         DeployOrderContract deployer = new DeployOrderContract();
-        (orderContract, helperConfig,,) = deployer.run();
-        targetContract(address(orderContract));
+        (orderContract, helperConfig,token,) = deployer.run();
+        handler = new FuzzHandler(address(orderContract), address(token));
+        targetContract(address(handler));
     }
 
 

test/unit/OrderContractTest.t.sol

@@ -403,6 +403,31 @@ contract OrderContractTest is Test {
         merchantNft.mintNft(merchantId, USER);
     }
 
+    function testMerchantNftOwnerBurn() public {
+        // Arrange
+        uint256 merchantId = 2;
+        vm.prank(owner);
+        merchantNft.mintNft(merchantId, SELLER);
+        // Act
+        vm.prank(owner);
+        merchantNft.ownerBurn(merchantId);
+        // Assert
+        vm.prank(owner);
+        vm.expectRevert(MerchantNft.MerchantNft__TokenDoesNotExist.selector);
+        merchantNft.ownerBurn(merchantId);
+    }
+
+    function testMerchantNftOnlyOwnerCanBurn() public {
+        // Arrange
+        uint256 merchantId = 2;
+        vm.prank(owner);
+        merchantNft.mintNft(merchantId, SELLER);
+        // Act / Assert
+        vm.prank(USER);
+        vm.expectRevert(MerchantNft.MerchantNft__OnlyOwnerCanCall.selector);
+        merchantNft.ownerBurn(merchantId);
+    }
+
     /*//////////////////////////////////////////////////////////////
                            CANCEL ORDER TESTS
     //////////////////////////////////////////////////////////////*/