Truffle and Ganache-cli test case fails

Question

So I have this setup : truffle and ganache-cli

I'm sending some ether to my contract, here is the related part of my contract:

    mapping(address => uint256) public balanceOf;

    function () payable public {
              uint amount = msg.value;
              balanceOf[msg.sender] += amount;
        }

In truffle this is how I send the ether.

it("Test if can be payed", function(){
    return web3.eth.sendTransaction({
           from:fromAddr, 
           to:MyContract.address,  
           value:amountToSend
    }).then(function(res){  
           expect(res).to.not.be.an("error"); // test passed
    });
 });

it("Test if contract received ether", function(){
        return web3.eth.getBalance(MyContract.address, 
               function(err, res){
                        expect(parseInt(res)).to.be.at.least(1000000000000000000); // test passed
                });
});

it("Catch if balanceOf "+fromAddr, function(){
        return sale.balanceOf.call(fromAddr).then(function(res){
                        expect(parseInt(res)).to.be.at.least(1); // fails the test
               });
});

Am I doing it right? What could be the reason for failed test? truffle test output :

AssertionError: expected 0 to be at least 1
      + expected - actual

      -0
      +1

I can provide more info if needed.

Answer 1

As I've mentioned in the comments, there are a number of problems in your code:

• Calling parseInt(res) may lead to an incorrect result, since res is a BigNumber possibly larger than Number.MAX_SAFE_INTEGER
• Using 1000000000000000000 may lead to an incorrect result, since it is larger than Number.MAX_SAFE_INTEGER

I'm not sure what exactly the cause of your failure, since I always use async/await instead of then where possible.

But in any case, this seems to be working fine:

contract("Sale", function(accounts) {
    let sale;
    let fromAddr = accounts[0];
    let amountToSend = "1000000000000000000";

    before(async function() {
        sale = await artifacts.require("Sale").new();
    });

    it("Test if can be payed", async function() {
        let res = await web3.eth.sendTransaction({
            from: fromAddr, 
            to: sale.address,  
            value: amountToSend
        });
        // if we reach here then the transaction has completed successfully
    });

    it("Test if contract received ether", async function() {
        let res = await web3.eth.getBalance(sale.address);
        assert(res.greaterThanOrEqualTo(amountToSend));
    });

    it("Catch if balanceOf "+fromAddr, async function() {
        let res = await sale.balanceOf.call(fromAddr);
        assert(res.greaterThanOrEqualTo(1));
    });
});