Hardhat testing setup in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Hardhat testing helpers.

Blockchain / Solidity

const { [1] } = require("hardhat");

Drag options to blanks, or click blank then click option'

Atruffle

Bweb3

Cganache

Dethers

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'web3' instead of 'ethers' causes errors because Hardhat uses ethers by default.

Trying to import 'truffle' or 'ganache' which are separate tools.

The ethers object is imported from Hardhat to interact with the Ethereum blockchain in tests.

2fill in blank

medium

Complete the code to get the list of signers for testing.

Blockchain / Solidity

const [owner, addr1] = await [1].getSigners();

Drag options to blanks, or click blank then click option'

Aethers

Bweb3

Chardhat

Dnetwork

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'web3.getSigners()' which does not exist.

Trying to get signers from 'network' which is unrelated.

The ethers object provides the getSigners() method to get test accounts.

3fill in blank

hard

Fix the error in deploying the contract instance.

Blockchain / Solidity

const Contract = await ethers.getContractFactory("MyContract");
const contract = await Contract.[1]();

Drag options to blanks, or click blank then click option'

Adeploy

Battach

Cconnect

Dcall

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'attach()' tries to connect to an existing contract, not deploy a new one.

Using 'connect()' or 'call()' which are not deployment methods.

The deploy() method creates a new contract instance on the blockchain.

4fill in blank

hard

Fill both blanks to write a test that checks the contract owner.

Blockchain / Solidity

describe("MyContract", function () {
  it("should set the right owner", async function () {
    const [[1]] = await ethers.getSigners();
    const Contract = await ethers.getContractFactory("MyContract");
    const contract = await Contract.deploy();
    await contract.deployed();
    expect(await contract.owner()).to.equal([2].address);
  });
});

Drag options to blanks, or click blank then click option'

Aowner

Baddr1

Daddr2

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names for the signer and the expected address causes test failures.

Using addresses of other signers like 'addr1' or 'addr2' incorrectly.

The first signer is usually called owner, and the test checks if the contract's owner matches owner.address.

5fill in blank

hard

Fill all three blanks to write a test that checks a function revert with a custom error message.

Blockchain / Solidity

it("should revert if not owner", async function () {
  const [owner, [1]] = await ethers.getSigners();
  const Contract = await ethers.getContractFactory("MyContract");
  const contract = await Contract.deploy();
  await contract.deployed();
  await expect(contract.connect([2]).restrictedFunction()).to.be.revertedWith([3]);
});

Drag options to blanks, or click blank then click option'

Aaddr1

C"Ownable: caller is not the owner"

D"NotOwnerError"

Attempts:

3 left

💡 Hint

Common Mistakes

Using different signer variables for connecting and assigning.

Using incorrect or incomplete revert messages causing test failures.

The test uses addr1 as a non-owner signer and expects the revert message "Ownable: caller is not the owner".

Practice

1. What is the main purpose of using Hardhat testing setup in blockchain development?

easy

A. To create user interfaces for blockchain applications

B. To deploy smart contracts directly to the main Ethereum network

C. To write and run tests for smart contracts on a local blockchain

D. To mine real cryptocurrency coins

Solution

1. Step 1: Understand Hardhat testing role

   Hardhat testing setup is designed to help developers write and run tests for smart contracts safely.

2. Step 2: Identify the environment used

   Tests run on a local blockchain, which means no real money or main network is involved.

3. Final Answer:

   To write and run tests for smart contracts on a local blockchain -> Option C

4. Quick Check:

   Hardhat testing = local smart contract tests [OK]

Hint: Hardhat tests run locally, not on mainnet [OK]

Common Mistakes:

• Confusing testing with deployment to mainnet
• Thinking Hardhat mines real coins
• Assuming Hardhat builds user interfaces

2. Which of the following is the correct way to start a test suite in Hardhat using Mocha?

easy

A. test('MyContract', function() { ... })

B. describe('MyContract', function() { ... })

C. suite('MyContract', () => { ... })

D. context('MyContract', function() { ... })

Solution

1. Step 1: Recall Mocha test structure

   Hardhat uses Mocha for testing, which organizes tests with describe blocks.

2. Step 2: Identify correct syntax

   The describe function takes a string and a callback function to group tests.

3. Final Answer:

   describe('MyContract', function() { ... }) -> Option B

4. Quick Check:

   Mocha test suites use describe() [OK]

Hint: Use describe() to group tests in Hardhat [OK]

Common Mistakes:

• Using test() instead of describe() for suites
• Confusing suite() or context() with Mocha syntax
• Missing function keyword or arrow function

3. Given this Hardhat test snippet, what will be the output when running the test?

describe('SimpleTest', function() {
  it('should return true', async function() {
    const result = true;
    console.log(result);
    expect(result).to.equal(true);
  });
});

medium

A. true and test passes

B. false and test fails

C. undefined and test passes

D. Error: expect is not defined

Solution

1. Step 1: Analyze console output

   The code logs the variable result which is set to true, so console shows 'true'.

2. Step 2: Check assertion

   The test asserts result equals true, which is correct, so test passes.

3. Final Answer:

   true and test passes -> Option A

4. Quick Check:

   console.log(true) + expect(true) passes [OK]

Hint: Check console.log and expect values carefully [OK]

Common Mistakes:

• Assuming expect is undefined without import
• Confusing console output with test result
• Thinking test fails because of async function

4. Identify the error in this Hardhat test code snippet:

describe('Token', function() {
  it('should deploy contract', async () => {
    this.timeout(20000);
    const Token = await ethers.getContractFactory('Token');
    const token = await Token.deploy();
    await token.waitForDeployment();
    expect(token.address).to.be.a('string');
  });
});

medium

A. Missing import of ethers from Hardhat

B. deploy() should not be awaited

C. Incorrect assertion method for address type

D. Using arrow function in it() causes context loss

Solution

1. Step 1: Check function style in it()

   Using arrow functions in Mocha's it blocks can cause loss of this context, which Hardhat sometimes relies on.

2. Step 2: Verify other parts

   Imports and await usage are correct; assertion syntax is valid for checking string type.

3. Final Answer:

   Using arrow function in it() causes context loss -> Option D

4. Quick Check:

   Use function() not arrow in it() [OK]

Hint: Avoid arrow functions in it() blocks [OK]

Common Mistakes:

• Ignoring context loss with arrow functions
• Thinking deploy() is synchronous
• Assuming ethers import is automatic

5. You want to test a smart contract function that transfers tokens and emits an event. Which setup correctly tests the event emission using Hardhat and Chai?

hard

A. await expect(token.transfer(addr1.address, 100)).to.emit(token, 'Transfer').withArgs(owner.address, addr1.address, 100);

B. expect(token.transfer(addr1.address, 100)).to.emit('Transfer').withArgs(owner.address, addr1.address, 100);

C. await token.transfer(addr1.address, 100); expect(token).to.emit('Transfer');

D. token.transfer(addr1.address, 100); expect(token).to.emit(token, 'Transfer');

Solution

1. Step 1: Understand event testing syntax

   Hardhat with Chai uses await expect(transaction).to.emit(contract, eventName).withArgs(...) to test events.

2. Step 2: Check options for correct usage

   await expect(token.transfer(addr1.address, 100)).to.emit(token, 'Transfer').withArgs(owner.address, addr1.address, 100); correctly awaits the transaction and specifies contract and event with arguments.

3. Step 3: Identify errors in other options

   The other options either miss the await before expect, fail to specify the contract instance in to.emit(), or use incorrect syntax chaining.

4. Final Answer:

   await expect(token.transfer(addr1.address, 100)).to.emit(token, 'Transfer').withArgs(owner.address, addr1.address, 100); -> Option A

5. Quick Check:

   Use await expect(...).to.emit(contract, event) [OK]

Hint: Always await expect() when testing events [OK]

Common Mistakes:

• Forgetting to await the expect call
• Not specifying the contract in to.emit()
• Calling expect on transaction result instead of promise