Web3 & DApp Development Fundamentals · Aula

Testes com forge

Testes de Solidity

Testes com forge é uma aula grátis de Web3 & DApp Development Fundamentals no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Web3 & DApp Development Fundamentals, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Web3 & DApp Development Fundamentals inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Tests Are Contracts

In Foundry a test file is a Solidity contract that inherits from Test in the forge-std library. Each public function whose name starts with test is run as an individual test case.

Test files live in test/ and conventionally use the .t.sol suffix.

import {Test} from "forge-std/Test.sol";

contract CounterTest is Test {
    function testInitialZero() public {
        // ...
    }
}

The setUp Function

The special setUp() function runs before every test, giving each test a fresh, isolated state. Deploy your contracts and seed any fixtures here.

Because state resets between tests, one test can never accidentally depend on another.

Counter counter;

function setUp() public {
    counter = new Counter();
}

Assertions

forge-std provides assertion helpers that fail the test with a clear message when they do not hold:

assertEq(a, b) — equality
assertTrue(cond) / assertFalse(cond)
assertGt, assertLt, assertGe, assertLe

function testIncrement() public {
    counter.increment();
    assertEq(counter.number(), 1);
}

Running Tests

Run the whole suite with forge test. Filter by name with --match-test or by contract with --match-contract. Increase verbosity with -v flags to see logs and traces.

$ forge test
$ forge test --match-test testIncrement -vvv

Expecting Reverts

Use vm.expectRevert immediately before a call that should fail. The test passes only if the next call reverts, optionally matching a specific error message or custom error.

function testOnlyOwner() public {
    vm.prank(address(0xBEEF));
    vm.expectRevert("not owner");
    counter.adminReset();
}

Impersonating Accounts

vm.prank(addr) sets msg.sender for the very next call. vm.startPrank(addr) applies it to all calls until vm.stopPrank(). This lets you test access control without deploying from many keys.

vm.startPrank(alice);
token.approve(spender, 100);
token.transfer(bob, 50);
vm.stopPrank();

Manipulating Balances and Time

Cheatcodes let you control the environment:

vm.deal(addr, amount) — set an account's ETH balance
vm.warp(timestamp) — set block.timestamp
vm.roll(blockNum) — set block.number

These make time-dependent and balance-dependent logic easy to test deterministically.

vm.deal(alice, 10 ether);
vm.warp(block.timestamp + 7 days);
vm.roll(block.number + 100);

Testing Events

vm.expectEmit declares which event fields to check, followed by the expected event, then the call that should emit it. The booleans select which topics and data to match.

vm.expectEmit(true, true, false, true);
emit Transfer(alice, bob, 100);
token.transfer(bob, 100);

Labels and Logs

vm.label(addr, name) gives addresses readable names in traces. console.log from forge-std prints debug output during tests when run with sufficient verbosity.

import {console} from "forge-std/console.sol";

vm.label(alice, "Alice");
console.log("balance:", token.balanceOf(alice));

Fork Testing

Foundry can fork a live network so your tests run against real deployed contracts and state. Set an RPC URL and use vm.createSelectFork to pin a block.

This is invaluable for testing integrations with protocols like Uniswap or Aave without redeploying them.

function setUp() public {
    vm.createSelectFork(vm.rpcUrl("mainnet"), 19000000);
}

Test Organization

Good practices for forge tests:

One behavior per test function
Descriptive names like testRevertWhenNotOwner
Shared setup in setUp()
Use prank for access control, warp for time logic
Add fork tests for external integrations

Quick Check

What is the purpose of the setUp() function in a Foundry test contract?

Recap

You learned forge testing:

Tests are Solidity contracts inheriting Test; functions start with test
setUp() gives fresh state per test
Assertions: assertEq, assertTrue, etc.
Cheatcodes: prank, deal, warp, expectRevert, expectEmit
Fork tests run against live network state

Next: fuzzing and invariant testing.

Perguntas Frequentes

A aula “Testes com forge” é grátis?

Sim — o texto completo de “Testes com forge” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Web3 & DApp Development Fundamentals, atualize para CoddyKit PRO. O curso de Web3 & DApp Development Fundamentals inclui 4 aulas no total.

O que vou aprender em “Testes com forge”?

Testes de Solidity Você pratica Web3 & DApp Development Fundamentals com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Web3 & DApp Development Fundamentals?

Nenhuma experiência prévia é necessária. Web3 & DApp Development Fundamentals no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Testes com forge”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Web3 & DApp Development Fundamentals?

Sim. Cada aula de Web3 & DApp Development Fundamentals inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Web3 & DApp Development Fundamentals