Unit Testing in Truffle

Hey @gabba, thanks for your reply. Good point, didn’t pay attention to that detail and now changing “=” to “==” it’s a failing festival lol:

3 passing (3s)
 2 failing

Contract: People
      should increase the balance:
    AssertionError: balance should increase to 1
     at Context.<anonymous> (test\peopletest.js:91:5)
     at runMicrotasks (<anonymous>)
     at processTicksAndRejections (internal/process/task_queues.js:97:5)

 2) Contract: People
      should be increased:
    AssertionError: owners balance should be 1
     at Context.<anonymous> (test\peopletest.js:111:5)
     at runMicrotasks (<anonymous>)
     at processTicksAndRejections (internal/process/task_queues.js:97:5)

My second and fifth test are claming some error on the assert function line, any thoughts?
Thanks once again!

Hi @pedromndias
Hum try to do your async call outside of your assert and store it into a variable.
Don’t hesitate to console.log the result before testing it if you need to debug it

1 Like

Owner Test assignment :

const People=artifacts.require(“People”);
const truffleAssert=require(“truffle-assertions”);
contract(“People”,async function(accounts){
it("delete people function is availible for owner only! ", async function(){
let instance = await People.deployed();
await instance.createPerson(“Bob”, 40, 90, {from: accounts[2], value: web3.utils.toWei(“1”, “ether”)});
await truffleAssert.fails(instance.deletePerson(accounts[2], {from: accounts[2]}), truffleAssert.ErrorType.REVERT);
});
it(“Only owner can delete person”, async function(){
let instance = await People.new();
await instance.createPerson(“Bob”, 40, 90, {from: accounts[2], value: web3.utils.toWei(“1”, “ether”)});
await truffleAssert.passes(instance.deletePerson(accounts[1], {from: accounts[0]}));
});
});

1 Like

Value asignment
it(“Balance is increase after adding new Person”, async function(){
let instance = await People.deployed();
let Balance = await web3.eth.getBalance(People.address);
await instance.createPerson(“Lisa”, 28, 166, {value: web3.utils.toWei(“1”,“ether”), from: accounts[1]});
let newBalance = await web3.eth.getBalance(People.address);
assert(newBalance == parseInt(Balance) + parseInt(web3.utils.toWei(“1”,“ether”)));

});
it(“It is imposible widrow founds from contract if you are not owner”, async function(){
let instance = await People.deployed();
await truffleAssert.fails(instance.withdrawAll({from: accounts[1]}));
});
it("Conract owner is able widrow founds ", async function(){
let instance = await People.deployed();
await truffleAssert.passes(instance.withdrawAll({from: accounts[0]}));
});

1 Like

8 posts were merged into an existing topic: Introduction to Unit Testing

it("contract address balance", async function(){
    let instance = await People.deployed();
    let address = instance.address;
    let currentBalance = await web3.eth.getBalance(address);
   let currentbalanceInNumber = parseInt(currentBalance);
    await instance.createPerson("Lisa", 35, 160, {from: accounts[3], value: web3.utils.toWei("1", "ether")});
     currentbalanceInNumber += 1000000000000000000;
     let finalBalance = await web3.eth.getBalance(address);
     let finalBalanceInNumber = parseInt(finalBalance);
     
     assert(currentbalanceInNumber === finalBalanceInNumber, "cost not transfer correctly");
    });
   
    it("should withdraw all", async function(){
        let instance = await People.deployed();
        let ownerBalance = await web3.eth.getBalance(accounts[0]);
        let contractBalance = await web3.eth.getBalance(instance.address);
        ownerBalance = parseInt(ownerBalance) + parseInt(contractBalance);
        let txnReceipt = await instance.withdrawAll();
        let gasUsed = txnReceipt.receipt.gasUsed;
        gasUsed = parseInt(gasUsed)*20000000000;
        ownerBalance -= gasUsed;
        let address = instance.address;
        let currentBalance = await web3.eth.getBalance(address);
        let currentbalanceInNumber = parseInt(currentBalance);
        let finalOwnerBalance = await web3.eth.getBalance(accounts[0]);
        let finalBalanceInNumber = parseInt(finalOwnerBalance);

        assert((currentbalanceInNumber === 0) && (ownerBalance === finalBalanceInNumber),"transfer not set correctly");
      });type or paste code here
1 Like

Very nice! You even combined them all… I like it. :+1:
Ivo

1 Like

Owner test assignment ::

const People = artifacts.require(‘People’);
const truffleAssert = require(‘truffle-assertions’);

contract(‘People’, async function(accounts) {
it(“shouldn’t create a person with age over 150 years”, async function() {
let instance = await People.deployed();
await truffleAssert.fails(instance.createPerson(‘Bob’,200,190, {value: web3.utils.toWei(‘1’, ‘ether’)}),truffleAssert.ErrorType.REVERT);
});

it(‘should not create a person without payment’, async function() {
let instance = await People.deployed();
await truffleAssert.fails(instance.createPerson(‘Bob’,50,190, {value: 1000}),truffleAssert.ErrorType.REVERT);
});

it(‘should set senior status correctly’, async function() {
let instance = await People.deployed();
await instance.createPerson(‘Bob’,70,190, {value: web3.utils.toWei(‘1’, ‘ether’)});
let result = await instance.getPerson();
assert(result.senior === true, ‘Senior level not set’);
});

it(‘should set age correctly’, async function() {
let instance = await People.deployed();
let result = await instance.getPerson();
assert(result.age.toNumber() === 70, ‘Age not set correctly’);
});

it(‘should not allow deletion of person if not owner’, async function() {
let instance = await People.deployed();
let result = await instance.getCreator(0);
await instance.deletePerson(result);
assert.equal(result, accounts[0], ‘Incorrect person deleted’);
})

});

1 Like

my solution is

... some other testcases ....

    it("should only be possible for the owner to delete a person",
        async function(){
          let i = await People.deployed();
          await i.createPerson("CBob", 65, 190,
            {value:web3.utils.toWei("1","ether"), from: account[1]});
          await truffleAssert.fails(
                i.deletePerson(account[1], {from:account[2]})
                , truffleAssert.ErrorType.REVERT);
        });

    it("should be possible to delete person by owner",
        async function(){
          let i = await People.deployed();
          await i.deletePerson(account[0], {from:account[0]});
          let person = await i.getPerson();
          assert(person.name ==="" && person.age == 0 && person.height == 0 && person.senior == false);
        });
....
1 Like
const  People = artifacts.require("People");
const truffleAssert = require("truffle-assertions");

contract("People", async function(accounts){
  it("should allow the owner to delete the contract", async function(){
    let instance = await People.deployed();
    await instance.createPerson("Bob", 65, 190, {value: web3.utils.toWei("1", "ether"), from: accounts[0]});
    await truffleAssert.passes(instance.deletePerson(accounts[0], {from: accounts[0]}), truffleAssert.ErrorType.REVERT);
  });
  it("should forbid a non-owner to delete the contract", async function(){
    let instance = await People.deployed();
    await instance.createPerson("Bob", 65, 190, {value: web3.utils.toWei("1", "ether"), from: accounts[0]});
    await truffleAssert.fails(instance.deletePerson(accounts[0], {from: accounts[1]}), truffleAssert.ErrorType.REVERT);
  });
});
1 Like

Value assignment:

  it("should increase balance variable when a person is added", async function(){
    let instance = await People.new();
    await instance.createPerson("Bob", 65, 190, {value: web3.utils.toWei("1", "ether")});
    let balance = await instance.balance();
    assert(balance == web3.utils.toWei("1", "ether"), "balance not set correctly");
    await instance.createPerson("Alice", 45, 170, {value: web3.utils.toWei("4", "ether")});
    balance = await instance.balance();
    assert(balance == web3.utils.toWei("5", "ether"), "balance not set correctly");
  });
  it("should increase balance on the blockchain when a person is added", async function(){
    let instance = await People.new();
    await instance.createPerson("Bob", 65, 190, {value: web3.utils.toWei("1", "ether")});
    let balance = await web3.eth.getBalance(instance.address);
    assert(balance == web3.utils.toWei("1", "ether"), "balance not set correctly");
    await instance.createPerson("Alice", 45, 170, {value: web3.utils.toWei("4", "ether")});
    balance =  await web3.eth.getBalance(instance.address);
    assert(balance == web3.utils.toWei("5", "ether"), "balance not set correctly");
  });
  it("balance on the blockchain and balance variable should be the same", async function(){
    let instance = await People.new();
    await instance.createPerson("Bob", 65, 190, {value: web3.utils.toWei("1", "ether")});
    let balance1 = await instance.balance();
    let balance2 = await web3.eth.getBalance(instance.address);
    assert(balance1 == balance2, "balance not set correctly");
    await instance.createPerson("Alice", 45, 170, {value: web3.utils.toWei("4", "ether")});
    balance1 =  await instance.balance();
    balance2 =  await web3.eth.getBalance(instance.address);
    assert(balance1 == balance2, "balance not set correctly");
  });
1 Like

Hi.

You can use the Preformatted text to show the code in the post. :wink:

Ivo

1 Like

following my solution. I’m not sure if it is common to use two assert() functions in one it() function

  it("should increase balance when add a person and "+
    "have the same balance in both smart contract and blockchain", async function(){
      // get balance: web3.eth.getBalance(address);

      let i = await People.deployed();

      //get actual balance
      let oldBalanceSC =  parseFloat( await i.balance());
      let balanceBC =  parseFloat(await web3.eth.getBalance(i.address));
      //compare balances in sc and bc
      assert(oldBalanceSC == balanceBC, "first check Balances must be equal")
      //add Person
      await i.createPerson("DBob", 65, 190,
        {value:web3.utils.toWei("1","ether")});
      // compare with new balance
      let newBalanceSC =  parseFloat(await i.balance());
      balanceBC =  parseFloat(await web3.eth.getBalance(i.address));
      let balanceSum = oldBalanceSC + parseFloat(await web3.utils.toWei("1","ether"));
      //compare balances in sc and bc
      assert(newBalanceSC == balanceBC && balanceSum == newBalanceSC
            , "second check Balances must be equal")

    });

    it("should reduce balance to 0 when withdraw all funds and "+
    "have the same balance in both smart contract and blockchain", async function(){
      let i = await People.deployed();
      //get actual balance
      let balanceSC =  parseFloat( await i.balance());
      let balanceBC =  parseFloat(await web3.eth.getBalance(i.address));
      //compare balances in sc and bc
      assert(balanceSC == balanceBC, "first check Balances must be equal")
      //withdrawAll
      await i.withdrawAll();
      // compare with new balance
      balanceSC =  parseFloat(await i.balance());
      balanceBC =  parseFloat(await web3.eth.getBalance(i.address));
      //compare balances in sc and bc
      assert( web3.utils.toWei("0", "ether") == balanceSC && balanceBC == balanceSC
           , "second check:  Balances must be zero and equal ")

    });
1 Like

guys i need some help…tryed to reinstall the packages but nothing really change…
do u have any idea witf is going on??

thanks in advance…

sorry guys i need to upp this cause im still stuck…

Value Assignment ::

it(‘Contract balance should be incremented by 1 (one) after person is created’, async function() {
let instance = await People.deployed();
let before_balance = await instance.getBalance();
await instance.createPerson(‘Elijah’,50,150, {value: web3.utils.toWei(‘1’, ‘ether’)});
let current_balance = await instance.getBalance()
let _difference = current_balance -= before_balance;
assert.equal(_difference, 1000000000000000000, ‘Incorrect contract balance’);
});

it(‘Owner balance should equal Account balance on the blockchain’, async function() {
let instance = await People.deployed();
let owner = await instance.getOwner();
let owner_balance = await web3.eth.getBalance(owner);
let blockchain_balance = await web3.eth.getBalance(accounts[0]);
assert.equal(owner_balance, blockchain_balance, ‘Incorrect blockchain contraxct balance’);
});

it(‘Contract balance should be 0 (zero) after withdrawal’, async function () {
let instance = await People.deployed();
await instance.withdrawAll();
let contract_balance = await instance.getBalance();
assert.equal(contract_balance,0,‘Contract Is Not 0 (ZERO) after withdrawal’);
});

1 Like

my solution to the onlyower modifier test.

	it("should be deletable just from owner", async function(){
		let instance = await People.deployed();
		await instance.createPerson("Noob",33,180, {from: accounts[1], value: web3.utils.toWei("1", "ether")});
		await truffleAssert.fails(instance.deletePerson(accounts[1], {from: accounts[1]}) ,truffleAssert.ErrorType.REVERT);
	})

	it("should allow owner to delete People", async function(){
		let instance = await People.deployed();
		await instance.createPerson("Goob",35,181, {from: accounts[2],value: web3.utils.toWei("1", "ether")});
		await truffleAssert.passes(instance.deletePerson(accounts[2], {from: accounts[0]}) ,truffleAssert.ErrorType.REVERT);

	})
1 Like

something is not right in the last test but i cant figure out what it is really

Owner Test

    it("should only contract owner (accounts[0]) delete", async function(){
        let instance = await People.deployed();
        await instance.createPerson("Bob", 65, 190, {from: accounts[1], value: web3.utils.toWei("1", "ether")});
        await TruffleAssert.passes(instance.deletePerson(accounts[1], {from: accounts[0]}));
    });
    it("shouldn't other user (accounts[1]) delete", async function(){
        let instance = await People.deployed();
        await instance.createPerson("Bob", 65, 190, {from: accounts[1], value: web3.utils.toWei("1", "ether")});
        await TruffleAssert.passes(instance.deletePerson(accounts[1], {from: accounts[1]}));
    });
1 Like

Hi @Daniel_Fuchs

You can use two assert if it make sense in your test, you just have to describe exactly what you are testing in the title of your test.
When you are testing two values use the === instead of == because the double equal is performing a type conversion and it can leads to error later in your code:
ex:

"42" == 42
true
"42" === 42
false
2 Likes