payroll_test.js

payroll_test.js

var Payroll = artifacts.require("./Payroll.sol");
var BigNumber = require('bignumber.js');
// Nodejs doesn't support import..from.. syntax now.
//import expectThrow from "zeppelin-solidity/test/helpers/expectThrow";;

var expectThrow = async function(promise) {
  try {
    await promise;
  } catch (err) {
    const revert_op = err.message.search('revert') >= 0;
    const invalidOpcode = err.message.search('invalid opcode') >= 0;
//    const outOfGas = err.message.search('out of gas') >= 0;
//    const invalidJump = err.message.search('invalid JUMP') >= 0;
//    assert(invalidOpcode || invalidJump || outOfGas, "Expected throw, got '" + err + "' instead");
    assert(revert_op || invalidOpcode, "Expect throw, got '" + err + "' instead.");
    return;
  }
  assert.fail('Expected throw not received');
}

contract("Payroll", async (accounts) => {
  let payroll;
  let payroll_contract;
  const owner = accounts[0];
  const employee = accounts[1];
  const base_salary = web3.toWei(2, "ether");

  before(async () => {
      // Note: payroll is a TruffleContract.
      payroll = await Payroll.new({from : owner});
      // Note: payroll_contract is not a TruffleContract and is different from payroll.
      payroll_contract = web3.eth.contract(payroll.abi).at(payroll.address);
      const wei_added = web3.toWei("20", "ether");
      await payroll.addFund({from : accounts[2], value : wei_added});
      assert.equal(wei_added, web3.eth.getBalance(payroll.address).toString());
  });

  it("addEmployee() should revert if not called from owner", async () => {
      await expectThrow(payroll.addEmployee(employee, base_salary, {from : accounts[9]}));
  });

  it("addEmployee() smoke test success", async () => {
      let result = await payroll.addEmployee(employee, base_salary);
      let added_employee = await payroll.employees.call(employee);
      console.log("added_employee = ", added_employee);
      assert.equal(added_employee[0], employee);  // address
      assert.equal(added_employee[1].toNumber(), base_salary);
      // Check Event.
      for (var i = 0; i < result.logs.length; i++) {
        var log = result.logs[i];
        if (log.event == 'AddedEmployee') {
          assert.equal(log.args.employee, employee);
          assert.equal(log.args.salary.toString(), base_salary);
          return;
        }
      }
      assert.fail("Expected addEmployee() to be success, but event wasn't triggered!");
  });

  it("addEmployee() would revert if adding an existing employee", async () => {
      await expectThrow(payroll.addEmployee(employee, base_salary));
  });


  it("removeEmployee() should revert if not called from owner", async () => {
      await expectThrow(payroll.removeEmployee(employee, {from : accounts[9]}));
  });

  it("removeEmployee() should revert the account to be removed wasn't added before",
      async() => {
        await expectThrow(payroll.removeEmployee(accounts[9]));
      });

  it("removeEmployee() smoke test success", async () => {
      // Note: There's a dependency - accounts[1] was added in abpve test.
      let result = await payroll.removeEmployee(employee);
      let get_employee = await payroll.employees.call(employee);
      assert.equal(parseInt(get_employee[0]), 0);  // address
      assert.equal(get_employee[1].toNumber(), 0);
      // Check Event.
      for (var i = 0; i < result.logs.length; i++) {
        var log = result.logs[i];
        if (log.event == 'RemovedEmployee') {
          assert.equal(log.args.employee, employee);
          return;
        }
      }
      assert.fail("Expected removeEmployee() to be success, but event wasn't triggered!");
  });


  it("getPaid() should revert if not called from added employee", async () => {
      let result = await payroll.addEmployee(employee, base_salary);
      for (var i = 0; i < result.logs.length; i++) {
        var log = result.logs[i];
        if (log.event == 'AddedEmployee') {
          assert.equal(log.args.employee, employee);
          assert.equal(log.args.salary.toString(), base_salary);
          break;
        }
      }
      await expectThrow(payroll.getPaid({from : accounts[9]}));
  });

  it("getPaid() should throw if called before payDuration", async () => {
      await expectThrow(payroll.getPaid({from : employee}));
  });

  it("getPaid() smoke test", async () => {
      // Get gasPrice.
      //const gasPrice = Payroll.class_defaults.gasPrice;
      const before_paid = new BigNumber(web3.eth.getBalance(employee));
      try {
        const pay_duration = await payroll.payDuration();
        // Increase next block's timestamp with 2 * payDuration.
        web3.currentProvider.send({jsonrpc: "2.0", method: "evm_increaseTime", params: [ 2 * pay_duration ], id: 1});
        web3.currentProvider.send({jsonrpc: "2.0", method: "evm_mine", params: [], id: 2});
        let result = await payroll.getPaid({from : employee});
        var gasPrice = web3.eth.getTransaction(result.tx).gasPrice.toNumber();
        // Get gas consumed by function getPaid().
        // See https://github.com/ethereum/wiki/wiki/JavaScript-API#web3ethestimategas:
        // Executes a message call or transaction, which is directly executed in
        // the VM of the node, but never mined into the blockchain.
        let gas = await payroll.getPaid.estimateGas({from : employee});
       
        const after_paid = new BigNumber(web3.eth.getBalance(employee));
        assert.equal(base_salary, after_paid.minus(before_paid).plus(gasPrice * gas).toString());
      } catch (err) {
        console.log("await promise error: ", err);
      }
  });
});