Pruebas de Smart Contracts en Hardhat con Chai y Ethers.js

Curso de Dapps: Introducción al Desarrollo de Aplicaciones Descentralizadas

Contenido del curso

Presentación del proyecto

Arquitectura de DApps

Setup del proyecto

Desarrollo del contrato inteligente

Probando nuestro Smart Contract

Conclusión

24
Desarrollo de Aplicaciones Descentralizadas con Solidity y Node.js
03:17 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0023:29

Pruebas de Smart Contracts en Hardhat con Chai y Ethers.js

Curso de Dapps: Introducción al Desarrollo de Aplicaciones Descentralizadas

Clase 21 de 24

Clase 21 / 24

Recursos

¿Cómo escribir pruebas en Smart Contracts con Hardhat?

¡Bienvenido al fascinante mundo de las pruebas para Smart Contracts! Ahora que tienes tu Smart Contract de PlatziPunks con las funcionalidades completas, es crucial asegurarse de que todo funcione correctamente antes de avanzar al despliegue en una red de prueba. Vamos a enfocar nuestras energías en crear tests usando Hardhat y JavaScript, que son herramientas esenciales en este proceso.

¿Por qué es importante realizar pruebas?

Las pruebas son fundamentales para garantizar que nuestro Smart Contract funcione de manera adecuada y segura. Algunos beneficios importantes de realizar pruebas incluyen:

Identificación de errores: Facilitan la detección de errores y malfuncionamientos antes de desplegar el contrato.
Validación de funcionalidad: Aseguran que todas las funciones implementadas operen conforme a las expectativas.
Mantenimiento de la calidad del código: Reducen el riesgo de errores futuros a medida que se hacen cambios o mejoras en el código.

¿Cómo empezar con las pruebas en Hardhat?

Para comenzar con las pruebas en Hardhat necesitas seguir algunos pasos iniciales:

Preparación del entorno: Instalar las herramientas necesarias como Hardhat, y los plugins de Ethers.js si no lo has hecho aún.
Crear el archivo de pruebas: Dentro de la carpeta de pruebas, crea un archivo platzipunks.js, donde escribirás todos los tests para tu contrato.
Importar las utilidades de Chai: Principalmente la función expect de Chai, que te ayudará a comparar los resultados reales con los esperados.

const { expect } = require("chai");

¿Cómo estructurar las pruebas?

Las pruebas generalmente se estructuran en suites que agrupan test relacionados. Usamos describe para definir una suite de pruebas, mientras que it define pruebas individuales.

Prueba de Max Supply

Vamos a crear una prueba básica para verificar que el max supply funciona correctamente.

it("set max supply to pass param", async function () {
    const maxSupply = 4000;
    const { deploy } = await setup(maxSupply);
    const returnedMaxSupply = await deploy.maxSupply();
    expect(maxSupply).to.equal(returnedMaxSupply);
});

Aquí, nos aseguramos que el suministro máximo configurado en el contrato sea igual al que hemos pasado como parámetro.

Prueba de Minting

La siguiente prueba verifica que al ejecutar la función de mint, se cree un nuevo token y se asigne al dueño del contrato.

it("mint a new token and assign it to owner", async function () {
    const { deploy, owner } = await setup();
    await deploy.mint();
    const ownerOfMinted = await deploy.ownerOf(0);
    expect(ownerOfMinted).to.equal(owner.address);
});

Esta prueba garantiza que el token mintado pertenece al dueño correcto.

Límite de Minting

Probamos también que no se muevan tokens más allá del límite del max supply.

it("has a minting limit", async function () {
    const maxSupply = 2;
    const { deploy } = await setup(maxSupply);
    await Promise.all([deploy.mint(), deploy.mint()]);
    await expect(deploy.mint()).to.be.revertedWith("PlatziPunks: max supply reached");
});

Esta prueba asegura que no se pueda crear más tokens una vez alcanzado el límite de max supply.

Pruebas del token URI

Finalmente, es importante verificar que el token URI retorna metadatos válidos.

describe("token URI", function () {
    it("returns valid metadata", async function () {
        const { deploy } = await setup();
        await deploy.mint();
        const tokenURI = await deploy.tokenURI(0);
        const [prefix, base64JSON] = tokenURI.split('base64,');
        const metadata = JSON.parse(Buffer.from(base64JSON, 'base64').toString('ascii'));
        expect(metadata).to.include.keys('name', 'description', 'image');
    });
});

Esto nos asegura que la metadata del token está correctamente formateada y contiene la información necesaria.

Recomendaciones finales

Itera en tus pruebas: Usa este enfoque para probar todas las funcionalidades de tu contrato a medida que añades nuevas características.
Documentación y plugins: Familiarízate con la documentación de Hardhat, Chai y Ethers.js para maximizar el uso de sus capacidades en tus pruebas.

Las pruebas continuas no solo fortalecen tu contrato, sino que también construyen una confianza sólida en el desenvolvimiento de tus recursos en la red. ¡Continúa experimentando y aprendiendo para mejorar cada vez más tus dApps y Smart Contracts!

Andrés Muñoz

Hace 5 años

Aquí están los test que hice. Use una librería que se llama hardhat-exposed https://github.com/frangio/hardhat-exposed que hace que funciones que están no visibles se vuelvan publicas para poder testear me gusto la idea pero creo la lib aun no esta lista para producción igual no se si será buena practica hacer esto

const { expect } = require("chai");

describe("Platzi Punks Contract", function () {
  const setup = async (_maxSupply = 2, tokenId = 1) => {
    const PlatziPunks = await ethers.getContractFactory("XPlatziPunks");
    const platzi_punks = await PlatziPunks.deploy(_maxSupply);
    await platzi_punks.deployed();
    
    const [owner] = await ethers.getSigners();
    const PseudoRandomDNA = await platzi_punks.deterministicPseudoRandomDNA(tokenId, owner.address)
    
    return {
      platzi_punks,
      owner,
      PseudoRandomDNA
    }
  }

  let platzi_punks;
  let owner;
  let PseudoRandomDNA;
  beforeEach(async () => {
    const test_utils = await setup();
    platzi_punks = test_utils.platzi_punks
    owner = test_utils.owner
    PseudoRandomDNA = test_utils.PseudoRandomDNA
  })

  describe("Deployment", () => {
    it("Should init contract with name and symbol", async () => {
      expect(await platzi_punks.name()).to.equal("PlatziPunks");
      expect(await platzi_punks.symbol()).to.equal("PLPKS");
    });

    it("Should init max supply with pass params", async () => {
      const maxSupply = 150;
      const {platzi_punks} = await setup(maxSupply);
      expect(await platzi_punks.maxSupply()).to.equal(maxSupply);
    });
  })

  describe("Minting", async () => {
    it("Mints a new token and assigns it to owner", async () => {
      await platzi_punks.mint();
      expect(await platzi_punks.ownerOf(1)).to.equal(owner.address);
    });

    it("Has a minting limit", async () => {      
      const {platzi_punks} = await setup(2);

      try {
        // Exceeds minting
        await platzi_punks.mint()
        await platzi_punks.mint()
        await platzi_punks.mint()
        expect.fail('fail with an error');
      } catch (error) {
        expect(error.message).to.contains('No Platzi Punks left :(');
      }
    });

    it("Should increment the balanceof the owner by 1 every mint", async () => {
      expect(await platzi_punks.balanceOf(owner.address)).to.equal(0);
      await platzi_punks.mint()
      await platzi_punks.mint()
      expect(await platzi_punks.balanceOf(owner.address)).to.equal(2);
    });

    it("Should increment tokenId in every mint", async () => {
      await platzi_punks.mint()
      expect(await platzi_punks.ownerOf(1)).to.equal(owner.address);
      await platzi_punks.mint()
      expect(await platzi_punks.ownerOf(2)).to.equal(owner.address);
    });

    it("Should save token dna on DnaByToken", async () => {
      await platzi_punks.mint()
      expect(await platzi_punks.DnaByToken(1).toString().length).to.equal(16);
      expect(await platzi_punks.DnaByToken(1)).to.equal(PseudoRandomDNA);
    });
  }) 

  describe("tokenURI", async () => {
    it("Should throw an error if tokenId don't exists", async () => {
      try {
        await platzi_punks.tokenURI(1)
        expect.fail('fail with an error');
      } catch (error) {
        expect(error.message).to.contains('ERC721Metadata: URI query for nonexistent token');
      }
    });

    it("Should have tokenURI correct metadata", async () => {
      await platzi_punks.mint()

      const tokenURI = await platzi_punks.tokenURI(1)
      const [ prefix, base64JSON ] = tokenURI.split(',')
      const stringifiedMetaData = Buffer.from(base64JSON, 'base64').toString('ascii');
      const metadata = JSON.parse(stringifiedMetaData)

      expect(prefix).to.equal("data:application/json;base64");
      expect(metadata).to.have.all.keys("name", "description", "image")

      expect(metadata.name).to.includes('PlatziPunks #1');
      expect(metadata.image).to.includes('https://avataaars.io/?')
      expect(metadata.image).to.includes('accessoriesType=')
      expect(metadata.image).to.includes('topType=')
    });

    it("Should have _baseUri avataaars.io", async () => {
      expect(await platzi_punks.x_baseURI()).to.equal('https://avataaars.io/');
    });

    it("Should get _paramsURI", async () => {
      expect(await platzi_punks.x_paramsURI(PseudoRandomDNA)).to.contains('accessoriesType=');
      expect(await platzi_punks.x_paramsURI(PseudoRandomDNA)).to.contains('topType=');
    });

    it("Should get imageByDNA", async () => {
      expect(await platzi_punks.imageByDNA(PseudoRandomDNA)).to.contains('https://avataaars.io/?');
      expect(await platzi_punks.imageByDNA(PseudoRandomDNA)).to.contains('accessoriesType=');
      expect(await platzi_punks.imageByDNA(PseudoRandomDNA)).to.contains('topType=');
    });
  })
});

-------------------------------------------------------------------

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("PunkDNA", function () {
  let punk_dna;
  beforeEach(async function() {
    const PunkDNA = await ethers.getContractFactory("XPunkDNA");
    punk_dna = await PunkDNA.deploy();
    await punk_dna.deployed();
  });

  it('should get DNA section', async() => {
    expect(await punk_dna.x_getDNASection(87654321, 0)).to.equal(21);
    expect(await punk_dna.x_getDNASection(87654321, 1)).to.equal(32);
    expect(await punk_dna.x_getDNASection(87654321, 2)).to.equal(43);
    expect(await punk_dna.x_getDNASection(87654321, 3)).to.equal(54);
    expect(await punk_dna.x_getDNASection(87654321, 4)).to.equal(65);
    expect(await punk_dna.x_getDNASection(87654321, 6)).to.equal(87);
    expect(await punk_dna.x_getDNASection(87654321, 8)).to.equal(0);
  })

  it('should get deterministic PseudoRandom DNA', async() => {
    const [signer] = await ethers.getSigners();
    expect(await punk_dna.deterministicPseudoRandomDNA(1, signer.address)).to.be.an('object');
    expect(await punk_dna.deterministicPseudoRandomDNA(1, signer.address).toString().length).to.equal(16);
  })
});

Ángel David Lerma Carrera

Hace 5 años

Hola Andres! Tengo una duda, que significa la x antes de los metodos en de las pruebas? por ejemplo "x_baseURI" Intento aplicarla pero me marca que no es una funcion, acaso asi con la X llamaste a tus metodos?

Alfredo Toledano

Hace 4 años

Buenas Andres!!

Buen apunte lo de esa libreria
Te compila el proyecto añadiendola? Porque a mi me peta si hago como indican en la documentacion

hardhat compile --force

Y parece que se lia con la internal variable de la lib Base64

'DeclarationError: Undeclared identifier. Did you mean "$TABLE"? --> contracts-exposed/Base64.sol:11:16: | 11 | return TABLE; '

Comentarios (32)32 comentarios

Leandro Vitale

Abimelek Castrezana

Jimmy Buriticá Londoño

Diego Marquina

Fernando López

Jairo Fernández

Edhu Nuñez Alvarado

Yhuan Muñoz Medina

Alex Gallardo

Afu Tse

Omar Castillo

Daniken Espinoza

David Martin Almeyda Sucso

Ernesto García

Profesor

Saúl Regalado

Bárbaro Javier Valmaseda Vázquez

Alejandro Betancourt

Carlos Dugarte

Federico Roberto Celico

Manuel Luis Vila

Edgar Domínguez

Gian Luca Rivera

Luis Alejandro Mongua

Melina Anahi Viera

Fabian Pappacena

Elías Muñiz

Ismael Salas Agüero

David Salazar

Jesus Marquez Martini

Hace 3 años

Presentación del proyecto

Desarrollo de Aplicaciones Descentralizadas en Blockchain

Desarrollo de NFTs con Solidity y Contratos Inteligentes

Arquitectura de DApps

Características de Aplicaciones Descentralizadas (dApps)

Componentes Descentralizables en Aplicaciones Descentralizadas

Evaluación de Descentralización en Aplicaciones Blockchain

Autenticación en Aplicaciones Descentralizadas y Firma Digital

Setup del proyecto

Setup de Proyectos Blockchain con Node.js y Yarn

Instalación y configuración de Hard Hat para contratos inteligentes

Compilación y despliegue de contratos inteligentes con Hard Hat

Actualización de Testnets en Ethereum: Goerli y Sepolia

Despliegue de Contratos Inteligentes en Redes de Prueba con Hard Hat

Manejo seguro de llaves privadas en proyectos blockchain con .env

Alternativas a Hard Hat para Desplegar Contratos Inteligentes

Desarrollo del contrato inteligente

Implementación de OpenZeppelin en Smart Contracts Ethereum

Extensión de Funcionalidad en Contratos ERC721 con OpenZeppelin

Funciones de Metadata en NFTs y OpenSepaline

Cálculo y Diseño del ADN en PlatziPong NFTs

Implementación de contratos inteligentes en Solidity para NFTs

Generación de ADN Pseudoaleatorio en Contratos Solidity

Asignación de ADN y URL de imagen en NFTs con Solidity

Probando nuestro Smart Contract

Pruebas de Smart Contracts en Hardhat con Chai y Ethers.js

Despliegue y Verificación de Smart Contracts en Etherscan

Prueba de Contratos Inteligentes en OpenSea Testnet

Conclusión

Desarrollo de Aplicaciones Descentralizadas con Solidity y Node.js

Pruebas de Smart Contracts en Hardhat con Chai y Ethers.js

Progreso del curso

Presentación del proyecto

Arquitectura de DApps

Setup del proyecto

Desarrollo del contrato inteligente

Probando nuestro Smart Contract

Conclusión

Recursos

Recursos