NestJS: backend-API:er för företag · Lektion

Enhetstestning av smarta kontrakt

Lär dig att skriva omfattande enhetstester för era Solidity-kontrakt för att säkerställa deras korrekthet, säkerhet och förväntade beteende.

Lektion 4 av 612 steg

Enhetstestning av smarta kontrakt är en gratis lektion i NestJS: backend-API:er för företag på CoddyKit. Detta är lektion 4 av 6. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för NestJS: backend-API:er för företag, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i NestJS: backend-API:er för företag innehåller totalt 6 lektioner.

Enhetstestning av smarta kontrakt

Välkommen till enhetstestning av smarta kontrakt! I den här lektionen får du lära dig att skriva effektiva tester för din Solidity-kod.

Enhetstester är avgörande inom traditionell programutveckling, men de är helt nödvändiga i blockkedjevärlden på grund av smarta kontrakts oföränderlighet och det ekonomiska värde som de ofta skyddar.

Varför testa smarta kontrakt?

Till skillnad från vanliga applikationer kan smarta kontrakt inte enkelt ändras när de väl har distribuerats. Fel kan leda till betydande ekonomiska förluster eller systemfel.

Oföränderlighet: Distribuerade kontrakt är permanenta.
Höga insatser: De hanterar ofta värdefulla tillgångar.
Säkerhet: Skydda mot sårbarheter.
Tillförlitlighet: Säkerställ att funktionerna beter sig som förväntat.
Gas-kostnader: Fel kan slösa bort användarnas pengar.

Grundliga tester hjälper dig att upptäcka problem innan distributionen.

Introduktion till testning med Hardhat

Hardhat är en populär utvecklingsmiljö för Ethereum som innehåller ett kraftfullt testningsramverk. Den tillhandahåller ett lokalt Ethereum-nätverk (Hardhat Network) för snabb och isolerad testning.

Lokalt nätverk: Distribuera och testa utan riktiga gaskostnader.
Integration med Ethers.js: Interagera med kontrakt med hjälp av ett välbekant JavaScript-bibliotek.
Felsökning: Verktyg för att förstå varför transaktioner misslyckas.

Vi använder Hardhat för att skriva våra enhetstester.

Grundläggande kontrakt för testning

Vi börjar med ett enkelt Solidity-kontrakt som vi ska använda i våra enhetstester. Med kontraktet Counter kan vi öka, minska och hämta ett räknevärde.

Kopiera och spara detta som contracts/Counter.sol i ditt 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;
  }
}

Konfigurera testfilen

Hardhat förväntar sig att testfiler finns i katalogen test/. Vi använder Mocha som testkörning och Chai för påståenden, vilka båda är integrerade med Hardhat.

describe(): Grupperar relaterade tester.
it(): Definierar ett enskilt testfall.
beforeEach(): Körs före varje test i ett describe-block och är användbart för konfigurering.

Skapa en fil med namnet test/Counter.js.

Distribuera kontraktet i tester

Innan vi kan testa kontraktets funktioner måste vi distribuera det till vårt lokala Hardhat-nätverk. Blocket beforeEach passar perfekt för detta eftersom det säkerställer en ny distribution för varje test.

Försök att köra den här testfilen. Testet bör godkännas om kontraktet är korrekt konfigurerat.

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

Testa det initiala tillståndet

Det första vi bör testa är om kontraktets initiala tillstånd är korrekt. count i kontraktet Counter ska börja på 0.

Vi använder expect() från Chai för att göra påståenden om kontraktets beteende. to.equal() kontrollerar likhet.

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

Testa tillståndsändringar (ökning)

Nu testar vi en funktion som ändrar kontraktets tillstånd. Efter att vi har anropat increment() förväntar vi oss att count ökar med ett.

Kom ihåg att funktioner som ändrar tillståndet måste awaitas eftersom de innefattar en transaktion på blockkedjan.

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

Testa funktionslogik (minskning)

Vi kan också testa funktionen decrement(). Först måste vi öka räknaren så att count är större än noll.

Detta visar hur tester kan innehålla en sekvens av operationer för att nå ett önskat tillstånd innan resultatet kontrolleras.

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

Testa förväntade återställningar

Smarta kontrakt använder ofta require() eller revert() för att upprätthålla villkor. Det är viktigt att testa att dessa villkor korrekt utlöser en återställning när de överträds.

Chais påstående to.be.revertedWith() gör det möjligt att kontrollera specifika felmeddelanden.

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

Snabbkontroll: testpåståenden

Vilka är de viktigaste fördelarna med att använda expect().to.be.revertedWith("...") i enhetstester av smarta kontrakt?

Besvara frågan i den interaktiva lektionen

Sammanfattning: enhetstestningens kraft

I den här lektionen har du lärt dig hur viktigt det är att enhetstesta smarta kontrakt och hur du skriver effektiva tester med Hardhat, Mocha och Chai.

Smarta kontrakt kräver noggranna tester eftersom de är oföränderliga.
Hardhat tillhandahåller en kraftfull lokal miljö för snabb testning.
Du kan testa initiala tillstånd, tillståndsändringar, funktionslogik och förväntade återställningar.

Att behärska enhetstestning är en grundläggande färdighet för alla som utvecklar säkra och tillförlitliga DApp:ar.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 20
Lektioner: 76

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Enhetstestning av smarta kontrakt” gratis?

Ja – hela texten till ”Enhetstestning av smarta kontrakt” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i NestJS: backend-API:er för företag, kan Ni uppgradera till CoddyKit PRO. Kursen i NestJS: backend-API:er för företag innehåller totalt 6 lektioner.

Vad lär jag mig i ”Enhetstestning av smarta kontrakt”?

Lär dig att skriva omfattande enhetstester för era Solidity-kontrakt för att säkerställa deras korrekthet, säkerhet och förväntade beteende. Ni övar på NestJS: backend-API:er för företag med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig NestJS: backend-API:er för företag?

Du behöver inga förkunskaper. Utbildningen i NestJS: backend-API:er för företag på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 6.

Hur lång tid tar lektionen ”Enhetstestning av smarta kontrakt”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här NestJS: backend-API:er för företag-lektionen?

Ja. Varje NestJS: backend-API:er för företag-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till NestJS: backend-API:er för företag