Test Smart Contract Functionality with Ethers and Hardhat

Instructor: [0:00] Now, you have pieces of the smart contract ready to be used, but remember, testing a smart contract is very important in the process of creating one, because after the deployment, it cannot be changed. Let's write tests for your smart contract. [0:23] Open the tipjar.js file and start adding new test. The first test to create is to check that the tip is successfully sent and that the total of new tips is bigger than before. This will be an asynchronous function. Let's retrieve some addresses for the operations using ethers.getsigners function.

[0:52] It will return an array of addresses where the first item will be the owner. Then, retrieve the balance of these addresses using the GetBalance function from the address and trigger the transaction.

[1:08] You have the contract instance already defined above. You'll need to copy this piece of code, but instead of copying it, let's move this logic to its own block inside and before all function. Now, you can access the contract from any part of the test.

[1:27] Time to perform a transaction by connecting the sender address with the contract. This address is the one that will interact with the contract and perform the syntax function by adding as arguments the message, the name, and the amount you want to send.

[1:46] Let's fix this type here. Now, to define the value, you cannot directly pass any number. You need to parse it as ether using the ethers. YouTube.parse ethers function. Let's use .001ethers. Then, wait for the transaction to be done and retrieve the new balances by using the owner.getbalance, again, same for the sender.

[2:20] Let's compare them using some assertions. Check that the new balance is above the previous one. Do the same with the sender balance, but in this case, check that the balance is below the previous value. Also, let's check the contract total tips variable.

[2:43] You can also test these changes by using a custom matcher provided by the Waffle framework. This is the changeEthersBalance function that assert that the transaction changes the balance of a particular address in a certain amount.

[3:03] Now, run the test. Open your terminal, be sure to be in the project folder, and run MPM run hardhat test, and wait for the results. All the tests are passing, but the contract has another function. Let's write a test for it, should return all the tips.

[3:26] Again, an asynchronous function, define the amount you want to use for this transaction, retrieve the sender address using the getSigners function. You can copy the previous transaction code but by sending a different amount with a different message and name. Send the transaction and wait for the result.

[3:50] Now, retrieve the tips by using the getAllTips function from the contract. Check that the Total Tips, public variable, is equal to two, because there are two transactions.

[4:03] Also, check that the array size is equal to two. At last, check the content of the tips array by comparing the values of each item. Let's run the test again. There you have three tests passing, but there is one more scenario. Check for a failure transaction. The contract code says that a transaction will fail, if the amount that the user wants to send is bigger than its own balance.

[4:35] Let's write this scenario. Retrieve the sender address using, again, the getSigners function. Set an insane amount of Ether, and try to perform the transaction. Copy and paste the same transaction code used before, but let's remove the waiting call of it because it's not needed.

[4:56] Now, write the assertion waiting for the transaction to be reversed. Run the test. You have four tests passing, but the contract is throwing a message when the transaction fails. You can assert that or test for that scenario by using the reverted with args function, and passing the text of the message to it. Run the test again, and all the scenarios were covered.