Testing with ethers.js in Blockchain / Solidity - Deep Dive

Overview - Testing with ethers.js

What is it?

Testing with ethers.js means writing code to check if your blockchain smart contracts work correctly using the ethers.js library. Ethers.js helps you interact with Ethereum-like blockchains, and testing ensures your contracts behave as expected before using real money. It involves simulating contract calls, transactions, and checking results in a safe environment.

Why it matters

Without testing, smart contracts can have bugs that cause loss of money or security problems. Testing with ethers.js helps catch these issues early, saving time and money. It makes blockchain development safer and more reliable, so users and developers trust the contracts.

Where it fits

Before testing with ethers.js, you should know basic JavaScript and how smart contracts work. After learning testing, you can move on to deploying contracts safely and advanced blockchain development tools.

Mental Model

Core Idea

Testing with ethers.js is like rehearsing a play where you act out contract interactions in a pretend world to make sure everything works before the real show.

Think of it like...

Imagine you want to bake a cake for a party. Testing with ethers.js is like baking a small sample cake at home first to check the recipe and taste before baking the big cake for everyone.

┌─────────────────────────────┐
│        Test Script          │
│  (JavaScript + ethers.js)  │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│  Local Blockchain Network    │
│  (Hardhat, Ganache, etc.)   │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│    Smart Contract Code       │
│  (Deployed on local chain)  │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Introduction to ethers.js library

Concept: Learn what ethers.js is and how it helps interact with blockchain.

Ethers.js is a JavaScript library that lets you connect to Ethereum blockchains, read data, and send transactions. It simplifies working with smart contracts by providing easy functions to call contract methods and listen to events.

Result

You understand ethers.js basics and can write simple scripts to connect to a blockchain.

Knowing ethers.js basics is essential because it is the tool that bridges your JavaScript code and blockchain contracts.

2

Foundation

Setting up a local blockchain for testing

Concept: Use a local blockchain to safely test contracts without real money.

Tools like Hardhat or Ganache create a local blockchain on your computer. This lets you deploy and test contracts quickly and reset the state anytime. You connect ethers.js to this local chain for testing.

Result

You can deploy contracts locally and run tests without risk.

Using a local blockchain creates a safe playground to experiment and catch bugs early.

3

Intermediate

Writing basic contract tests with ethers.js

🤔Before reading on: Do you think tests only check if a function runs, or also check the returned values? Commit to your answer.

Concept: Learn how to write tests that call contract functions and check their results.

You write JavaScript test scripts that deploy contracts, call functions, and use assertions to check expected outputs. For example, testing if a stored number updates correctly after calling a function.

Result

Tests run and confirm contract functions behave as expected or fail if not.

Testing both function execution and output ensures your contract logic is correct, not just that it runs.

4

Intermediate

Simulating transactions and events

🤔Before reading on: Can you predict if ethers.js tests can check emitted events from contracts? Commit to yes or no.

Concept: Learn to test if contracts emit the right events during transactions.

Ethers.js lets you listen for events emitted by contracts during transactions. You can write tests that confirm specific events fired with correct data, which is important for contract communication.

Result

Tests verify that events are emitted as expected, improving contract transparency.

Checking events helps ensure contracts communicate properly with other contracts or frontends.

5

Intermediate

Handling errors and reverts in tests

🤔Before reading on: Do you think a test should pass if a contract call fails as expected? Commit to yes or no.

Concept: Learn to test that contracts correctly reject bad inputs or unauthorized actions.

You write tests that expect contract calls to fail (revert) under certain conditions. Using ethers.js, you catch these errors and assert that the failure happened as intended.

Result

Tests confirm your contract protects against invalid or harmful actions.

Testing failure cases is as important as success cases to ensure contract security.

6

Advanced

Using fixtures and snapshots for efficient tests

🤔Before reading on: Do you think resetting blockchain state between tests is slow or fast? Commit to your answer.

Concept: Learn to speed up tests by reusing blockchain states with snapshots.

Fixtures are predefined contract deployments and states. Snapshots let you save the blockchain state and revert to it between tests. This avoids redeploying contracts every time, making tests faster and more reliable.

Result

Tests run quickly and independently without side effects.

Efficient test setups save time and reduce flaky test results in large projects.

7

Expert

Testing with multiple accounts and complex scenarios

🤔Before reading on: Can ethers.js tests simulate multiple users interacting with contracts? Commit to yes or no.

Concept: Learn to test contracts with different user roles and complex interactions.

Ethers.js lets you connect with multiple signer accounts to simulate different users. You can test permissions, transfers, and multi-step workflows by switching accounts in tests.

Result

Tests cover real-world usage with multiple participants and roles.

Simulating multiple users in tests uncovers bugs that only appear in real interactions.

Under the Hood

Ethers.js creates JavaScript objects representing contracts and blockchain providers. When you call a contract function, ethers.js encodes the call into blockchain transactions or calls, sends them to the local or remote blockchain node, and decodes the results. Testing frameworks run these calls on a local blockchain instance that simulates real blockchain behavior, including state changes, gas costs, and event emissions.

Why designed this way?

Ethers.js was designed to be lightweight, modular, and easy to use compared to older libraries. It separates concerns between providers (blockchain connections) and contracts, making testing flexible. Local blockchains like Hardhat provide fast, resettable environments to avoid the cost and delay of testing on real networks.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Test Script   │──────▶│ Ethers.js     │──────▶│ Local Blockchain│
│ (JavaScript)  │       │ (Library)     │       │ (Hardhat/Ganache)│
└───────────────┘       └───────────────┘       └───────────────┘
        ▲                      │                        │
        │                      ▼                        ▼
   Assertions             Contract Calls          State Changes & Events

Myth Busters - 4 Common Misconceptions

Quick: Do you think tests on a local blockchain guarantee your contract will work the same on the real Ethereum mainnet? Commit yes or no.

Common Belief: If tests pass on a local blockchain, the contract will definitely work on the real network.

Reality: Local blockchains simulate many behaviors but differ in timing, gas costs, and network conditions. Some bugs only appear on real networks.

Why it matters: Relying only on local tests can cause unexpected failures or vulnerabilities after deployment.

Quick: Do you think ethers.js tests automatically check gas usage limits? Commit yes or no.

Common Belief: Ethers.js tests always check if transactions use too much gas.

Reality: Gas usage must be explicitly checked in tests; ethers.js does not enforce gas limits by default.

Why it matters: Ignoring gas can lead to contracts that are too expensive or fail in production.

Quick: Do you think you must deploy a new contract instance for every test? Commit yes or no.

Common Belief: Each test must deploy a fresh contract to be valid.

Reality: Using snapshots and fixtures, you can reuse contract states to speed up tests without redeploying every time.

Why it matters: Not using snapshots slows down tests and wastes resources.

Quick: Do you think testing only successful contract calls is enough? Commit yes or no.

Common Belief: Testing only that functions work correctly is enough for contract safety.

Reality: Testing failure cases and reverts is crucial to ensure contracts handle bad inputs and attacks safely.

Why it matters: Missing failure tests can leave contracts vulnerable to exploits.

Expert Zone

1

Tests can simulate blockchain time by advancing the local chain's clock, which is essential for contracts depending on timestamps.

2

Ethers.js supports low-level calls and manual transaction crafting, allowing tests to cover edge cases beyond normal contract methods.

3

Combining ethers.js with coverage tools reveals untested contract code paths, improving test quality.

When NOT to use

Testing with ethers.js and local blockchains is not suitable for final performance or security audits. For those, use formal verification tools, mainnet forks, or professional audit services.

Production Patterns

In production, tests are integrated into continuous integration pipelines, run on multiple environments, and combined with static analysis. Developers write modular tests for each contract feature and simulate multi-user scenarios to catch complex bugs.

Connections

Unit Testing in Software Engineering

Testing with ethers.js builds on the same principles of unit testing by isolating small parts of code and verifying their behavior.

Understanding general unit testing helps grasp why contract tests focus on small, repeatable checks for correctness.

Simulation in Systems Engineering

Testing with ethers.js simulates blockchain environments to predict real-world behavior without risk.

Knowing simulation techniques in engineering clarifies why local blockchains are essential for safe contract testing.

Financial Auditing

Just like financial audits verify correctness and compliance of accounts, testing with ethers.js verifies smart contract correctness and security.

Seeing testing as an audit process highlights its role in trust and risk management in blockchain applications.

Common Pitfalls

#1 Not waiting for transactions to be mined before checking results.

Wrong approach:

const tx = await contract.setValue(42);
const value = await contract.getValue(); // Immediately after
console.log(value);

Correct approach:

const tx = await contract.setValue(42);
await tx.wait();
const value = await contract.getValue();
console.log(value);

Root cause:

Misunderstanding that blockchain transactions are asynchronous and need confirmation before state changes are visible.

#2 Ignoring error handling when expecting contract reverts.

Wrong approach:

await contract.restrictedAction(); // No try-catch or assertion

Correct approach:

await expect(contract.restrictedAction()).to.be.revertedWith('Not authorized');

Root cause:

Not using proper test assertions to catch and verify expected failures.

#3 Re-deploying contracts in every test without using snapshots.

Wrong approach:

beforeEach(async () => {
contract = await ContractFactory.deploy();
await contract.deployed();
});

Correct approach:

let snapshotId = await network.provider.request({ method: 'evm_snapshot', params: [] });
beforeEach(async () => {
await network.provider.request({ method: 'evm_revert', params: [snapshotId] });
snapshotId = await network.provider.request({ method: 'evm_snapshot', params: [] });
});

Root cause:

Not leveraging blockchain snapshot features to optimize test speed and isolation.

Key Takeaways

Testing with ethers.js lets you safely simulate and verify smart contract behavior before real deployment.

Using a local blockchain environment is essential to run fast, repeatable tests without risking real assets.

Effective tests check both successful outcomes and expected failures to ensure contract security.

Advanced testing techniques like snapshots and multi-account simulations improve test speed and realism.

Understanding the asynchronous nature of blockchain transactions is key to writing reliable tests.