Testing smart contracts con Truffle y Mocha

Testing de Smart Contracts con Truffle y Mocha

En el ecosistema cripto y blockchain, la seguridad y la fiabilidad de los smart contracts son esenciales. Un error en el código puede acarrear pérdidas millonarias e incluso poner en riesgo la confianza de toda una comunidad. Por ello, este artículo exhaustivo ofrece una guía detallada para testear tus contratos inteligentes usando Truffle y Mocha, dos herramientas de referencia en el desarrollo Ethereum.

1. ¿Por qué testear tus Smart Contracts

Un smart contract, una vez desplegado en la blockchain, es inmutable. Cualquier vulnerabilidad o fallo quedará para siempre. Por eso, adoptar una estrategia de testing sólida te permitirá:

• Detectar vulnerabilidades antes de la puesta en producción.
• Validar la lógica de negocio en distintos escenarios y casos límite.
• Facilitar auditorías al presentar un conjunto de pruebas que demuestren el correcto funcionamiento.
• Mantener confianza de inversores y usuarios al demostrar profesionalidad y robustez.

2. Herramientas Principales

3. Configuración del entorno

1. Node.js y npm: Asegúrate de tener instalada la versión LTS.
   node --version npm --version
2. Instalar Truffle:
   npm install -g truffle
3. Instalar Ganache CLI (opcional):
   npm install -g ganache-cli
4. Crear un proyecto Truffle:
   truffle init

4. Estructura de Directorios en Truffle

5. Escribiendo Tests con Mocha y Chai

Truffle integra Mocha por defecto y usa Chai para las aserciones. Veamos un ejemplo de test básico:

const MyToken = artifacts.require(MyToken)
const { expect } = require(chai)

contract(MyToken, accounts =gt {
  const [owner, user] = accounts

  beforeEach(async () =gt {
    this.token = await MyToken.new(1000)
  })

  it(debería asignar balance inicial al owner, async () =gt {
    const balance = await this.token.balanceOf(owner)
    expect(balance.toNumber()).to.equal(1000)
  })

  it(debería transferir tokens correctamente, async () =gt {
    await this.token.transfer(user, 200, { from: owner })
    const userBalance = await this.token.balanceOf(user)
    expect(userBalance.toNumber()).to.equal(200)
  })
})
  

Explicación

• artifacts.require: Carga el contrato compilado.
• contract(): Contexto de Mocha para tests de Ethereum.
• beforeEach(): Despliega un nuevo contrato para aislar casos.
• expect(): Aserciones legibles con Chai.

6. Caso Práctico: Testear un ERC20

Supongamos que tienes un contrato basado en OpenZeppelin ERC20. Estos son los aspectos clave a validar:

• Nombre, símbolo y decimales.
• Balance inicial y totalSupply.
• Transferencias y aprobaciones (approve / transferFrom).
• Eventos emitidos al transferir o aprobar.

Con Truffle y Mocha podrás cubrir cada función, simulando tanto llamadas exitosas como fallidas (revert), usando helpers como expectRevert de OpenZeppelin Test Helpers.

7. Ejecutando los Tests

Para lanzar la suite:

truffle test

Opciones útiles:

8. Técnicas Avanzadas

• Mock Contracts: Simula dependencias externas.
• Snapshots de blockchain: Retrocede al estado anterior con Ganache (evm_snapshot / evm_revert).
• Pruebas de gas: Mide consumo para optimizar costos.
• Integración con solidity-coverage: Analiza la cobertura de tus tests.
  solidity-coverage

9. Buenas Prácticas

1. Aislamiento de tests: Desplegar contratos frescos en cada caso.
2. Nombrado claro: Describe qué caso cubre cada it().
3. Timeouts ajustados: Usa this.timeout(100000) cuando sea necesario.
4. Revisión periódica: Actualiza tus tests al modificar lógica o dependencias.
5. Integración Continua: Automatiza tests con GitHub Actions o Travis CI.

10. Integración Continua

Configurar un workflow básico en GitHub Actions:

name: CI

on:
  push:
    branches: [ main ]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: 14
      - run: npm install -g truffle ganache-cli
      - run: npm install
      - run: ganache-cli -d amp
      - run: truffle test
  

11. Recursos y Enlaces Relevantes

• Smart Contracts Ethereum.org
• Docs de Truffle
• Guía de Mocha
• Chai Assertion Library
• Ganache CLI

Conclusión

Implementar una estrategia de testing rigurosa con Truffle y Mocha no solo te protege contra errores críticos, sino que también acelera el desarrollo de tus dApps al detectar problemas en fases tempranas. Siguiendo los consejos y ejemplos de este artículo, podrás garantizar contratos más seguros, documentar su comportamiento y ofrecer confianza total a tus usuarios e inversores.