Unit Testing in Truffle

newavel · September 28, 2020, 12:29pm

Hi guys. I’m having a problem regarding truffle test. I’m getting the error below whenever I’m trying to test the contract.

According to Google, the problem is with the truffle-config.js file. I tried uncommenting the networks portion as suggested by Google (as well as changing the development to ganache) but it doesn’t solve the problem. My config file is as follows:

module.exports = {

  networks: {
    ganache : {
      host: "127.0.0.1",     // Localhost (default: none)
      port: 8545,            // Standard Ethereum port (default: none)
      network_id: "*",       // Any network (default: none)
     },
  },

  // Set default mocha options here, use special reporters etc.
  mocha: {
  },

  // Configure your compilers
  compilers: {
    solc: {
      version: "0.5.12",    // Fetch exact version from solc-bin (default: truffle's version)
    }
  }
}

I’m having this problem on and off lately. What could be the problem? Thank you.

alegarap · October 1, 2020, 6:39pm

It wasn’t very clear to me the difference between before, beforeEach, after and afterEach functions.

What I understood is before() runs just once before the following test is executed; after() runs once after the following test. The other two run before/after each existing test in the file.

Is that correct?

dan-i · October 2, 2020, 8:36am

Hey @alegarap

What I understood is before() runs just once before the following test is executed; after() runs once after the following test. The other two run before/after each existing test in the file.

That is correct

Cheers,
Dani

NLUGNER · October 5, 2020, 10:54am

//This took a while. I had to reinstall Truffle and Ganache to get it working.

it(“should not allow non-owner to delete Punters”, async function(){
let instance = await Punters.deployed();
await instance.createPerson(“Liz”, 35, 160, {from: accounts[2], value: web3.utils.toWei(“1”, “ether”)});
await truffleAssert.fails(instance.deletePerson(accounts[2], {from: accounts[2]}), truffleAssert.ErrorType.REVERT);
});
it(“should allow the owner to delete Punters”, async function(){
let instance = await Punters.new();
await instance.createPerson(“Liz”, 35, 160, {from: accounts[2], value: web3.utils.toWei(“1”, “ether”)});
await truffleAssert.passes(instance.deletePerson(accounts[1], {from: accounts[0]}));
});

KingArt · October 7, 2020, 3:04am

@filip

when I run a test in the console I get the following error

TypeError [ERR_INVALID_REPL_INPUT]: Listeners for uncaughtException cannot be used in the REPL

Any thoughts?

nicolasgarcia214 · October 7, 2020, 5:15am

const People = artifacts.require("People");

const AssertionError = require("assertion-error");

const truffleAssert = require("truffle-assertions");

contract("People", async (accounts) => {

  it("Should not create a person older than 150 years", async function () {

    let instance = await People.deployed();

    await truffleAssert.fails(

      instance.createPerson("Nico", 1000, 180, {

        value: web3.utils.toWei("1", "ether"),

      }),

      truffleAssert.ErrorType.REVERT

    );

  });

  it("Should not create a without payment", async function () {

    let instance = await People.deployed();

    await truffleAssert.fails(

      instance.createPerson("Nico", 50, 180, {

        value: 1000,

      }),

      truffleAssert.ErrorType.REVERT

    );

  });

  it("Should set senior status correctly", async function () {

    let instance = await People.deployed();

    await instance.createPerson("Nico", 90, 180, {

      value: web3.utils.toWei("1", "ether"),

    });

    let result = await instance.getPerson();

    assert(result.senior === true, "Senior level not set");

  });

  it("Should not be execute by anyone but the owner", async function () {

    let instance = await People.deployed();

    await truffleAssert.fails(

      instance.deletePerson(accounts[0], { from: accounts[3] }),

      truffleAssert.ErrorType.REVERT

    );

  });

  it("Should allow the owner to delete people", async function () {

    let instance = await People.deployed();

    let resultBeforeDelete = await instance.getPerson();

    await instance.deletePerson(accounts[0]);

    let resultAfterDelete = await instance.getPerson();

    assert(

      resultBeforeDelete !== resultAfterDelete,

      "The person was not deleted"

    );

  });

});

dan-i · October 7, 2020, 8:54am

Hey @KingArt,

That looks like an issue with node, check this faq: FAQ - How to downgrade Node.Js

Cheers,
Dani

KingArt · October 7, 2020, 11:46pm

Thanks Dani that worked!

Mislav_Bajan · October 8, 2020, 2:44pm

Owner test:

it(“shouldn’t be possable for nonowner to delete person”, async function(){
let instance = await People.deployed();
await instance.createPerson(“Mislav4”, 100, 196, {value : web3.utils.toWei(“1”, “ether”), from:accounts[1]});
await truffleAssert.fails(instance.deletePerson(accounts[1],{from:accounts[1]}))

});
it(“should be possible for owner to delete”, async function(){
let instance = await People.deployed();
assert(instance.deletePerson(accounts[0]));
});

Mislav_Bajan · October 8, 2020, 5:23pm

Value Assignment

it(“balance should increase when adding a person”, async function(){
let instance = await People.deployed();
start = await web3.eth.getBalance(People.address);
await instance.createPerson(“Mislav5”, 100, 196, {value : web3.utils.toWei(“1”, “ether”), from:accounts[1]});
end = await web3.eth.getBalance(People.address);
assert(parseInt(end) === parseInt(start) + 1000000000000000000);
});
it(“owner should be able to withdraw and balance should be zero”, async function(){
let instance = await People.deployed();
assert(await instance.withdrawAll({from:accounts[0]}));
balance = await web3.eth.getBalance(People.address)
assert(parseInt(balance)===0, “Balance not zero :” + balance);
});

biokillos · October 8, 2020, 11:05pm

  it("should get creator if called by the owner", async () => {
    const instance = await People.deployed();
    await instance.createPerson('Bob', 70, 150, {value: web3.utils.toWei("1", "ether")});
    const creator = await instance.getCreator(0);
    assert(creator === accounts[0]);
  })

  it("should not delete person if called not by the owner", async () => {
    const instance = await People.deployed();
    await instance.createPerson('Bob', 70, 150, {value: web3.utils.toWei("1", "ether")});
    // Account 1 tries to delete the person created by the owner
    await truffleAssert.fails(instance.deletePerson(accounts[0], {from: accounts[1]}), truffleAssert.ErrorType.REVERT);
  })

biokillos · October 9, 2020, 7:04am

Value Assignment

const truffleAssert = require("truffle-assertions");

const People = artifacts.require("People");

const getContractBalance = async (address) => {
  const balanceWei = await web3.eth.getBalance(address);

  return web3.utils.fromWei(balanceWei, "ether");
};

contract("People", async (accounts) => {
  let instance;

  before(async () => {
    instance = await People.deployed();    
  });

  it("should reflect correct balance", async () => {
    const COSTS_ETHER = "15";

    await instance.createPerson('Bob', 70, 150, {value: web3.utils.toWei(COSTS_ETHER, "ether")});
    const contractBalance = await getContractBalance(instance.address);
  
    assert(contractBalance === COSTS_ETHER);
  });
  
  it("owner should withdraw all", async () => {
    await instance.withdrawAll();
    const contractBalanceWei = await web3.eth.getBalance(instance.address);
    assert(contractBalanceWei === "0");
  })
});

RLion · October 9, 2020, 2:17pm

It seems partial working but the following i do not understand.
when i use account[0] for creating and deleting it seems to work but changing all to account[1] which schould result in same result it fails ???
what am i missing ?

it(“Only owner can delete … test”, async function(){
let instance = await People.deployed();
await instance.createPerson(“Test person A”, 20, 190, {from: accounts[0], value: web3.utils.toWei(“1”, “ether”)});
//deletePerson(address creator) public onlyOwner
//Account[5] created the person, only account[5] can delete this person
await truffleAssert.fails(instance.deletePerson(accounts[0], {from: accounts[0]}), truffleAssert.ErrorType.REVERT);
});

result :

After changing account to [1] …

it(“Only owner can delete … test”, async function(){
let instance = await People.deployed();
await instance.createPerson(“Test person A”, 20, 190, {from: accounts[1], value: web3.utils.toWei(“1”, “ether”)});
//deletePerson(address creator) public onlyOwner
//Account[5] created the person, only account[5] can delete this person
await truffleAssert.fails(instance.deletePerson(accounts[1], {from: accounts[1]}), truffleAssert.ErrorType.REVERT);
});

FOUND THE REASON … account[0] is the OWNER …

Here my result :

enrico · October 10, 2020, 5:13pm

Hello @filip,

I’m having some confusion about addresses.

If I understand correctly the contract People has its own address (eg. 0000).

Then there is the owner which has another address (eg. 1111) and the owner address (owner msg.sender) is saved in the Ownable contract to restrict some function only to Owner.

When a new user create it’s own account (newPerson) his address is different from all the previous ones (eg. 3333) and is saved both in the array creatorsand associated to his newPerson with the mapping people.

Now in the unitesting we get the contract owner with accounts[0].
How is possible if the owner address is not passed into the array creators in the contract people?
when creating a person await instance.createPerson("Lisa", 35, 160, {from: accounts[2], value: web3.utils.toWei("1", "ether")}); if we don’t specify from: accounts[2] which address will be used? accounts[1] and each time will follow wiht next array index?
why if I specify the account in the test “should set senior status correctly” it give me error? await instance.createPerson("Bob", 65, 190, {from: accounts[1], value: web3.utils.toWei("1", "ether")});

error ` 1) should set senior status correctly

Events emitted during test:
---------------------------

People.personCreated(
  name: 'Bob' (type: string),
  senior: true (type: bool)
)


---------------------------
2) should set age correctly
> No events were emitted`

Sorry for the long post but I’m quite confused

sajede.k · October 11, 2020, 9:26am

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(“shouldn’t create a person without enogh payment”,async function(){
let instance= await people.deployed();
await truffleAssert.fails(instance.createPerson(“bob”,50,190,{value:1000}), truffleAssert.ErrorType.REVERT);
})
it(“should set person property correctly”,async function(){
let instance= await people.deployed();
await instance.createPerson(“bob”,65,190,{value:web3.utils.toWei(“1”,“ether”)});
let result=await instance.getPerson();
assert(result.senior===true && result.age.toNumber()==65,“person not set correctly”);
})
it(“shouldn’t delete person if caller is not owner”,async function(){

  let instance= await people.deployed();
  await instance.createPerson("bob",65,190,{value:web3.utils.toWei("1","ether")});
  let result=await instance.getCreator(0);
  await truffleAssert.fails(instance.deletePerson(result,{from:accounts[2]}), truffleAssert.ErrorType.REVERT);

})
});

vnaysngh · October 11, 2020, 11:15am

lmao, I went on and did something different than the original solution

 it("checks the owner of the contract", async () => {
    let instance = await People.deployed();
    await instance.deletePerson(account[0]);
    let ownerAddress = await instance.owner();
    assert(ownerAddress === account[0], "user is not the owner");
  });

  it("only deletes when owner", async () => {
    let instance = await People.deployed();
    await truffleAssert.fails(
      instance.deletePerson(account[1]),
      truffleAssert.ErrorType.REVERT
    );
  });

vnaysngh · October 11, 2020, 11:18am

Also, I’d like to understand how the contract took accounts[0] as it’s owner because we nowhere defined it explicity?

dan-i · October 13, 2020, 1:53pm

Ciao @enrico

Now in the unitesting we get the contract owner with accounts[0].
How is possible if the owner address is not passed into the array creators in the contract people?

when creating a person await instance.createPerson("Lisa", 35, 160, {from: accounts[2], value: web3.utils.toWei("1", "ether")}); if we don’t specify from: accounts[2] which address will be used? accounts[1] and each time will follow wiht next array index?

why if I specify the account in the test “should set senior status correctly” it give me error? await instance.createPerson("Bob", 65, 190, {from: accounts[1], value: web3.utils.toWei("1", "ether")});

Although I have not seen your contract, I do think that you are setting the contract owner in your constructor, something like this:

address public owner;

constructor () public {
   owner = msg.sender;
}

By default, the deployer account is always accounts[0] so this is why your owner is set to accounts[0].

If you do not specify any accounts in your testing, then the default account will be used automatically (accounts[0]).
I should check your smart contract for that Can you please upload it to GitHub and send me the link to the repo?

Happy learning,
Dani

dan-i · October 13, 2020, 1:56pm

Hey @vnaysngh

I copy/paste part of my answer to Enrico,

Also, I’d like to understand how the contract took accounts[0] as it’s owner because we nowhere defined it explicity?

Although I have not seen your contract, I do think that you are setting the contract owner in your constructor, something like this:

address public owner;

constructor () public {
   owner = msg.sender;
}

By default, the deployer account is always accounts[0] so this is why your owner is set to accounts[0].

Regarding your tests, the only things that you should change are:

let instance = await People.deployed();
let instance = await People.deployed();

These should be declared in a before or beforeEach function.

Happy coding,
Dani

Nicksta · October 13, 2020, 6:45pm

contract (“People”, async function(accounts){
it(“should create a person”, async function(){
let instance = await People.deployed();
assert (instance.createPerson(“henni”, 61,190, {value: web3.utils.toWei(“1”, “ether”)}));
});

it (“should have the same creator address as the owner addres”, async function(){
let instance = await People.deployed();
let creator_address = msg.sender();
let owner_address = await instance.owner();
assert(creator_address === owner_address, “user is not the owner”);
assert.equal(creator_address, owner_address, “creator and owner should be the same”);
});
it (“shouldn’t be possible to delete a person if itsnt the owner”, async function(){
let instance = await People.deployed();
await truffleAssert.fails(instance.deletePerson(accounts[0]) ({from: accounts[3]}), truffleAssert.ErrorType.REVERT);
});

But something is wrong with my accounts(accounts not defined):

should have the same creator address as the owner addres:
ReferenceError: msg is not defined
at Context. (test/PeopleTest.js:34:27)
at process._tickCallback (internal/process/next_tick.js:68:7)
shouldn’t be possible to delete a person if itsnt the owner:
ReferenceError: accounts is not defined
at Context. (test/PeopleTest.js:41:53)
at process._tickCallback (internal/process/next_tick.js:68:7)