🇧🇷
Ethereum Developer Pack - PT
  • Ethereum Developer Pack - PT
  • Módulo 1
    • Introdução a Smart Contracts
      • Fundamentos de Blockchain
        • Histórico
        • Bitcoin
        • O que é Blockchain
        • Conceitos-chave em Blockchain
        • Como funciona a Blockchain
        • Tipos de Blockchain
        • Modelos de Consenso
      • A nova Internet
        • Web 3
        • Elementos Fundamentais
        • Impacto do Ethereum em Diversos Setores
      • Wallets
        • Componentes de uma wallet
        • Tipos de Wallet
        • Códigos Mnemônicos
      • Ethereum 101
        • Smart Contracts
        • Contas
          • Tipos de contas
          • Conteúdo das contas
        • Transações
          • Componentes
          • Ciclo de vida
        • Gás
        • Solidity
        • EVM
          • A máquina de estados
          • Opcodes
          • Como funciona a EVM
          • Clientes de execução
          • DApps
      • Blockchain Explorer
        • Funções de um blockchain explorer
        • Beneficios de utilizar um blockchain explorer
      • Remix
        • Características do Remix
        • Workspaces ou espaços de trabalho
        • Carregar e compilar um contrato
        • Implantar na máquina virtual do Remix (Remix VM)
        • Interagindo com funções
        • Deployar em uma rede pública
      • Crie seu primeiro Smart Contract
  • Módulo 2
    • Fundamentos de Solidity
      • Hello World
      • Tipos de Dados
      • Funções
      • Variáveis
        • Exercício 1
      • Operadores
        • Ejercicio 2
      • Constructor
        • Exercício 3
      • Convenções de nomenclatura
      • Tipos de armazenamento para variáveis
      • Estruturas de Controle
        • Exercício 4
      • Modificadores
      • Eventos
        • Exercício 5
      • Tipos de Referencia
        • Arrays
          • Exercício 6
        • Mappings
          • Exercício 7
        • Structs
          • Exercício 8
      • Address Payable
      • Como os contratos e funções recebem Ether.
      • Transferências de Ether
      • Conceitos Avançados
        • Codificação de ABI
        • Hashing
        • This
        • Herança
        • Abstract
        • Interface
        • Chamada entre contratos
        • EVM
        • ABI
        • Bytecode
        • Opcodes
  • Módulo 3
    • ERCs, Bibliotecas e Padrões de Desenvolvimento
      • Boas Práticas de Desenvolvimento
      • Padrões de Desenvolvimento
      • EIP & ERC
      • ERC-20
      • ERC-721
      • Open Zeppelin
      • Crie um Token ERC-20
      • Almacenamiento Descentralizado: IPFS
      • Crea un Token ERC-721
      • DeFi
  • Módulo 4
    • Kit de ferramentas para desenvolvimento na Ethereum
      • Requisitos para o módulo 4
        • Terminal
        • Git e Github
        • Node.js e npm
        • Visual Studio Code para Solidity
      • Toolkit
        • JSON-RPC
        • Ethers.js
          • Exercício
        • Hardhat
          • Implantação de um contrato no Hardhat
          • Implantação de um contrato em uma rede pública
        • Scaffold-ETH
          • Características do Scaffold-ETHCaracterísticas
          • Como instalar o Scaffold-ETH
  • Módulo 5
    • Segurança, Testes e Auditorias
      • Testes
        • Importância de realizar testes
        • Métodos para testar contratos inteligentes
          • Testes automatizados
          • Testes manuais
        • Conceitos importantes em testes
        • Ferramentas para testes
        • Testes com Hardhat
        • Recursos adicionais
      • Segurança
        • Uma mentalidade diferente de design
        • Principais vulnerabilidades em contratos inteligentes
          • Reentrancy attack (ataque de reentrada)
          • Replay attack (ataque de repetición)
          • Price Oracle Manipulation (Manipulación de Oráculos de Precios)
          • Missing Access Control (Pérdida de Control de Acceso)
          • Reward Manipulation (Manipulación de Recompensas)
          • Failure to Initialize (Falla al Inicializar)
          • Front-running
          • Invariant Breaks (Quebra de Invariantes)
          • Mishandling of ETH (Má gestão de ETH)
          • Denial of Service (DoS - Negação de Serviço)
          • Integer overflow and underflow (Overflow e Underflow de inteiros)
          • Phishing y Typosquatting
        • Recursos adicionais
      • Auditoria de smart contracts
        • Processo de Auditoria
        • Ferramentas
        • Como se preparar para uma auditoria
        • O teste Rekt
        • Desafios
        • Recursos adicionais
  • Contribuye
    • Kipu Explorer
Powered by GitBook
On this page
  • Mainnet Forking
  • Desenvolvimento Orientado por Testes
  • Cobertura de testes
  • Fixtures
  1. Módulo 5
  2. Segurança, Testes e Auditorias
  3. Testes

Conceitos importantes em testes

Mainnet Forking

O mainnet forking é uma técnica usada nos testes de blockchain, na qual se pega um número específico de bloco e uma referência para um nó de blockchain (como o Geth) e se copia toda a informação de estado relevante até aquele número de bloco. Esse estado clonado permite que os desenvolvedores executem testes contra ele. Essa estratégia é comumente implementada contra a mainnet, especialmente quando se testam interações com códigos de terceiros que já estão implantados.

Uma das vantagens significativas do mainnet forking é a capacidade de executar todos os testes localmente, reduzindo significativamente tanto os riscos quanto os custos associados aos testes. Como a rede local reflete o estado da cadeia, ela também pode ser revertida ao seu estado original após cada teste, permitindo testes eficientes e isolados. Além disso, o estado local pode ser manipulado conforme necessário para simular cenários específicos que podem não estar presentes no estado do fork. O mainnet forking é, portanto, uma ferramenta poderosa, especialmente para testar cenários que não são facilmente cobertos pelos testes unitários e de integração.

Desenvolvimento Orientado por Testes

O Desenvolvimento Orientado por Testes (Test Driven Development - TDD) é uma metodologia na qual os testes são escritos antes do código real. Esse enfoque tenta garantir que todo o código esteja alinhado com as especificações impostas pelos testes. O fluxo de trabalho envolve escrever os testes, verificar que eles estão falhando, escrever o código e confirmar que os testes passaram. É importante notar que o código que faz o teste passar deve ser a quantidade mínima necessária, evitando que qualquer código desnecessário se infiltre no projeto. Se os testes falharem, é porque os testes ou o código contêm um erro.

Consequentemente, o processo é repetido após uma rodada de reestruturação do código e dos testes. No final de uma rodada de TDD, é comum revisar novamente toda a base de código e estruturá-la de forma mais organizada, por exemplo, externalizando o código em bibliotecas ou componentes individuais e executando novamente o conjunto de testes para garantir que nenhum erro tenha sido introduzido. Embora o TDD não possa garantir código livre de erros, geralmente oferece garantias mais fortes do que adaptar um conjunto de testes posteriormente. Ele também acelera o processo de escrita de testes, pois os desenvolvedores frequentemente escrevem os testes no final do processo de desenvolvimento, o que pode levar à fadiga e à falta de cobertura nos cenários de teste.

O TDD é aplicado principalmente a testes unitários, mas também pode ser usado para testes de integração, assumindo que os componentes estão bem definidos e não é provável que mudem. Embora frequentemente seja percebido como uma desvantagem, o TDD obriga os desenvolvedores e gerentes de projeto a refletirem primeiro sobre a arquitetura e o design de seus contratos inteligentes e a estabelecer um conjunto de requisitos do usuário que o sistema precisa atender. No entanto, vale notar que todas as vantagens do TDD têm um custo em termos de velocidade de desenvolvimento, especialmente quando os desenvolvedores ainda não estão familiarizados com o desenvolvimento orientado por testes.

Cobertura de testes

A cobertura de testes (test coverage) de contratos inteligentes refere-se à medida em que o código do contrato foi executado e verificado por meio de testes automatizados. Em termos simples, é uma métrica que indica qual porcentagem do código foi testada através de casos de teste específicos.

Uma cobertura de testes de 100% é o objetivo, mas é difícil de alcançar na prática. No entanto, os desenvolvedores devem aspirar cobrir todas as funções e casos de uso críticos do contrato. Ferramentas de cobertura de código, como o solidity-coverage, podem ajudar a medir quais partes do código foram testadas.

Importância da cobertura de testes

  1. Segurança:

    • Garante que todas as partes críticas do contrato foram verificadas e são seguras contra possíveis vulnerabilidades.

  2. Funcionalidade:

    • Verifica que todas as funções do contrato operem como esperado sob diversas condições e entradas.

  3. Confiança:

    • Proporciona confiança tanto aos desenvolvedores quanto aos usuários de que o contrato foi exaustivamente testado e é confiável.

  4. Manutenção:

    • Facilita a manutenção e atualização do contrato, garantindo que qualquer mudança ou adição ao código também seja testada adequadamente.

Tipos de cobertura de testes

  1. Cobertura de Linhas:

    • Mede a porcentagem de linhas de código que foram executadas durante os testes.

  2. Cobertura de Funções:

    • Mede a porcentagem de funções que foram chamadas pelo menos uma vez durante os testes.

  3. Cobertura de Condições:

    • Mede a porcentagem de condições booleanas possíveis que foram avaliadas como verdadeiras e falsas durante os testes.

  4. Cobertura de Ramos:

    • Mede a porcentagem de caminhos de execução (ramificações) que foram seguidos durante os testes, incluindo bifurcações em declarações como if, else, switch, etc.

Ferramenta para medir a cobertura de testes

Fixtures

Os fixtures são cenários de teste que são executados uma vez e, em seguida, são lembrados por meio de capturas do estado da blockchain. Entre os benefícios que eles oferecem, podemos destacar:

  • Eliminam a necessidade de implantar o contrato novamente antes de fazer um novo teste.

  • Garantem que os testes sejam executados sempre sob as mesmas condições iniciais, o que é crucial para a consistência e confiabilidade dos testes.

  • Permitem que cada teste seja executado em um ambiente limpo e isolado, evitando que o estado de um teste afete o outro.

  • Ajudam a reduzir o tempo de configuração para cada teste individual, ao definir um estado inicial comum para um grupo de testes.

O Hardhat permite configurar fixtures em seu ambiente de testes.

PreviousTestes manuaisNextFerramentas para testes

Last updated 22 days ago

Uma das ferramentas mais utilizadas para medir a cobertura de testes em contratos inteligentes escritos em Solidity é o solidity-coverage. Ela gera um relatório detalhado sobre quais partes do código foram executadas durante os testes. Pode ser executada de forma independente ou dentro do Hardhat. Você pode encontrar mais informações em no GitHub.

seu repositório