Introduction

Les contrats intelligents sont immuables une fois déployés sur la blockchain, ce qui signifie qu'ils ne peuvent pas être modifiés. Par conséquent, tout bogue ou toute faille de sécurité peut avoir de graves conséquences, ce qui fait des tests une étape indispensable du processus de développement.

Dans cette leçon, nous parlerons du contrat Fa1_2TestFull, qui comprend une série de tests conçus pour vérifier la fonctionnalité de notre contrat de jeton.

Le test Fa1_2Contrat complet

Le contrat Fa1_2TestFull est une classe qui hérite de toutes les fonctionnalités des différents contrats comme Admin, Pause, Fa1_2, Mint, Burn et ChangeMetadata. Il est utilisé pour regrouper toutes ces fonctionnalités et effectuer un test approfondi afin de s'assurer que le contrat fonctionne comme prévu.

Python
class Fa1_2TestFull(Admin, Pause, Fa1_2, Mint, Burn, ChangeMetadata) :
 def __init__(self, administrator, metadata, ledger, token_metadata) :
           ChangeMetadata.__init__(self)
            Burn.__init__(self)
            Mint.__init__(self)
            Fa1_2.__init__(self, metadata, ledger, token_metadata)
 Pause.__init__(self)
            Admin.__init__(self, administrateur)

Le constructeur de la classe Fa1_2TestFull initialise toutes les fonctionnalités.

Mise en place d'un test

Pour notre contrat, nous commençons par mettre en place le scénario de test avec les comptes de test et l'initialisation du contrat. Cela se fait dans une fonction de test décorée avec @sp.add_test.

Python
@sp.add_test(name="FA12")def test() :
   # Initialiser le scénario de test et les comptes
 sc = sp.test_scenario(m)
    admin = sp.test_account("Administrator")
    alice = sp.test_account("Alice")
    bob = sp.test_account("Robert")

    # Initialiser le contrat avec quelques valeurs initiales
 token_metadata = {
        "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(administrator=admin.address,metadata=contract_metadata,token_metadata=token_metadata,ledger={},)
    sc += c1

Nous définissons les comptes de test : Admin, Alice et Bob. Ensuite, nous initialisons notre contrat, Fa1_2TestFull, avec quelques valeurs initiales. L'opérateur += ajoute le contrat au scénario.

Désormais, pour vous aider à mieux comprendre le code, le code sera à gauche et une visualisation de la ligne de code surlignée sera à droite. Exemple ici :

Tests en cours d'exécution

L'étape suivante consiste à effectuer des tests, ce qui implique de déclencher différentes fonctions contractuelles et de vérifier les résultats.

Par exemple, pour tester la fonctionnalité de frappe de monnaie, nous exécutons :

Python
sc.h2("Admin frappe quelques pièces")
c1.mint(address=alice.address, value=12).run(sender=admin)

Cette ligne exécute un test au cours duquel l'administrateur frappe 12 jetons pour Alice. Si la fonction frappe avec succès les jetons et met correctement à jour le solde d'Alice, le test est réussi.

Vérification des résultats

SmartPy fournit la méthode verify pour s'assurer qu'une condition est vraie. Si la condition n'est pas remplie, le test échoue. Par exemple :

Python
 c1.update_metadata(key="" , value=sp.bytes("0x00")).run(sender=admin)
 sc.verify(c1.data.metadata["" ] == sp.bytes("0x00"))

Ces lignes vérifient que les métadonnées du contrat ont été correctement mises à jour en "0x00 ". S'il n'a pas été mis à jour correctement, le test échoue.

Tests avancés

Vos tests de contrats intelligents doivent couvrir tous les cas d'utilisation possibles, y compris les cas limites et les défaillances potentielles. Il peut s'agir de transferts dépassant le solde d'un utilisateur, de jetons brûlés lorsque le contrat est mis en pause, etc.

Par exemple, l'échec d'un test de transfert pourrait ressembler à ce qui suit :

Python
sc.h2("Bob essaie d'effectuer un transfert à partir d'Alice mais il n'a pas son accord")
c1.transfer(from_=alice.address, to_=bob.address, value=4).run(sender=bob, valid=False)

Ici, Bob tente de transférer 4 jetons du compte d'Alice sans en avoir reçu l'autorisation. Comme cette opération devrait échouer, nous avons défini valid=False dans la fonction d'exécution. Si le contrat empêche correctement le transfert, le test est réussi.

Récapitulation

Les tests sont essentiels au développement des contrats intelligents. Étant donné la nature immuable de la blockchain, toute erreur dans un contrat peut avoir des conséquences permanentes et potentiellement coûteuses. La rédaction de tests complets permet de s'assurer que toutes les fonctions se comportent comme prévu, ce qui se traduit par des contrats robustes et sûrs.

N'oubliez pas d'écrire des tests pour les cas positifs et négatifs. Les cas positifs valident le fait qu'une fonction fonctionne correctement lorsqu'elle est utilisée comme prévu. Les cas négatifs garantissent que le contrat se comporte correctement lorsqu'il traite des entrées incorrectes ou inattendues.