Introdução

Os contratos inteligentes são imutáveis uma vez implementados na cadeia de blocos, o que significa que não podem ser modificados. Portanto, quaisquer bugs ou vulnerabilidades de segurança podem ter consequências graves, tornando o teste uma etapa indispensável no processo de desenvolvimento.

Nesta lição, discutiremos o contrato FA1_2TestFull, que inclui uma série de testes concebidos para verificar a funcionalidade do nosso contrato de token.

O Contrato FA1_2TestFull

O contrato FA1_2TestFull é uma classe que herda todas as funcionalidades dos diferentes contratos como Admin, Pause, Fa1_2, Mint, Burn e Changemetadata. É usado para agregar todas estas funcionalidades e realizar um teste completo para garantir que o contrato está a funcionar conforme o esperado.

Python
classe FA1_2TestFull (Admin, Pausa, Fa1_2, Mint, Burn, ChangeMetadata):
 def __init__(self, administrador, metadados, livro-razão, token_metadata):
 Alterar metadados.__init__(auto)
            Queimar.__init__(auto)
            Hortelã.__init__(auto)
            Fa1_2.__init__(eu, metadados, livro-razão, token_metadata)
 Pausa.__init__(auto)
            Administrador.__init__(eu, administrador)

O construtor da classe FA1_2TestFull inicializa todas as funcionalidades.

Configurar um teste

Para o nosso contrato, começamos por configurar o cenário de teste com contas de teste e a inicialização do contrato. Isto é feito dentro de uma função de teste decorada com @sp.add_test.

Python
@sp .add_test (nome = " FA12") teste de definição ():
 # Inicializar cenário de teste e contas
 sc = sp.test_scenario (m)
    admin = sp.test_account (Administrador) " "
    alice = sp.test_account (Alice) " "
    bob = sp.test_account (Robert) " "

    # Inicializar contrato com alguns valores iniciais
 token_metadados = {
        "decimals": sp.utils.bytes_of_string("18"),  # Mandatory by the spec"name": sp.utils.bytes_of_string("My Great Token"),  # Recommended"symbol": sp.utils.bytes_of_string("MGT"),  # Recommended# Extra fields"icon": sp.utils.bytes_of_string("https://smartpy.io/static/img/logo-only.svg"),
    }
    contract_metadata = sp.utils.metadata_of_url (ipfs: //qmaiaUJ1FFngYTU8RLBJC3EEN9CSKWAF8EGmbNDMHzpNfd) " "
    c1 = m.FA1_2TestFull (administrador=admin.address, metadata=contract_metadata, token_metadata=token_metadata, ledger= {},)
    sc += c1

Definimos as contas de teste: Admin, Alice e Bob. Em seguida, inicializamos o nosso contrato, FA1_2Testfull, com alguns valores iniciais. O operador += adiciona o contrato ao cenário.

A partir de agora, para o ajudar a entender melhor o código, o código estará à esquerda e uma visualização da linha de código destacada estará à direita. Exemplo aqui:

Testes em execução

O próximo passo é executar testes, e isso envolve acionar diferentes funções de contrato e verificar os resultados.

Por exemplo, para testar a funcionalidade de cunhagem, executamos:

Python
sc.h2 (O " administrador cunha algumas moedas) "
c1.mint (endereço=alice.address, valor=12) .run (remetente = admin)

Esta linha executa um teste onde o administrador cunha 12 fichas para Alice. Se a função cunha com êxito os tokens e actualiza corretamente o saldo de Alice, então este teste passa.

Verificar Resultados

O SmartPy fornece o método de verificação para garantir que uma condição é verdadeira. Se a condição não for cumprida, o teste falhará. Por exemplo:

Python
 c1.update_metadata (chave =, valor = sp.bytes (0x00)) .run (remetente = " " administrador) " "
 sc.verify (c1.data.metadata [] " " == sp.bytes (0x00)) " "

Essas linhas verificam se os metadados do contrato foram atualizados corretamente para ""0x00. Se não foi atualizado corretamente, o teste falha.

Testes Avançados

Os seus testes de contrato inteligente devem abranger todos os casos de uso possíveis, incluindo casos extremos e potenciais falhas. Estes podem incluir transferências que excedam o saldo de um utilizador, queima de tokens quando o contrato é pausado, etc.

Por exemplo, um teste de transferência com falha pode ter este aspecto:

Python
sc.h2 ("Bob tenta transferir-se de Alice mas não tem a aprovação dela) "
c1.transfer (de_=alice.address, para_=bob.address, value=4) .run (remetente = bob, Válido = falso)

Aqui, Bob tenta transferir 4 fichas da conta da Alice sem ter aprovação. Uma vez que esta operação deve falhar, definimos valid=False na função de execução. Se o contrato impedir corretamente a transferência, o teste passa.

Recapitulação

Os testes são cruciais no desenvolvimento de contratos inteligentes. Dada a natureza imutável da blockchain, qualquer erro num contrato pode ter consequências permanentes e potencialmente dispendiosas. Escrever testes abrangentes garante que todas as funções se comportem conforme o esperado, levando a contratos robustos e seguros.

Lembre-se de escrever testes para casos positivos e negativos. Casos positivos validam que uma função funciona corretamente quando usada como pretendido. Casos negativos garantem que o contrato se comporta corretamente no tratamento de entradas incorretas ou inesperadas.