Enterprise-backend-API's met NestJS · Les

Smart contracts testen met unit-tests

Leer uitgebreide unit-tests te schrijven voor uw Solidity-contracten om de correctheid, beveiliging en verwachte werking ervan te waarborgen.

Les 4 van 612 stappen

Smart contracts testen met unit-tests is een gratis Enterprise-backend-API's met NestJS-les op CoddyKit. Dit is les 4 van 6. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Enterprise-backend-API's met NestJS. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Enterprise-backend-API's met NestJS bevat in totaal 6 lessen.

Smart contracts testen met unittests

Welkom bij unittests voor smart contracts! In deze les leer je effectieve tests voor je Solidity-code schrijven.

Unittests zijn cruciaal bij traditionele softwareontwikkeling, maar in de blockchainwereld absoluut onmisbaar vanwege het onveranderlijke karakter van smart contracts en de financiële waarde die ze vaak veiligstellen.

Waarom smart contracts testen?

In tegenstelling tot gewone toepassingen kunnen smart contracts na implementatie niet eenvoudig worden gewijzigd. Bugs kunnen leiden tot aanzienlijke financiële verliezen of systeemstoringen.

Onveranderlijkheid: Geïmplementeerde contracts zijn permanent.
Grote belangen: Ze beheren vaak waardevolle activa.
Beveiliging: Beschermt tegen kwetsbaarheden.
Betrouwbaarheid: Zorgt ervoor dat functies zich gedragen zoals verwacht.
Gaskosten: Bugs kunnen geld van gebruikers verspillen.

Grondig testen helpt problemen vóór de implementatie op te sporen.

Kennismaken met Hardhat voor testen

Hardhat is een populaire Ethereum-ontwikkelomgeving met een krachtig testframework. Het biedt een lokaal Ethereum-netwerk (Hardhat Network) voor snel en geïsoleerd testen.

Lokaal netwerk: Implementeer en test zonder echte gaskosten.
Ethers.js-integratie: Communiceer met contracts via een vertrouwde JavaScript-bibliotheek.
Foutopsporing: Hulpmiddelen om mislukte transacties te begrijpen.

We gebruiken Hardhat om onze unittests te schrijven.

Basiscontract voor tests

Laten we beginnen met een eenvoudig Solidity-contract dat we voor onze unittests gebruiken. Met dit Counter-contract kunnen we een teller verhogen, verlagen en uitlezen.

Kopieer dit en sla het op als contracts/Counter.sol in je Hardhat-project.

pragma solidity ^0.8.0;

contract Counter {
  uint public count;

  constructor() {
    count = 0;
  }

  function increment() public {
    count += 1;
  }

  function decrement() public {
    require(count > 0, "Count cannot be negative");
    count -= 1;
  }

  function getCount() public view returns (uint) {
    return count;
  }
}

Je testbestand instellen

Hardhat verwacht testbestanden in de map test/. We gebruiken Mocha als testuitvoerder en Chai voor beweringen; beide zijn geïntegreerd met Hardhat.

describe(): Groepeert gerelateerde tests.
it(): Definieert een afzonderlijk testgeval.
beforeEach(): Wordt vóór elke test in een describe-blok uitgevoerd en is handig voor de voorbereiding.

Laten we een bestand met de naam test/Counter.js maken.

Je contract testen implementeren

Voordat we de functies van ons contract kunnen testen, moeten we het implementeren op ons lokale Hardhat-netwerk. Het blok beforeEach is hiervoor ideaal, omdat het voor elke test een nieuwe implementatie garandeert.

Probeer dit testbestand uit te voeren. De test hoort te slagen als je contract correct is ingesteld.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", function () {
  let counter; // Declare 'counter' to be accessible in all tests

  beforeEach(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.deploy();
    await counter.deployed(); // Wait for deployment to be confirmed
  });

  // A simple test to confirm deployment
  it("Should confirm the contract is deployed", async function () {
    expect(counter.address).to.not.be.null;
  });
});

De beginstatus testen

Het eerste wat we moeten testen, is of de beginstatus van ons contract correct is. De count van ons Counter-contract hoort te beginnen op 0.

We gebruiken expect() van Chai om beweringen over het gedrag van ons contract te doen. to.equal() controleert op gelijkheid.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", function () {
  let counter;

  beforeEach(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.deploy();
    await counter.deployed();
  });

  it("Should return the initial count of 0", async function () {
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should confirm the contract is deployed", async function () {
    expect(counter.address).to.not.be.null;
  });
});

Statuswijzigingen testen (verhogen)

Laten we nu een functie testen die de status van het contract wijzigt. Nadat we increment() aanroepen, verwachten we dat count met één toeneemt.

Houd er rekening mee dat functies die de status wijzigen met await moeten worden afgewacht, omdat ze een transactie op de blockchain uitvoeren.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", function () {
  let counter;

  beforeEach(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.deploy();
    await counter.deployed();
  });

  it("Should return the initial count of 0", async function () {
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should increment the count by 1", async function () {
    await counter.increment();
    expect(await counter.getCount()).to.equal(1);
  });

  it("Should confirm the contract is deployed", async function () {
    expect(counter.address).to.not.be.null;
  });
});

Functielogica testen (verlagen)

We kunnen ook de functie decrement() testen. Eerst moeten we de teller hiervoor verhogen, zodat count groter is dan nul.

Hiermee zie je hoe tests een reeks bewerkingen kunnen bevatten om vóór de bewering over de uitkomst een gewenste status te bereiken.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", function () {
  let counter;

  beforeEach(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.deploy();
    await counter.deployed();
  });

  it("Should return the initial count of 0", async function () {
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should increment the count by 1", async function () {
    await counter.increment();
    expect(await counter.getCount()).to.equal(1);
  });

  it("Should decrement the count by 1", async function () {
    await counter.increment(); // First increment to make count > 0
    await counter.decrement();
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should confirm the contract is deployed", async function () {
    expect(counter.address).to.not.be.null;
  });
});

Verwachte terugdraaiingen testen

Smart contracts gebruiken vaak require() of revert() om voorwaarden af te dwingen. Het is essentieel om te testen of deze voorwaarden bij overtreding inderdaad een terugdraaiing veroorzaken.

Met Chai's bewering to.be.revertedWith() kunnen we controleren op specifieke foutmeldingen.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", function () {
  let counter;

  beforeEach(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.deploy();
    await counter.deployed();
  });

  it("Should return the initial count of 0", async function () {
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should increment the count by 1", async function () {
    await counter.increment();
    expect(await counter.getCount()).to.equal(1);
  });

  it("Should decrement the count by 1", async function () {
    await counter.increment();
    await counter.decrement();
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should revert if decrementing from zero", async function () {
    await expect(counter.decrement()).to.be.revertedWith("Count cannot be negative");
  });

  it("Should confirm the contract is deployed", async function () {
    expect(counter.address).to.not.be.null;
  });
});

Snelle controle: testbeweringen

Wat zijn de belangrijkste voordelen van het gebruik van expect().to.be.revertedWith("...") in unittests voor smart contracts?

Beantwoord dit in de interactieve les

Samenvatting: de kracht van unittests

In deze les heb je geleerd hoe belangrijk unittests voor smart contracts zijn en hoe je effectieve tests schrijft met Hardhat, Mocha en Chai.

Smart contracts vereisen grondige tests vanwege hun onveranderlijkheid.
Hardhat biedt een krachtige lokale omgeving voor snel testen.
Je kunt beginstatussen, statuswijzigingen, functielogica en verwachte terugdraaiingen testen.

Unittests beheersen is een fundamentele vaardigheid voor elke ontwikkelaar van veilige en betrouwbare DApps.

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 20
Lessen: 76

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Smart contracts testen met unit-tests” gratis?

Ja — de volledige tekst van “Smart contracts testen met unit-tests” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Enterprise-backend-API's met NestJS wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Enterprise-backend-API's met NestJS bevat in totaal 6 lessen.

Wat leer ik in “Smart contracts testen met unit-tests”?

Leer uitgebreide unit-tests te schrijven voor uw Solidity-contracten om de correctheid, beveiliging en verwachte werking ervan te waarborgen. Je oefent met Enterprise-backend-API's met NestJS door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Enterprise-backend-API's met NestJS te beginnen?

Ervaring vooraf is niet nodig. Enterprise-backend-API's met NestJS op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 6.

Hoe lang duurt de les “Smart contracts testen met unit-tests”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Enterprise-backend-API's met NestJS?

Ja. Elke les over Enterprise-backend-API's met NestJS bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Enterprise-backend-API's met NestJS