Einführung

Smart Contracts sind unveränderlich, sobald sie auf der Blockchain bereitgestellt werden, was bedeutet, dass sie nicht geändert werden können. Daher können Fehler oder Sicherheitslücken schwerwiegende Folgen haben, sodass das Testen zu einem unverzichtbaren Schritt im Entwicklungsprozess wird.

In dieser Lektion besprechen wir den Fa1_2TestFull Vertrag, der eine Reihe von Tests zur Überprüfung der Funktionalität unseres Token-Vertrags umfasst.

Der Fa1_2TestFull Vertrag

Der Fa1_2TestFull Vertrag ist eine Klasse, die alle Funktionalitäten der verschiedenen Verträge wie Admin, Pause, Fa1_2, Mint, Burn und ChangeMetadata erbt. Es wird verwendet, um alle diese Funktionen zusammenzufassen und einen gründlichen Test durchzuführen, um sicherzustellen, dass der Vertrag wie erwartet funktioniert.

Python 
 Klasse Fa1_2TestFull(Admin, Pause, Fa1_2, Mint, Burn, ChangeMetadata): 
 def __init__(self, Administrator, Metadata, Ledger, token_metadata): 
 ChangeMetadata.__init__(selbst)
            Brennen.__init__(selbst)
            Minze.__init__(selbst)
            Fa1_2.__init__(selbst, metadata, ledger, token_metadata) 
 Pause.__init__(selbst)
            Administrator.__init__(selbst, Administrator)

Der Klassenkonstruktor Fa1_2TestFull initialisiert alle Funktionen.

Einrichten eines Tests

Für unseren Vertrag beginnen wir mit der Einrichtung des Testszenarios mit Testkonten und der Vertragsinitialisierung. Dies geschieht innerhalb einer Testfunktion, die mit @sp.add_test dekoriert ist.

Python 
 @sp.add_test(name="FA12")def test(): 
 # Testszenario und Konten initialisieren 
 sc = sp.test_scenario(m)
    admin = sp.test_account("Administrator")
    alice = sp.test_account("Alice")
    bob = sp.test_account("Robert")

    # Vertrag mit einigen Anfangswerten initialisieren 
 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

Wir definieren die Testkonten: Admin, Alice und Bob. Dann initialisieren wir unseren Vertrag Fa1_2TestFull mit einigen Anfangswerten. Der += Operator fügt den Vertrag zum Szenario hinzu.

Damit Sie den Code besser verstehen, wird er von nun an auf der linken Seite und eine Visualisierung der hervorgehobenen Codezeile auf der rechten Seite angezeigt. Beispiel hier:

Ausführen von Tests

Der nächste Schritt besteht darin, Tests durchzuführen. Dabei werden verschiedene Vertragsfunktionen ausgelöst und die Ergebnisse überprüft.

Um beispielsweise die Minting-Funktionalität zu testen, führen wir Folgendes aus:

Python 
 sc.h2("Admin prägt ein paar Münzen") 
 c1.mint(address=alice.address, value=12).run(sender=admin)

Diese Zeile führt einen Test aus, bei dem der Administrator 12 Token für Alice prägt. Wenn die Funktion die Token erfolgreich prägt und Alices Guthaben korrekt aktualisiert, ist dieser Test erfolgreich.

Ergebnisse überprüfen

SmartPy bietet die verify , um sicherzustellen, dass eine Bedingung wahr ist. Wenn die Bedingung nicht erfüllt ist, schlägt der Test fehl. Zum Beispiel:

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

Diese Zeilen bestätigen, dass die Metadaten des Vertrags korrekt auf "0x00" aktualisiert wurden. Wenn es nicht korrekt aktualisiert wurde, schlägt der Test fehl.

Erweiterte Tests

Ihre Smart-Contract-Tests sollten alle möglichen Anwendungsfälle abdecken, einschließlich Randfällen und potenziellen Fehlern. Dazu können Überweisungen gehören, die das Guthaben eines Benutzers überschreiten, das Verbrennen von Token, wenn der Vertrag pausiert wird, usw.

Ein fehlgeschlagener Übertragungstest könnte beispielsweise so aussehen:

Python 
 sc.h2("Bob versucht, von Alice zu übertragen, aber er hat nicht ihre Zustimmung") 
 c1.transfer(from_=alice.address, to_=bob.address, value=4).run(sender=bob, gültig=Falsch)

Hier versucht Bob, ohne Genehmigung 4 Token von Alices Konto zu übertragen. Da dieser Vorgang fehlschlagen sollte, setzen wir in der run valid=False . Wenn der Vertrag die Übertragung korrekt verhindert, ist der Test bestanden.

Rekapitulieren

Tests sind bei der Entwicklung intelligenter Verträge von entscheidender Bedeutung. Aufgrund der Unveränderlichkeit der Blockchain kann jeder Fehler in einem Vertrag dauerhafte und möglicherweise kostspielige Folgen haben. Durch das Schreiben umfassender Tests wird sichergestellt, dass sich alle Funktionen wie erwartet verhalten, was zu robusten und sicheren Verträgen führt.

Denken Sie daran, Tests sowohl für positive als auch für negative Fälle zu schreiben. Positive Fälle bestätigen, dass eine Funktion bei bestimmungsgemäßer Verwendung korrekt funktioniert. Negative Fälle stellen sicher, dass sich der Vertrag beim Umgang mit falschen oder unerwarteten Eingaben korrekt verhält.