No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Probando nuestro Smart Contract

21/24
Recursos

Aportes 19

Preguntas 12

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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);
  })
});

Hacer pruebas es una buena practica que ayuda a detectar errores de funcionamiento y verificar que nuestro smart Contract funcione como se espera.

Si a

"data:application/json;base64,"

dejas la coma al final de base64, el test tira error. Por lo menos a mi me fallaba y le tuve que sacar la coma


Tomo su tiempo, pero se logr贸.

Definitivamente

import "hardhat/console.sol";

me ayudo a encontrar el error, pero lo ideal es que eviten copiar la current <= maxSupply y mantengan el <

Cuando intente usar la libreria de Strings de openzepeling con el siguiente codigo, me generaba un error

tokenId.toString()

Para solucionarlo cambie le definicio del framento de codigo con lo siguiente.

Strings.toString(tokenId)

Espero que les ayude si tienen el mismo problema que yo tuve.

Yo utilic茅 un for y as铆 hice un poco m谩s din谩mico el test

for(let i=0; i<maxSupply; i++){
	await deployed.mint()
 }

As铆 ser铆a testear el 鈥淢inting鈥 con diferentes usuarios:

it("Mints a new token and assigns it to owner", async () => {
      const { deployed } = await setup({});
      const [owner, user1, user2] = await ethers.getSigners();

      await deployed.mint();
      await deployed.connect(user1).mint();
      await deployed.connect(user2).mint();

      const ownerOfMinted0 = await deployed.ownerOf(0);
      const ownerOfMinted1 = await deployed.ownerOf(1);
      const ownerOfMinted2 = await deployed.ownerOf(2);

      expect(ownerOfMinted0).to.equal(owner.address);
      expect(ownerOfMinted1).to.equal(user1.address);
      expect(ownerOfMinted2).to.equal(user2.address);
    });

Para los que hicieron el tema de que mint sea payable, hay algunas cosas que deben tener en cuenta para los test:

  1. en el const setup, deben agregar payees y shares_ as铆 como cuando llamen el await setup, les pongo un ejemplo
...
const setup = async ({ maxSupply = 10000, payees = [], shares_ = [100]}) => {
...

 const { deployed } = await setup({ maxSupply, payees: [deployer.address], shares_: [100] });

  1. Cuando quieran hacer mint, deben pasar el value de la siguiente manera:
// El 0.005 cambia por el valor que pusieron en su contrato
await deployed.mint({value: ethers.utils.parseEther("0.005")});
  1. Yo use el tema de ethers.getSigners(); para obtener al deployer para as铆 pasar en payees el deployer.address
describe("tokenURI", () => {
      it("returns valid metadata", async () => {
        const maxSupply = 1000;
        const [deployer] = await ethers.getSigners();
        const { deployed } = await setup({ maxSupply, payees: [deployer.address], shares_: [100] });

De esta forma funcionaron todos mis tests c:

Si como yo convertiste tu funci贸n mint en tipo payable, la manera de enviar ether es la siguiente:

await deployed.mint({value: ethers.utils.parseEther('2')});

Las pruebas arrojan un error que indica bug en nuestro c贸digo

await Promise.all( ) ???

INDAGAR: to.be.revertedWith('message')

INDAGAR: overwirte del MaxSupply

NVM: Windows: https://content.breatheco.de/en/how-to/nvm-install-windows https://docs.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows

expect: https://www.chaijs.com/guide/styles/#expect https://www.chaijs.com/api/bdd/

Test Suite Medium article: https://blog.bitsrc.io/build-your-own-javascript-testing-framework-377e6583c870 https://gist.github.com/philipszdavido/b44c62cd7bcd94740e33af5859e7810c#file-js-test-lib-index-js pruebas con chai y mocha: https://www.youtube.com/watch?v=-sn3H0V3PuY another one: https://codeburst.io/how-to-test-javascript-with-mocha-the-basics-80132324752e

https://www.chaijs.com/ also https://mochajs.org/

En el material de ayuda en la en donde se hace el split, se escribi贸 mal la separaci贸n,
Tiene;

 "data:application/json;base64,"

Cuando deber铆a ser;

"data:aplication/json;base64,"

Por si lo copiaron y no funciona haha