NestJS-backend-API'er til virksomheder · Lektion

Enhedstest af smart contracts

Lær at skrive omfattende enhedstests til Deres Solidity-kontrakter for at sikre korrekthed, sikkerhed og forventet adfærd.

Lektion 4 af 612 trin

Enhedstest af smart contracts er en gratis NestJS-backend-API'er til virksomheder-lektion på CoddyKit. Dette er lektion 4 af 6. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i NestJS-backend-API'er til virksomheder, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. NestJS-backend-API'er til virksomheder-kurset indeholder 6 lektioner i alt.

Enhedstest af smart contracts

Velkommen til enhedstest af smart contracts! Denne lektion guider dig gennem skrivningen af effektive test til din Solidity-kode.

Enhedstest er afgørende i traditionel softwareudvikling, men de er helt uundværlige i blockchain-verdenen på grund af smart contracts' uforanderlige natur og den økonomiske værdi, de ofte beskytter.

Hvorfor teste smart contracts?

I modsætning til almindelige applikationer kan smart contracts ikke nemt ændres, når de først er implementeret. Fejl kan føre til betydelige økonomiske tab eller systemfejl.

Uforanderlighed: Implementerede contracts er permanente.
Store værdier: De administrerer ofte værdifulde aktiver.
Sikkerhed: Beskytter mod sårbarheder.
Pålidelighed: Sikrer, at funktioner opfører sig som forventet.
Gasomkostninger: Fejl kan spilde brugernes midler.

Grundig test hjælper med at finde problemer før implementering.

Introduktion til Hardhat til test

Hardhat er et populært Ethereum-udviklingsmiljø, der indeholder et effektivt testframework. Det leverer et lokalt Ethereum-netværk (Hardhat Network) til hurtig, isoleret test.

Lokalt netværk: Implementer og test uden reelle gasgebyrer.
Integration med Ethers.js: Interager med contracts ved hjælp af et velkendt JavaScript-bibliotek.
Fejlfinding: Værktøjer til at forstå mislykkede transaktioner.

Vi bruger Hardhat til at skrive vores enhedstest.

Grundlæggende contract til test

Lad os begynde med en simpel Solidity-contract, som vi bruger til vores enhedstest. Denne Counter-contract giver os mulighed for at øge, mindske og hente en tæller.

Kopiér og gem dette som contracts/Counter.sol i dit Hardhat-projekt.

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;
  }
}

Opsætning af din testfil

Hardhat forventer, at testfiler ligger i mappen test/. Vi bruger Mocha som testkører og Chai til påstande, og begge er integreret med Hardhat.

describe(): Grupperer relaterede test.
it(): Definerer et individuelt testtilfælde.
beforeEach(): Kører før hver test i en describe-blok og er nyttig til opsætning.

Lad os oprette en fil med navnet test/Counter.js.

Implementering af din contract i test

Før vi kan teste vores contracts funktioner, skal vi implementere den på vores lokale Hardhat-netværk. Blokken beforeEach er perfekt til dette, fordi den sikrer en ny implementering for hver test.

Prøv at køre denne testfil. Den bør bestå, hvis din contract er konfigureret korrekt.

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;
  });
});

Test af den oprindelige tilstand

Det første, vi skal teste, er, om vores contracts oprindelige tilstand er korrekt. Vores Counter-contracts count bør starte på 0.

Vi bruger expect() fra Chai til at lave påstande om vores contracts adfærd. to.equal() kontrollerer lighed.

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;
  });
});

Test af tilstandsændringer (forøgelse)

Lad os nu teste en funktion, der ændrer contractens tilstand. Efter kaldet til increment() forventer vi, at count øges med én.

Husk, at funktioner, der ændrer tilstanden, skal afventes med await, fordi de involverer en transaktion på blockchainen.

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;
  });
});

Test af funktionslogik (formindskelse)

Vi kan også teste funktionen decrement(). Først skal vi øge tælleren, så vi sikrer, at count er større end nul.

Dette viser, hvordan test kan involvere en række handlinger for at nå en ønsket tilstand, før resultatet kontrolleres.

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;
  });
});

Test af forventede tilbagerulninger

Smart contracts bruger ofte require() eller revert() til at håndhæve betingelser. Det er vigtigt at teste, at disse betingelser korrekt udløser en tilbagerulning, når de overtrædes.

Chais to.be.revertedWith()-påstand giver os mulighed for at kontrollere specifikke fejlmeddelelser.

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;
  });
});

Hurtigt tjek: Testpåstande

Hvad er de vigtigste fordele ved at bruge expect().to.be.revertedWith("...") i enhedstest af smart contracts?

Besvar den i den interaktive lektion

Opsummering: Enhedstestens styrke

I denne lektion har du lært, hvor vigtigt det er at lave enhedstest af smart contracts, og hvordan du skriver effektive test med Hardhat, Mocha og Chai.

Smart contracts kræver grundige test på grund af deres uforanderlighed.
Hardhat leverer et effektivt lokalt miljø til hurtig test.
Du kan teste oprindelige tilstande, tilstandsændringer, funktionslogik og forventede tilbagerulninger.

At mestre enhedstest er en grundlæggende færdighed for enhver udvikler af sikre og pålidelige DApps.

Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 20
Lektioner: 76

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Enhedstest af smart contracts” gratis?

Ja — hele teksten til “Enhedstest af smart contracts” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af NestJS-backend-API'er til virksomheder-kurset, skal du opgradere til CoddyKit PRO. NestJS-backend-API'er til virksomheder-kurset indeholder 6 lektioner i alt.

Hvad lærer jeg i “Enhedstest af smart contracts”?

Lær at skrive omfattende enhedstests til Deres Solidity-kontrakter for at sikre korrekthed, sikkerhed og forventet adfærd. Du øver dig i NestJS-backend-API'er til virksomheder med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på NestJS-backend-API'er til virksomheder?

Der kræves ingen tidligere erfaring. NestJS-backend-API'er til virksomheder på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 6.

Hvor lang tid tager lektionen “Enhedstest af smart contracts”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne NestJS-backend-API'er til virksomheder-lektion?

Ja. Alle NestJS-backend-API'er til virksomheder-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til NestJS-backend-API'er til virksomheder