21.11.2024

Lição 094: Testes Unitários com Truffle

Os testes unitários são um aspecto crucial do desenvolvimento de contratos inteligentes, garantindo que seu código se comporte como esperado e siga a lógica pretendida. O Truffle, um popular framework de desenvolvimento para Ethereum, oferece um excelente suporte para testar contratos inteligentes. Nesta lição, vamos explorar como configurar e executar testes unitários utilizando o Truffle.

Configurando Seu Ambiente de Desenvolvimento

Antes de começarmos a escrever testes, verifique se você tem os seguintes softwares instalados:

• Node.js
• Truffle
• Ganache (para testes em blockchain local)

Você pode instalar o Truffle globalmente usando o npm:

npm install -g truffle

Uma vez que você tenha o Truffle instalado, crie um novo projeto:

mkdir meuProjeto
cd meuProjeto
truffle init

Isso criará uma estrutura básica de projeto para o seu projeto Truffle.

Escrevendo um Contrato Inteligente Simples

Vamos criar um contrato inteligente simples, chamado SimpleStorage.sol, que permite armazenar e recuperar um número.

Crie um novo arquivo no diretório contracts:

// contracts/SimpleStorage.sol
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

Criando Testes Unitários

Agora que temos nosso contrato inteligente, vamos escrever testes unitários para ele. O Truffle usa Mocha e Chai para testes, tornando fácil escrever e executar os testes.

Crie um novo arquivo de teste no diretório test, por exemplo, TestSimpleStorage.js:

// test/TestSimpleStorage.js
const SimpleStorage = artifacts.require("SimpleStorage");

contract("SimpleStorage", (accounts) => {
    let simpleStorage;

    beforeEach(async () => {
        simpleStorage = await SimpleStorage.new();
    });

    it("deve armazenar um valor", async () => {
        await simpleStorage.set(42);
        const value = await simpleStorage.get();
        assert.equal(value.toString(), '42', "O valor armazenado está incorreto.");
    });

    it("deve retornar 0 para o estado inicial", async () => {
        const value = await simpleStorage.get();
        assert.equal(value.toString(), '0', "O valor inicial deve ser 0.");
    });
});

Explicação do Arquivo de Teste

1. Imports: Importamos o contrato SimpleStorage usando artifacts.require().

2. Contexto do Contrato: Usamos contract() para definir uma suíte de testes para nosso contrato inteligente. O primeiro parâmetro é o nome do contrato e o segundo é uma função de callback que contém nossos testes.

3. Configuração com beforeEach(): Este método de ciclo de vida é executado antes de cada teste. Implantamos uma nova instância de SimpleStorage para garantir que os testes sejam executados em um contrato limpo.

4. Escrevendo os Testes:

   • O primeiro teste verifica se conseguimos armazenar um valor e recuperá-lo corretamente.
   • O segundo teste verifica se o valor inicial é 0 quando o contrato é implantado.

Executando os Testes

Para executar os testes, basta executar:

truffle test

Você deverá ver uma saída similar a seguinte, indicando que seus testes passaram com sucesso:

  Contract: SimpleStorage
    ✓ deve armazenar um valor
    ✓ deve retornar 0 para o estado inicial (XXms)

  2 passando (XXms)

Melhores Práticas para Escrever Testes

• Isolar os Testes: Cada teste deve operar de forma independente. Use beforeEach() para configurar o estado necessário para cada caso de teste.
• Usar Aserções Significativas: Seja descritivo em suas asserções para indicar claramente o que o teste está verificando.
• Testar Casos de Borda: Sempre inclua testes para casos extremos para assegurar a robustez.
• Manter os Testes Pequenos: Cada teste deve se concentrar em um único aspecto do comportamento do contrato para facilitar a depuração.

Conclusão

Os testes unitários são uma parte essencial do desenvolvimento de contratos inteligentes, e o Truffle fornece um framework robusto para facilitar esse processo. Seguindo os passos delineados nesta lição, você será capaz de escrever testes efetivos para seus contratos inteligentes em Ethereum, garantindo a confiabilidade e a correção em suas aplicações descentralizadas. Boa codificação!

Video

Navigation