Recentemente escrevi um tutorial ensinando como implementar um contrato de NFTs usando HardHat, Solidity e TypeScript, além da biblioteca de contratos OpenZeppelin que segue a especificação ERC-721. Se você não fez este primeiro tutorial, corre lá que é obrigatório pois nessa parte 2 vamos escrever apenas os testes automatizados para nossos contratos, ok? Link aqui.
Outra recomendação é você entender primeiro do padrão de NFT em si, algo que abordei em outro tutorial de NFT ERC721 onde escrevemos todo o contrato do zero, pois é ali que construímos o conhecimento de como tudo funciona, permitindo que a gente consiga saber como testar um NFT também.
Então mãos à obra pois temos muitos testes a escrever!
Principais testes do nosso contrato
Comece abrindo o arquivo MyNFT.test.ts na pasta test e vamos escrever nosso primeiro teste, que irá verificar se o nome e o symbol da nossa coleção estão corretos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
it("Should has the correct name", async () => { const { myNFT } = await loadFixture(deployFixture); const name = await myNFT.name() as string; expect(name).to.equal("MyNFT", "The name is wrong"); }); it("Should has the correct symbol", async () => { const { myNFT } = await loadFixture(deployFixture); const symbol = await myNFT.symbol() as string; expect(symbol).to.equal("MYN", "The symbol is wrong"); }); |
Começamos os testes sempre chamando a função deployFixture que criamos anteriormente para pegar uma instância zerada do contrato a fim de manter a independência entre os testes. Na sequência chamamos a função em questão que iremos testar: name() no primeiro teste e symbol() no segundo. No final das contas a asserção é simples, com uso de .to.equal.
Eu não vou ficar citando, mas a cada teste codificado, o ideal é rodar a bateria toda com o comando ‘npx hardhat test’ a ver se estão passando, ok? Outra possibilidade é rodar com ‘npx hardhat coverage’ para ter relatórios de cobertura de código.
O teste seguinte é mais complexo, para verificar se estamos conseguindo mintar novos tokens.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
it("Should mint a new NFT", async () => { const { myNFT, owner } = await loadFixture(deployFixture); await myNFT.mint(); const balance = await myNFT.balanceOf(owner.address); const token = await myNFT.tokenByIndex(0); const ownerToken = await myNFT.tokenOfOwnerByIndex(owner.address, 0); const ownerOf = await myNFT.ownerOf(token); const totalSupply = await myNFT.totalSupply(); expect(totalSupply).to.equal(1, "Can't mint"); expect(balance).to.equal(1, "Can't mint"); expect(token).to.equal(ownerToken, "Can't mint"); expect(ownerOf).to.equal(owner.address, "Can't mint"); }); |
Aqui eu resolvi fazer um teste de integração bem completo ao invés de unitário, para ganharmos tempo. Começamos carregando a instância do contrato e o owner que fez o deploy dele. Depois, chamamos a função de mint() em si, enquanto que o resto todo do código são as variáveis de verificação se o minting funcionou. Para isso eu optei por verificar se o saldo do owner é 1, se o token na posição 0 global é igual ao token na posição 0 do owner, se o dono do token é o owner e se o total supply de tokens na coleção é 1.
Opcionalmente você pode quebrar este grande teste em vários testes menores ou então até mesmo criar variações, testando de forma diferente.
Agora vamos escrever o teste para a funcionalidade de burn.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
it("Should burn", async () => { const { myNFT, owner } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenOfOwnerByIndex(owner.address, 0); await myNFT.burn(token); const totalSupply = await myNFT.totalSupply(); const balance = await myNFT.balanceOf(owner.address); expect(balance).to.equal(0, "Can't burn"); expect(totalSupply).to.equal(0, "Can't burn"); }); |
Aqui nós temos de primeiro mintar um token, já que precisamos que exista algum para queimá-lo. Então logo após o mint chamamos a função de burn e o restante do código são para coleta de indícios que comprovem que o burn foi efetuado com sucesso como verificar se o total supply está zerado e se o saldo do owner também está zerado.
Outra variação de teste da funcionalidade de burn diz respeito a burn delegado, isto é, o owner do token pode ceder o controle dele a outra pessoa, que pode decidir por queimar o token. Isso envolve uma série de mecanismos internos e é interessante de ser testado.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
it("Should burn (approved)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenOfOwnerByIndex(owner.address, 0); await myNFT.approve(otherAccount.address, token); const instance = myNFT.connect(otherAccount); await instance.burn(token); const totalSupply = await myNFT.totalSupply(); const balanceFrom = await myNFT.balanceOf(owner.address); const balanceTo = await myNFT.balanceOf(owner.address); expect(balanceFrom).to.equal(0, "Can't burn"); expect(balanceTo).to.equal(0, "Can't burn"); expect(totalSupply).to.equal(0, "Can't burn"); }); |
Esta variação é bem mais complexa que o teste de burn tradicional pois envolve aprovar um operador/controlador diferente para o token após mintá-lo. Então usamos a função connect para gerar uma conexão com o contrato se fazendo passar por outra carteira e realizamos o burn a partir dela. O restante do código é a coleta de evidências do burn.
Existe ainda mais uma variação do burn que é quando a delegação do controle é total sobre a coleção de um owner.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
it("Should burn (approved all)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenOfOwnerByIndex(owner.address, 0); await myNFT.setApprovalForAll(otherAccount.address, true); const instance = myNFT.connect(otherAccount); await instance.burn(token); const totalSupply = await myNFT.totalSupply(); const balanceFrom = await myNFT.balanceOf(owner.address); const balanceTo = await myNFT.balanceOf(owner.address); expect(balanceFrom).to.equal(0, "Can't burn"); expect(balanceTo).to.equal(0, "Can't burn"); expect(totalSupply).to.equal(0, "Can't burn"); }); |
O teste é praticamente idêntico ao anterior, então dispensa maiores explicações. Mas e os cenários de fracasso? Para o mint não creio que tenhamos algum que valha a pena testar, mas para o burn nós temos ao menos dois.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
it("Should NOT burn (exists)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await expect(myNFT.burn(1)) .to.be.revertedWithCustomError(myNFT, "ERC721NonexistentToken"); }); it("Should NOT burn (permission)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const instance = myNFT.connect(otherAccount); const token = await instance.tokenByIndex(0); await expect(instance.burn(token)) .to.be.revertedWithCustomError(myNFT, "ERC721InsufficientApproval"); }); |
No primeiro cenário nós tentamos queimar um token que não foi mintado, o que deve gerar um custom error que especifiquei. Este custom error eu peguei diretamente do ERC721Burnable.sol na biblioteca OpenZeppelin. No segundo teste, uma segunda conta tenta queimar um token que não é dela e que não possui o controle, obviamente obtendo fracasso.
Agora vamos implementar os testes ligados aos metadados dos nossos NFTs. Vou criar um teste que retorna com sucesso a URL do JSON de metadados e outra que fracassa pois o token em questão não foi mintado ainda.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
it("Should has URI metadata", async () => { const { myNFT } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); const uri = await myNFT.tokenURI(token); expect(uri).to.equal("https://www.luiztools.com.br/nft/1.json", "Wrong token URI"); }); it("Should NOT has URI metadata", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await expect(myNFT.tokenURI(1)) .to.be.revertedWithCustomError(myNFT, "ERC721NonexistentToken"); }); |
Repare que você terá de ajustar o primeiro teste à sua realidade de URL, e lembro também que esta minha URL é fictícia, apenas para fins didáticos, não vai funcionar se tentar acessá-la no navegador, mas em um cenário real, deveria.
Testes de Transferência
Agora todos os demais testes são questionáveis de serem feitos. Isso porque dos códigos que escrevemos, os testes acima cobrem completamente e qualquer outra coisa que testarmos estará testando na verdade os contratos da OpenZeppelin, códigos que não são nossos. Claro que é interessante escrever estes testes principalmente para fins didáticos, para termos um melhor entendimento do funcionamento dos contratos e de como usar o nosso contrato em uma aplicação real, por isso vou fazê-lo, mas do ponto de vista de cobertura de código/testes, eles não agregam nem 1%.
Vamos começar então testando a transferência de NFT entre contas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
it("Should transfer from", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await myNFT.transferFrom(owner.address, otherAccount.address, token); const balanceFrom = await myNFT.balanceOf(owner.address); const balanceTo = await myNFT.balanceOf(otherAccount.address); const totalSupply = await myNFT.totalSupply(); const ownerOf = await myNFT.ownerOf(token); const ownerToken = await myNFT.tokenOfOwnerByIndex(otherAccount.address, 0); expect(balanceFrom).to.equal(0, "The admin balance is wrong"); expect(balanceTo).to.equal(1, "The to balance is wrong"); expect(totalSupply).to.equal(1, "The total supply is wrong"); expect(token).to.equal(ownerToken, "Can't transfer"); expect(ownerOf).to.equal(otherAccount.address, "Can't transfer"); }); |
Aqui começamos mintando o token para em seguida transferi-lo, sendo o restante apenas as verificações do teste, para saber se o owner original não tem mais a propriedade do mesmo e se o novo owner tem.
Uma outra coisa que é interessante verificarmos, pois a especificação ERC721 assim exige, é se os eventos estão sendo corretamente emitidos. Então vamos testar a emissão do evento de transferência, na mesma situação acima.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
it("Should emit transfer event", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await expect(myNFT.transferFrom(owner.address, otherAccount.address, token)) .to.emit(myNFT, 'Transfer') .withArgs(owner.address, otherAccount.address, token); }); |
Aqui o segredo é o expect que usa o .to.emit para ler os logs da blockchain e saber se o evento foi devidamente registrado. Porque na prática os eventos da blockchain nada mais são do que logs registrados e associados aos blocos.
Agora vamos testar outro tipo de transferência, a delegada, quando o owner do token permite que outra carteira possa transferir o mesmo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
it("Should transfer from (approved)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await myNFT.approve(otherAccount.address, token); const approved = await myNFT.getApproved(token); const instance = myNFT.connect(otherAccount); await instance.transferFrom(owner.address, otherAccount.address, token); const ownerOf = await instance.ownerOf(token); expect(ownerOf).to.equal(otherAccount.address, "Can't transfer (approved)"); expect(approved).to.equal(otherAccount.address, "Can't approve"); }); |
Aqui a única diferença em relação aos testes de transferência anteriores é a chamada ao approve para permitir que a gente se conecte à segunda carteira na sequência e faça a transferência normalmente. Como já verificamos o processo normal de transferência, deixo os expects aqui cobrirem apenas o que toca a ideia de aprovação. E como a aprovação emite também um evento específico, vamos testá-lo em outro teste.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
it("Should emit approve event", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await expect(myNFT.approve(otherAccount.address, token)) .to.emit(myNFT, 'Approval') .withArgs(owner.address, otherAccount.address, token); }); |
Um outro ponto importante ainda levando em conta a aprovação é que quando uma transferência ocorre, todas as aprovações ao token devem ser eliminadas, o que será testado a seguir.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
it("Should clear approvals", async () => { const { myNFT, owner, otherAccount, oneMoreAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await myNFT.approve(otherAccount.address, token); await myNFT.transferFrom(owner.address, oneMoreAccount.address, token); const ownerOf = await myNFT.ownerOf(token); const approved = await myNFT.getApproved(token); expect(ownerOf).to.equal(oneMoreAccount.address, "Can't transfer (approved)"); expect(approved).to.equal(ethers.ZeroAddress, "Can't approve"); }); |
E a seguir a mesma ideia de testes, mas considerando uma aprovação completa na coleção do owner, ao invés de aprovar somente um token.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
it("Should transfer from (approve all)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await myNFT.setApprovalForAll(otherAccount.address, true); const instance = myNFT.connect(otherAccount); await instance.transferFrom(owner.address, otherAccount.address, token); const ownerOf = await myNFT.ownerOf(token); const isApproved = await instance.isApprovedForAll(owner.address, otherAccount.address); expect(ownerOf).to.equal(otherAccount.address, "Can't transfer (approved all)"); expect(isApproved).to.equal(true, "Can't approve for all"); }); it("Should emit ApprovalForAll event", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await expect(myNFT.setApprovalForAll(otherAccount.address, true)) .to.emit(myNFT, 'ApprovalForAll') .withArgs(owner.address, otherAccount.address, true); }); |
Na sequência, temos que escrever os cenários de fracasso, certo? Porque existem várias coisas que podem impedir uma transferência de ser realizada com sucesso e vou cobrir aqui a falta de permissão, a não existência do token, a aprovação para outra carteira que não a sua e a aprovação completa para outra carteira que não a sua.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
it("Should NOT transfer from", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await myNFT.mint(); const instance = myNFT.connect(otherAccount); const token = await instance.tokenByIndex(0); await expect(instance.transferFrom(owner.address, otherAccount.address, token)) .to.be.revertedWithCustomError(myNFT, "ERC721InsufficientApproval"); }); it("Should NOT transfer from (exists)", async () => { const { myNFT, owner, otherAccount } = await loadFixture(deployFixture); await expect(myNFT.transferFrom(owner.address, otherAccount.address, 1)) .to.be.revertedWithCustomError(myNFT, "ERC721NonexistentToken"); }); it("Should NOT transfer from (approve)", async () => { const { myNFT, owner, otherAccount, oneMoreAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await myNFT.approve(oneMoreAccount.address, token); const instance = myNFT.connect(otherAccount); await expect(instance.transferFrom(owner.address, otherAccount.address, token)) .to.be.revertedWithCustomError(myNFT, "ERC721InsufficientApproval"); }); it("Should NOT transfer from (approve all)", async () => { const { myNFT, owner, otherAccount, oneMoreAccount } = await loadFixture(deployFixture); await myNFT.mint(); const token = await myNFT.tokenByIndex(0); await myNFT.setApprovalForAll(oneMoreAccount.address, true); const instance = myNFT.connect(otherAccount); await expect(instance.transferFrom(owner.address, otherAccount.address, token)) .to.be.revertedWithCustomError(myNFT, "ERC721InsufficientApproval"); }); |
Note que a maioria dos testes de fracasso falham com a mesma mensagem pois caem na mesma situação de ausência de permissão. Escrevi todos eles mais para testar os mecanismos de aprovação mesmo.
E por fim, vamos escrever mais um teste para a função supportsInterface e com isso garantir 100% de cobertura.
|
1 2 3 4 5 6 7 8 |
it("Should support interface", async () => { const { myNFT } = await loadFixture(deployFixture); const supports = await myNFT.supportsInterface("0x80ac58cd"); expect(supports).to.equal(true, "Doesn't support interface"); }); |
Este código que passei para a função consta na documentação do ERC-721 e representa a interface, facilitando a verificação se ela está suportada em nosso contrato.
Agora experimente rodar a bateria de testes com ‘npx hardhat test’ e espero que você tenha o mesmo resultado que eu: tudo passando.
E com isso finalizamos mais este tutorial.
Caso queira se aprofundar nas funcionalidaes de ERC721 da OpenZeppelin, o vídeo abaixo se aprofunda nele.
Se quiser aprender como fazer deploy desta moeda em blockchain local, recomendo aprender a usar o HardHat Network neste tutorial.
Agora se quiser colocar em uma blockchain pública, recomendo fazer este tutorial aqui.
Uma outra dica é hospedar os metadados e as mídias dos seus NFT no IPFS, falo disso no vídeo abaixo e neste tutorial.
E se quiser aprender uma forma mais avançada do padrão 721, que economiza muito nas taxas de gás, confira este tutorial aqui de ERC-721a (Azuki) ou estude diminuição de gás em linhas gerais nesse artigo.
E outro padrão muito usado para NFTs é o ERC-1155 que ensino neste tutorial.
Um abraço e sucesso!
Olá, tudo bem?
O que você achou deste conteúdo? Conte nos comentários.
Bom dia Luiz!
Me chamo Kelvi, sou de Chapecó SC e antes de mais nada quero te meus parabéns pelo excelente trabalho, produzindo conteúdos tão ricos de forma tão bem elaborada.
Virei seu fã.
Acabei de ler os artigos Como criar NFTs usando Solidity e HardHat (JS) – Parte 1 e 2, e achei excelente, pois aprendi muito com eles.
Quero apenas fazer duas observações para os códigos propostos, pois precisei fazer 2 pequenos ajustes, então resolvi compartilhar com você com o simples objetivo de colaborar.
Primeiro, a function supportsInterface foi necessário adicionar ERC721URIStorage no override(), ficando assim a assinatura da função:
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, ERC721URIStorage) returns (bool){
Segundo, no arquivo de testes a função deployFixture precisa retornar uma terceira conta, chamada oneMoreAccount, para que alguns dos testes funcionem, deixando a função assim:
async function deployFixture() {
const [owner, otherAccount, oneMoreAccount] = await ethers.getSigners();
const MyNFT = await ethers.getContractFactory(“MyNFT”);
const myNFT = await MyNFT.deploy();
return { myNFT, owner, otherAccount, oneMoreAccount };
}
Espero ter ajudado.
Grato pelas contribuições!