Mastering Complex Smart Contracts and Integration Testing with Solidity and Foundry

February 12, 2024

Hello, blockchain enthusiasts! Today, we're diving into the world of complex smart contracts on the Ethereum blockchain. We'll explore how to write a more intricate contract and conduct thorough integration testing using Solidity and Foundry. Whether you're a seasoned developer or new to smart contracts, this guide is designed to enhance your skills.

Understanding Complex Smart Contracts

A complex smart contract typically involves multiple functions, state variables, and perhaps interactions with other contracts. For this example, we'll create a contract that manages a simple voting system.

Setting Up Your Development Environment

Before we begin, ensure you have Foundry installed. It's a comprehensive development toolkit for Ethereum. Install it using:

curl -L https://foundry.paradigm.xyz | bash
  foundryup

Writing a Voting Smart Contract

Our contract will allow users to create a new vote, cast votes, and tally the final results.

// SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;
  
  contract Voting {
   struct Vote {
   bool exists;
   string description;
   mapping(address => bool) voted;
   uint256 yesCount;
   uint256 noCount;
   }
  
   mapping(uint256 => Vote) public votes;
   uint256 public voteCount;
  
   function createVote(string memory description) public {
   Vote storage v = votes[voteCount++];
   v.exists = true;
   v.description = description;
   }
  
   function vote(uint256 voteId, bool yes) public {
   require(votes[voteId].exists, "Vote does not exist");
   require(!votes[voteId].voted[msg.sender], "Already voted");
  
   votes[voteId].voted[msg.sender] = true;
   if (yes) {
   votes[voteId].yesCount++;
   } else {
   votes[voteId].noCount++;
   }
   }
  
   function tally(uint256 voteId) public view returns (string memory, uint256, uint256) {
   require(votes[voteId].exists, "Vote does not exist");
   Vote storage v = votes[voteId];
   return (v.description, v.yesCount, v.noCount);
   }
  }

// SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;
  
  contract Voting {
   struct Vote {
   bool exists;
   string description;
   mapping(address => bool) voted;
   uint256 yesCount;
   uint256 noCount;
   }
  
   mapping(uint256 => Vote) public votes;
   uint256 public voteCount;
  
   function createVote(string memory description) public {
   Vote storage v = votes[voteCount++];
   v.exists = true;
   v.description = description;
   }
  
   function vote(uint256 voteId, bool yes) public {
   require(votes[voteId].exists, "Vote does not exist");
   require(!votes[voteId].voted[msg.sender], "Already voted");
  
   votes[voteId].voted[msg.sender] = true;
   if (yes) {
   votes[voteId].yesCount++;
   } else {
   votes[voteId].noCount++;
   }
   }
  
   function tally(uint256 voteId) public view returns (string memory, uint256, uint256) {
   require(votes[voteId].exists, "Vote does not exist");
   Vote storage v = votes[voteId];
   return (v.description, v.yesCount, v.noCount);
   }
  }

Integration Testing with Foundry

Integration tests ensure that the contract's functions interact correctly with each other and perform as expected.

Writing Integration Tests

Here's how we can test our voting contract:

Test Vote Creation: Verify that a new vote can be created.
Test Vote Casting: Ensure that votes can be cast and are counted correctly.
Test Vote Tallying: Check that the tally function returns the correct counts.

// SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;
  
  import "ds-test/test.sol";
  import "../src/Voting.sol";
  
  contract VotingTest is DSTest {
   Voting voting;
  
   function setUp() public {
   voting = new Voting();
   voting.createVote("Should we adopt a new protocol?");
   }
  
   function testVoteCreation() public {
   (string memory description,,) = voting.tally(0);
   assertEq(description, "Should we adopt a new protocol?");
   }
  
   function testVoteCasting() public {
   voting.vote(0, true);
   (, uint256 yesCount,) = voting.tally(0);
   assertEq(yesCount, 1);
   }
  
   function testVoteTallying() public {
   voting.vote(0, false);
   (, uint256 yesCount, uint256 noCount) = voting.tally(0);
   assertEq(yesCount, 1);
   assertEq(noCount, 1);
   }
  }

Running the Tests

Execute the tests with

forge test

This will compile and run the tests, showing if your contract functions as expected.

Conclusion

There you have it! You've just tackled a more complex smart contract and learned how to rigorously test it using Foundry. Remember, the key to mastering smart contracts is practice and continuous learning. Explore different scenarios, tweak the contract, and try writing different tests to deepen your understanding.
Happy coding, and may your contracts always perform flawlessly!