Natuurlijk! Hier is een uitgebreide gids voor het opzetten van een robuust testframework voor jouw slimme contract met behulp van Truffle, inclusief methodologieën, voorbeelden en best practices. --- **1. Overzicht van het testproces** - **Eenheidstests:** Test individuele functies in isolatie, zoals transfer, mint, burn. - **Integratietests:** Test de interactie tussen meerdere functies en contracten. - **Scenario-gebaseerde tests:** Simuleer volledige workflows en gebruiksscenario's, inclusief randgevallen en foutmodi. --- **2. Tools en technologieën** - **Truffle:** Framework om smart contracts te ontwikkelen, testen en implementeren. - **Ganache:** Lokale blockchain voor snelle testen. - **Chai:** Assertion library voor tests in JavaScript. - **Mocha:** Test runner geïntegreerd in Truffle. - **OpenZeppelin Test Helpers:** Voor het testen van foutmodi (bijv. reverts). --- **3. Opzetten van de testsuite** - Installeer benodigde dependencies: ```bash npm init -y npm install --save-dev chai @openzeppelin/test-helpers ``` - Maak een testbestand, bijvoorbeeld `test/Token.test.js`. --- **4. Structuur van tests** - **Initialisatie:** Maak accounts en installeer het contract. - **Eenheidstests:** Test functies zoals `transfer`, `approve`, `transferFrom` in isolatie. - **Randgevallen:** Transfer van 0 tokens, overdragen meer dan saldo, transfer naar niet-bestaande adressen. - **Foutmodi:** Test transactie die moet revert, bijvoorbeeld niet-gemachtigde overdracht. --- **5. Voorbeeld: Testgevallen voor `transfer` functie** ```js const { expectRevert, expectEvent } = require('@openzeppelin/test-helpers'); const Token = artifacts.require("YourToken"); contract("YourToken", (accounts) => { const [owner, receiver, thirdParty] = accounts; let token; beforeEach(async () => { token = await Token.new({ from: owner }); // Stel initiale balans in indien nodig await token.mint(owner, web3.utils.toWei('1000'), { from: owner }); }); describe("Transfer functie", () => { it("moet succesvol tokens overdragen", async () => { const amount = web3.utils.toWei('100'); const receipt = await token.transfer(receiver, amount, { from: owner }); expectEvent(receipt, 'Transfer', { from: owner, to: receiver, value: amount, }); const ownerBalance = await token.balanceOf(owner); const receiverBalance = await token.balanceOf(receiver); assert.equal(ownerBalance.toString(), web3.utils.toWei('900')); assert.equal(receiverBalance.toString(), amount); }); it("moet transfer falen bij onvoldoende saldo", async () => { const amount = web3.utils.toWei('2000'); await expectRevert( token.transfer(receiver, amount, { from: owner }), "revert" // of specifieke revert bericht ); }); it("moet transfer falen bij nulbedrag", async () => { await expectRevert( token.transfer(receiver, 0, { from: owner }), "revert" // afhankelijk van implementatie ); }); it("moet transfer falen naar niet-bestaand adres (bijv. 0x0)", async () => { await expectRevert( token.transfer('0x0000000000000000000000000000000000000000', web3.utils.toWei('10'), { from: owner }), "revert" ); }); }); }); ``` --- **6. Best practices voor onderhoud** - **Modulariseer tests:** Verdeel tests per functionaliteit en gebruik `describe`. - **Gebruik fixtures:** Hergebruik setup-code met `beforeEach` of `before`. - **Update testdata:** Pas tests aan bij contractwijzigingen. - **Gebruik mocks/stubs:** Voor externe contractinteracties. - **Automatiseer testen:** Integreer met CI/CD pipelines. - **Test randgevallen en foutmodi grondig:** Voorkom regressies. - **Documenteer testcases:** Voor duidelijkheid en onderhoudbaarheid. --- **7. Extra tips** - **Gebruik OpenZeppelin Test Helpers** voor het controleren van revert-berichten en events. - **Gebruik coverage tools** zoals solidity-coverage om te controleren of alle functies en paden getest worden. - **Voer regelmatig regressietests uit** na elke wijziging. --- **Samenvatting** Door deze aanpak te volgen met Truffle en bijbehorende tools, creëer je een uitgebreide, onderhoudsvriendelijke testsuite die alle functies en randgevallen van je slimme contract dekt. Zo garandeer je de betrouwbaarheid en veiligheid van je smart contract tijdens de evolutie ervan. --- Heeft u nog specifieke vragen of wilt u hulp bij een bepaald onderdeel?

Zeker, ik begeleid je stap voor stap door het opzetten van een uitgebreid testframework voor je slimme contract met Truffle. Hier is een complete handleiding: ## 1. Projectstructuur en Tools ### Benodigde tools: - **Truffle Suite** (Truffle, Ganache) - **Mocha** (test runner) - **Chai** (assertie library) - **OpenZeppelin Test Helpers** (voor veilige testing) ### Projectstructuur: ``` contracts/ ├── MyToken.sol test/ ├── unit/ │ ├── MyToken.unit.js ├── integration/ │ ├── MyToken.integration.js ├── scenarios/ │ ├── transfer.scenarios.js truffle-config.js ``` ## 2. Testopzet met Truffle ### Basis testconfiguratie: ```javascript const { expect } = require('chai'); const { BN, expectEvent, expectRevert } = require('@openzeppelin/test-helpers'); const MyToken = artifacts.require('MyToken'); contract('MyToken', function (accounts) { const [owner, user1, user2, user3] = accounts; const initialSupply = new BN('1000000'); const transferAmount = new BN('100'); beforeEach(async function () { this.token = await MyToken.new(initialSupply, { from: owner }); }); }); ``` ## 3. Unittest Voorbeelden voor Transfer ### Normale transfer testen: ```javascript describe('Transfer functies - Unit Tests', function () { it('moet tokens succesvol transfereren tussen accounts', async function () { // Arrange const initialBalance = await this.token.balanceOf(user1); // Act const receipt = await this.token.transfer(user2, transferAmount, { from: user1 }); // Assert const finalBalanceUser1 = await this.token.balanceOf(user1); const finalBalanceUser2 = await this.token.balanceOf(user2); expect(finalBalanceUser1).to.be.bignumber.equal(initialBalance.sub(transferAmount)); expect(finalBalanceUser2).to.be.bignumber.equal(transferAmount); expectEvent(receipt, 'Transfer', { from: user1, to: user2, value: transferAmount }); }); it('moet transfer naar adres 0 voorkomen', async function () { await expectRevert( this.token.transfer('0x0000000000000000000000000000000000000000', transferAmount, { from: user1 }), 'Transfer naar adres 0' ); }); it('moet onvoldoende saldo detecteren', async function () { const largeAmount = initialSupply.add(new BN('1')); await expectRevert( this.token.transfer(user2, largeAmount, { from: user1 }), 'Onvoldoende saldo' ); }); }); ``` ## 4. Integratietest Voorbeelden ```javascript describe('Transfer functies - Integratie Tests', function () { it('moet meerdere transfers correct verwerken', async function () { // Meerdere opeenvolgende transfers await this.token.transfer(user2, transferAmount, { from: user1 }); await this.token.transfer(user3, transferAmount, { from: user2 }); const balanceUser3 = await this.token.balanceOf(user3); expect(balanceUser3).to.be.bignumber.equal(transferAmount); }); it('moet batch transfers correct afhandelen', async function () { const transfers = [ { from: user1, to: user2, amount: new BN('50') }, { from: user1, to: user3, amount: new BN('75') } ]; for (const transfer of transfers) { await this.token.transfer(transfer.to, transfer.amount, { from: transfer.from }); } const totalTransferred = transfers.reduce((acc, curr) => acc.add(curr.amount), new BN('0')); const finalBalance = await this.token.balanceOf(user1); const expectedBalance = initialSupply.sub(totalTransferred); expect(finalBalance).to.be.bignumber.equal(expectedBalance); }); }); ``` ## 5. Scenario-gebaseerde Tests ```javascript describe('Transfer Scenario Tests', function () { it('moet front-running scenario simuleren', async function () { // Simuleer race condition scenario const promises = [ this.token.transfer(user2, transferAmount, { from: user1 }), this.token.transfer(user3, transferAmount, { from: user1 }) ]; const results = await Promise.allSettled(promises); const successfulTransfers = results.filter(result => result.status === 'fulfilled'); // Alleen één transfer zou moeten slagen als er onvoldoende saldo is expect(successfulTransfers.length).to.be.at.most(1); }); it('moet re-entrancy scenario testen', async function () { // Test voor re-entrancy aanvallen const maliciousContract = await MaliciousContract.new(this.token.address); await expectRevert( maliciousContract.attack(transferAmount), 'Re-entrancy guard' ); }); it('moet maximum transfer limieten handhaven', async function () { const maxTransfer = new BN('10000'); // Test overschrijding maximum transfer await expectRevert( this.token.transfer(user2, maxTransfer.add(new BN('1')), { from: user1 }), 'Transfer limiet overschreden' ); }); }); ``` ## 6. Randgevallen en Foutmodi ```javascript describe('Randgevallen en Foutmodi', function () { it('moet transfer van 0 tokens toestaan', async function () { const receipt = await this.token.transfer(user2, new BN('0'), { from: user1 }); expectEvent(receipt, 'Transfer', { from: user1, to: user2, value: new BN('0') }); }); it('moet overflow voorkomen bij grote bedragen', async function () { const hugeAmount = new BN('2').pow(new BN('256')).sub(new BN('1')); await expectRevert( this.token.transfer(user2, hugeAmount, { from: user1 }), 'Overflow gedetecteerd' ); }); it('moet gas limieten respecteren', async function () { const gasLimit = 100000; try { await this.token.transfer(user2, transferAmount, { from: user1, gas: gasLimit }); } catch (error) { expect(error.message).to.include('out of gas'); } }); }); ``` ## 7. Best Practices voor Testonderhoud ### 1. Test Organisatie ```javascript // Gebouw descriptieve testnamen describe('ERC20 Token Contract', function () { describe('Wanneer gebruiker tokens heeft', function () { describe('En een geldig transfer uitvoert', function () { it('Dan moet het saldo correct worden bijgewerkt', function () { // Test implementatie }); }); }); }); ``` ### 2. Herbruikbare Test Helpers ```javascript // test/helpers.js const transferAndVerify = async (token, from, to, amount) => { const initialFromBalance = await token.balanceOf(from); const initialToBalance = await token.balanceOf(to); const receipt = await token.transfer(to, amount, { from }); expect(await token.balanceOf(from)).to.be.bignumber.equal( initialFromBalance.sub(amount) ); expect(await token.balanceOf(to)).to.be.bignumber.equal( initialToBalance.add(amount) ); return receipt; }; ``` ### 3. Test Data Management ```javascript // Gebouw fixtures voor consistente testdata const testScenarios = { validTransfers: [ { amount: new BN('100'), description: 'Normale transfer' }, { amount: new BN('1'), description: 'Kleine transfer' }, { amount: new BN('999999'), description: 'Grote transfer' } ], invalidTransfers: [ { amount: new BN('0'), description: 'Nul transfer' }, { amount: new BN('1000001'), description: 'Te grote transfer' } ] }; ``` ### 4. Upgrade-bestendige Tests ```javascript // Abstracte testklasse voor contract upgrades describe('Upgrade Compatibility', function () { it('moet backward compatibility behouden', async function () { const upgradedToken = await UpgradedToken.new(); await this.token.upgradeTo(upgradedToken.address); // Test dat bestaande functionaliteit blijft werken await transferAndVerify(upgradedToken, user1, user2, transferAmount); }); }); ``` ## 8. Test Uitvoering en Rapportage ### Package.json scripts: ```json { "scripts": { "test:unit": "truffle test ./test/unit/", "test:integration": "truffle test ./test/integration/", "test:scenarios": "truffle test ./test/scenarios/", "test:all": "truffle test", "test:coverage": "truffle run coverage" } } ``` ### Coverage rapportage: ```bash # Installeer coverage tool npm install --save-dev solidity-coverage # Voer tests uit met coverage truffle run coverage ``` ## 9. Continue Integratie ### .github/workflows/test.yml: ```yaml name: Smart Contract Tests on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Run tests run: | npm install npx truffle test - name: Generate coverage run: npx truffle run coverage ``` Deze aanpak zorgt voor een robuust testframework dat meeschaalt met je contractontwikkeling en consistentie biedt tijdens upgrades en wijzigingen.