Merge pull request #97 from sogoiii/async_await_tests

issue #57: Async await tests

.babelrc

+{
+  "presets": ["es2015", "stage-2", "stage-3"]
+}

package.json

@@ -4,6 +4,9 @@
   "description": "Secure Smart Contract library for Solidity",
   "main": "truffle.js",
   "devDependencies": {
+    "babel-preset-es2015": "^6.18.0",
+    "babel-preset-stage-2": "^6.18.0",
+    "babel-preset-stage-3": "^6.17.0",
     "ethereumjs-testrpc": "^3.0.2",
     "truffle": "^2.1.1"
   },

test/BasicToken.js

+const assertJump = require('./helpers/assertJump');
+
 contract('BasicToken', function(accounts) {
 
-  it("should return the correct totalSupply after construction", function(done) {
-    return BasicTokenMock.new(accounts[0], 100)
-      .then(function(token) {
-        return token.totalSupply();
-      })
-      .then(function(totalSupply) {
-        assert.equal(totalSupply, 100);
-      })
-      .then(done);
+  it("should return the correct totalSupply after construction", async function() {
+    let token = await BasicTokenMock.new(accounts[0], 100);
+    let totalSupply = await token.totalSupply();
+
+    assert.equal(totalSupply, 100);
   })
 
-  it("should return correct balances after transfer", function(done) {
-    var token;
-    return BasicTokenMock.new(accounts[0], 100)
-      .then(function(_token) {
-        token = _token;
-        return token.transfer(accounts[1], 100);
-      })
-      .then(function() {
-        return token.balanceOf(accounts[0]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 0);
-      })
-      .then(function() {
-        return token.balanceOf(accounts[1]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 100);
-      })
-      .then(done);
+  it("should return correct balances after transfer", async function(){
+    let token = await BasicTokenMock.new(accounts[0], 100);
+    let transfer = await token.transfer(accounts[1], 100);
+
+    let firstAccountBalance = await token.balanceOf(accounts[0]);
+    assert.equal(firstAccountBalance, 0);
+
+    let secondAccountBalance = await token.balanceOf(accounts[1]);
+    assert.equal(secondAccountBalance, 100);
   });
 
-  it("should throw an error when trying to transfer more than balance", function(done) {
-    var token;
-    return BasicTokenMock.new(accounts[0], 100)
-      .then(function(_token) {
-        token = _token;
-        return token.transfer(accounts[1], 101);
-      })
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done);
+  it("should throw an error when trying to transfer more than balance", async function() {
+    let token = await BasicTokenMock.new(accounts[0], 100);
+    try {
+      let transfer = await token.transfer(accounts[1], 101);
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
 });

test/Bounty.js

-var sendReward = function(sender, receiver, value){
+let sendReward = function(sender, receiver, value){
   web3.eth.sendTransaction({
     from:sender,
     to:receiver,
@@ -8,134 +8,108 @@ var sendReward = function(sender, receiver, value){
 
 contract('Bounty', function(accounts) {
 
-  it("sets reward", function(done){
-    var owner = accounts[0];
-    var reward = web3.toWei(1, "ether");
+  it("sets reward", async function(){
+    let owner = accounts[0];
+    let reward = web3.toWei(1, "ether");
+    let bounty = await SecureTargetBounty.new();
+    sendReward(owner, bounty.address, reward);
 
-    SecureTargetBounty.new().
-      then(function(bounty){
-        sendReward(owner, bounty.address, reward);
-        assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
-      }).
-      then(done);
+    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
   })
 
-  it("empties itself when killed", function(done){
-    var owner = accounts[0];
-    var reward = web3.toWei(1, "ether");
-    var bounty;
+  it("empties itself when killed", async function(){
+    let owner = accounts[0];
+    let reward = web3.toWei(1, "ether");
+    let bounty = await SecureTargetBounty.new();
+    sendReward(owner, bounty.address, reward);
 
-    SecureTargetBounty.new().
-      then(function(_bounty){
-        bounty = _bounty;
-        sendReward(owner, bounty.address, reward);
-        assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
-        return bounty.kill()
-      }).
-      then(function(){
-        assert.equal(0, web3.eth.getBalance(bounty.address).toNumber())
-      }).
-      then(done);
+    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
+
+    await bounty.kill();
+    assert.equal(0, web3.eth.getBalance(bounty.address).toNumber());
   })
 
   describe("Against secure contract", function(){
-    it("checkInvariant returns true", function(done){
-      var bounty;
-
-      SecureTargetBounty.new().
-        then(function(_bounty) {
-          bounty = _bounty;
-          return bounty.createTarget();
-        }).
-        then(function() {
-          return bounty.checkInvariant.call()
-        }).
-        then(function(result) {
-          assert.isTrue(result);
-        }).
-        then(done);
+
+    it("checkInvariant returns true", async function(){
+      let bounty = await SecureTargetBounty.new();
+      let target = await bounty.createTarget();
+      let check = await bounty.checkInvariant.call();
+
+      assert.isTrue(check);
     })
 
-    it("cannot claim reward", function(done){
-      var owner = accounts[0];
-      var researcher = accounts[1];
-      var reward = web3.toWei(1, "ether");
-
-      SecureTargetBounty.new().
-        then(function(bounty) {
-          var event = bounty.TargetCreated({});
-          event.watch(function(err, result) {
-            event.stopWatching();
-            if (err) { throw err }
-            var targetAddress = result.args.createdAddress;
-            sendReward(owner, bounty.address, reward);
-            assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
-            bounty.claim(targetAddress, {from:researcher}).
-              then(function(){ throw("should not come here")}).
-              catch(function() {
-                return bounty.claimed.call();
-              }).
-              then(function(result) {
-                assert.isFalse(result);
-                bounty.withdrawPayments({from:researcher}).
-                  then(function(){ throw("should not come here")}).
-                  catch(function() {
-                    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
-                    done();
-                  })
-              })
-          })
-          bounty.createTarget({from:researcher});
-        })
+    it("cannot claim reward", async function(done){
+      let owner = accounts[0];
+      let researcher = accounts[1];
+      let reward = web3.toWei(1, "ether");
+      let bounty = await SecureTargetBounty.new();
+      let event = bounty.TargetCreated({});
+
+      event.watch(async function(err, result) {
+        event.stopWatching();
+        if (err) { throw err }
+
+        var targetAddress = result.args.createdAddress;
+        sendReward(owner, bounty.address, reward);
+
+        assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
+
+        try {
+          let tmpClain = await bounty.claim(targetAddress, {from:researcher});
+          done("should not come here");
+        } catch(error) {
+            let reClaimedBounty = await bounty.claimed.call();
+            assert.isFalse(reClaimedBounty);
+
+            try {
+              let withdraw = await bounty.withdrawPayments({from:researcher});
+              done("should not come here")
+            } catch (err) {
+              assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
+              done();
+            }
+        }//end of first try catch
+      });
+      bounty.createTarget({from:researcher});
     })
   })
 
   describe("Against broken contract", function(){
-    it("checkInvariant returns false", function(done){
-      var bounty;
-
-      InsecureTargetBounty.new().
-        then(function(_bounty) {
-          bounty = _bounty;
-          return bounty.createTarget();
-        }).
-        then(function() {
-          return bounty.checkInvariant.call()
-        }).
-        then(function(result) {
-          assert.isFalse(result);
-        }).
-        then(done);
+    it("checkInvariant returns false", async function(){
+      let bounty = await InsecureTargetBounty.new();
+      let target = await bounty.createTarget();
+      let invariantCall = await bounty.checkInvariant.call();
+
+      assert.isFalse(invariantCall);
     })
 
-    it("claims reward", function(done){
-      var owner = accounts[0];
-      var researcher = accounts[1];
-      var reward = web3.toWei(1, "ether");
-
-      InsecureTargetBounty.new().
-        then(function(bounty) {
-          var event = bounty.TargetCreated({});
-          event.watch(function(err, result) {
-            event.stopWatching();
-            if (err) { throw err }
-            var targetAddress = result.args.createdAddress;
-            sendReward(owner, bounty.address, reward);
-            assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
-            bounty.claim(targetAddress, {from:researcher}).
-              then(function() {
-                return bounty.claimed.call();
-              }).
-              then(function(result) {
-                assert.isTrue(result);
-                return bounty.withdrawPayments({from:researcher})
-              }).
-              then(function() {
-                assert.equal(0, web3.eth.getBalance(bounty.address).toNumber())
-              }).then(done);
-          })
-          bounty.createTarget({from:researcher});
-        })
+    it("claims reward", async function(done){
+      let owner = accounts[0];
+      let researcher = accounts[1];
+      let reward = web3.toWei(1, "ether");
+      let bounty = await InsecureTargetBounty.new();
+      let event = bounty.TargetCreated({});
+
+      event.watch(async function(err, result) {
+        event.stopWatching();
+        if (err) { throw err }
+        let targetAddress = result.args.createdAddress;
+        sendReward(owner, bounty.address, reward);
+
+        assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
+
+        let bountyClaim = await bounty.claim(targetAddress, {from:researcher});
+        let claim = await bounty.claimed.call();
+
+        assert.isTrue(claim);
+
+        let payment = await bounty.withdrawPayments({from:researcher});
+
+        assert.equal(0, web3.eth.getBalance(bounty.address).toNumber());
+        done();
+      })
+      bounty.createTarget({from:researcher});
     })
   })
 });

test/Claimable.js

 contract('Claimable', function(accounts) {
-  var claimable;
+  let claimable;
 
-  beforeEach(function() {
-    return Claimable.new().then(function(deployed) {
-      claimable = deployed;
-    });
+  beforeEach(async function() {
+    claimable = await Claimable.new();
   });
 
-  it("should have an owner", function(done) {
-    return claimable.owner()
-      .then(function(owner) {
-        assert.isTrue(owner != 0);
-      })
-      .then(done)
+  it("should have an owner", async function() {
+    let owner = await claimable.owner();
+    assert.isTrue(owner != 0);
   });
 
-  it("changes pendingOwner after transfer", function(done) {
-    var newOwner = accounts[1];
-    return claimable.transfer(newOwner)
-      .then(function() {
-        return claimable.pendingOwner();
-      })
-      .then(function(pendingOwner) {
-        assert.isTrue(pendingOwner === newOwner);
-      })
-      .then(done)
+  it("changes pendingOwner after transfer", async function() {
+    let newOwner = accounts[1];
+    let transfer = await claimable.transfer(newOwner);
+    let pendingOwner = await claimable.pendingOwner();
+
+    assert.isTrue(pendingOwner === newOwner);
   });
 
-  it("should prevent to claimOwnership from no pendingOwner", function(done) {
-    return claimable.claimOwnership({from: accounts[2]})
-      .then(function() {
-        return claimable.owner();
-      })
-      .then(function(owner) {
-        assert.isTrue(owner != accounts[2]);
-      })
-      .then(done)
+  it("should prevent to claimOwnership from no pendingOwner", async function() {
+    let claimedOwner = await claimable.claimOwnership({from: accounts[2]});
+    let owner = await claimable.owner();
+    
+    assert.isTrue(owner != accounts[2]);
   });
 
-  it("should prevent non-owners from transfering" ,function(done) {
-    return claimable.transfer(accounts[2], {from: accounts[2]})
-      .then(function() {
-        return claimable.pendingOwner();
-      })
-      .then(function(pendingOwner) {
-        assert.isFalse(pendingOwner === accounts[2]);
-      })
-      .then(done)
+  it("should prevent non-owners from transfering", async function() {
+    let transfer = await claimable.transfer(accounts[2], {from: accounts[2]});
+    let pendingOwner = await claimable.pendingOwner();
+
+    assert.isFalse(pendingOwner === accounts[2]);
   });
 
   describe("after initiating a transfer", function () {
-    var newOwner;
+    let newOwner;
 
-    beforeEach(function () {
+    beforeEach(async function () {
       newOwner = accounts[1];
-      return claimable.transfer(newOwner);
+      await claimable.transfer(newOwner);
     });
 
-    it("changes allow pending owner to claim ownership", function(done) {
-      return claimable.claimOwnership({from: newOwner})
-        .then(function() {
-          return claimable.owner();
-        })
-        .then(function(owner) {
-          assert.isTrue(owner === newOwner);
-        })
-        .then(done)
+    it("changes allow pending owner to claim ownership", async function() {
+      let claimedOwner = await claimable.claimOwnership({from: newOwner})
+      let owner = await claimable.owner();
+
+      assert.isTrue(owner === newOwner);
     });
   });
 });

test/Killable.js

@@ -32,38 +32,25 @@ contract('Killable', function(accounts) {
     }
 };
 
-  it("should send balance to owner after death", function(done) {
-    var initBalance, newBalance, owner, address, killable, kBalance;
+  it("should send balance to owner after death", async function() {
+    let initBalance, newBalance, owner, address, killable, kBalance, txnHash, receiptMined;
     web3.eth.sendTransaction({from: web3.eth.coinbase, to: accounts[0], value: web3.toWei('50','ether')}, function(err, result) {
       if(err)
         console.log("ERROR:" + err);
       else {
         console.log(result);
       }
-    })
-    return Killable.new({from: accounts[0], value: web3.toWei('10','ether')})
-      .then(function(_killable) {
-        killable = _killable;
-        return killable.owner();
-      })
-      .then(function(_owner) {
-        owner = _owner;
-        initBalance = web3.eth.getBalance(owner);
-        kBalance = web3.eth.getBalance(killable.address);
-      })
-      .then(function() {
-        return killable.kill({from: owner});
-      })
-      .then(function (txnHash) {
-        return web3.eth.getTransactionReceiptMined(txnHash);
-      })
-      .then(function() {
-        newBalance = web3.eth.getBalance(owner);
-      })
-      .then(function() {
-        assert.isTrue(newBalance > initBalance);
-      })
-      .then(done);
+    });
+
+    killable = await Killable.new({from: accounts[0], value: web3.toWei('10','ether')});
+    owner = await killable.owner();
+    initBalance = web3.eth.getBalance(owner);
+    kBalance = web3.eth.getBalance(killable.address);
+    txnHash = await killable.kill({from: owner});
+    receiptMined = await web3.eth.getTransactionReceiptMined(txnHash);
+    newBalance = web3.eth.getBalance(owner);
+
+    assert.isTrue(newBalance > initBalance);
   });
 
 });

test/LimitBalance.js

+const assertJump = require('./helpers/assertJump');
+
 contract('LimitBalance', function(accounts) {
-  var lb;
+  let lb;
 
-  beforeEach(function() {
-    return LimitBalanceMock.new().then(function(deployed) {
-      lb = deployed;
-    });
+  beforeEach(async function() {
+    lb = await LimitBalanceMock.new();
   });
 
-  var LIMIT = 1000;
+  let LIMIT = 1000;
 
-  it("should expose limit", function(done) {
-    return lb.limit()
-      .then(function(limit) { 
-        assert.equal(limit, LIMIT);
-      })
-      .then(done)
+  it("should expose limit", async function() {
+    let limit = await lb.limit();
+    assert.equal(limit, LIMIT);
   });
 
-  it("should allow sending below limit", function(done) {
-    var amount = 1;
-    return lb.limitedDeposit({value: amount})
-      .then(function() { 
-        assert.equal(web3.eth.getBalance(lb.address), amount);
-      })
-      .then(done)
+  it("should allow sending below limit", async function() {
+    let amount = 1;
+    let limDeposit = await lb.limitedDeposit({value: amount});
+
+    assert.equal(web3.eth.getBalance(lb.address), amount);
   });
 
-  it("shouldnt allow sending above limit", function(done) {
-    var amount = 1100;
-    return lb.limitedDeposit({value: amount})
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done)
+  it("shouldnt allow sending above limit", async function() {
+    let amount = 1110;
+    try {
+      let limDeposit = await lb.limitedDeposit({value: amount});
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
-  it("should allow multiple sends below limit", function(done) {
-    var amount = 500;
-    return lb.limitedDeposit({value: amount})
-      .then(function() { 
-        assert.equal(web3.eth.getBalance(lb.address), amount);
-        return lb.limitedDeposit({value: amount})
-      })
-      .then(function() { 
-        assert.equal(web3.eth.getBalance(lb.address), amount*2);
-      })
-      .then(done)
+  it("should allow multiple sends below limit", async function() {
+    let amount = 500;
+    let limDeposit = await lb.limitedDeposit({value: amount});
+
+    assert.equal(web3.eth.getBalance(lb.address), amount);
+
+    let limDeposit2 = await lb.limitedDeposit({value: amount});
+    assert.equal(web3.eth.getBalance(lb.address), amount*2);
   });
 
-  it("shouldnt allow multiple sends above limit", function(done) {
-    var amount = 500;
-    return lb.limitedDeposit({value: amount})
-      .then(function() { 
-        assert.equal(web3.eth.getBalance(lb.address), amount);
-        return lb.limitedDeposit({value: amount+1})
-      })
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error;
-      })
-      .then(done)
+  it("shouldnt allow multiple sends above limit", async function() {
+    let amount = 500;
+    let limDeposit = await lb.limitedDeposit({value: amount});
+
+    assert.equal(web3.eth.getBalance(lb.address), amount);
+
+    try {
+      await lb.limitedDeposit({value: amount+1})
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
 });

test/Ownable.js

 contract('Ownable', function(accounts) {
-  var ownable;
+  let ownable;
 
-  beforeEach(function() {
-    return Ownable.new().then(function(deployed) {
-      ownable = deployed;
-    });
+  beforeEach(async function() {
+    ownable = await Ownable.new();
   });
 
-  it("should have an owner", function(done) {
-    return ownable.owner()
-      .then(function(owner) {
-        assert.isTrue(owner != 0);
-      })
-      .then(done)
+  it("should have an owner", async function() {
+    let owner = await ownable.owner();
+    assert.isTrue(owner != 0);
   });
 
-  it("changes owner after transfer", function(done) {
-    var other = accounts[1];
-    return ownable.transfer(other)
-      .then(function() {
-        return ownable.owner();
-      })
-      .then(function(owner) {
-        assert.isTrue(owner === other);
-      })
-      .then(done)
+  it("changes owner after transfer", async function() {
+    let other = accounts[1];
+    let transfer = await ownable.transfer(other);
+    let owner = await ownable.owner();
+
+    assert.isTrue(owner === other);
   });
 
-  it("should prevent non-owners from transfering" ,function(done) {
-    var other = accounts[2];
-    return ownable.transfer(other, {from: accounts[2]})
-      .then(function() {
-        return ownable.owner();
-      })
-      .then(function(owner) {
-        assert.isFalse(owner === other);
-      })
-      .then(done)
+  it("should prevent non-owners from transfering", async function() {
+    let other = accounts[2];
+    let transfer = await ownable.transfer(other, {from: accounts[2]});
+    let owner = await ownable.owner();
+
+     assert.isFalse(owner === other);
   });
 
-  it("should guard ownership against stuck state" ,function(done) {
-    var ownable = Ownable.deployed();
-
-    return ownable.owner()
-      .then(function (originalOwner) {
-        return ownable.transfer(null, {from: originalOwner})
-          .then(function() {
-            return ownable.owner();
-          })
-          .then(function(newOwner) {
-            assert.equal(originalOwner, newOwner);
-          })
-          .then(done);
-      });
+  it("should guard ownership against stuck state", async function() {
+    let ownable = Ownable.deployed();
+    let originalOwner = await ownable.owner();
+    let transfer = await ownable.transfer(null, {from: originalOwner});
+    let newOwner = await ownable.owner();
+    
+    assert.equal(originalOwner, newOwner);
   });
 
 });

test/PullPayment.js

 contract('PullPayment', function(accounts) {
 
-  it("can't call asyncSend externally", function(done) {
-    return PullPaymentMock.new()
-      .then(function(ppc) {
-        assert.isUndefined(ppc.asyncSend);
-      })
-      .then(done);
+  it("can't call asyncSend externally", async function() {
+    let ppc = await PullPaymentMock.new();
+    assert.isUndefined(ppc.asyncSend);
   });
 
-  it("can record an async payment correctly", function(done) {
-    var ppce;
-    var AMOUNT = 100;
-    return PullPaymentMock.new()
-      .then(function(_ppce) {
-        ppce = _ppce;
-        ppce.callSend(accounts[0], AMOUNT)
-      })
-      .then(function() {
-        return ppce.payments(accounts[0]);
-      })
-      .then(function(paymentsToAccount0) {
-        assert.equal(paymentsToAccount0, AMOUNT);
-      })
-      .then(done);
+  it("can record an async payment correctly", async function() {
+    let AMOUNT = 100;
+    let ppce = await PullPaymentMock.new();
+    let callSend = await ppce.callSend(accounts[0], AMOUNT);
+    let paymentsToAccount0 = await ppce.payments(accounts[0]);
+
+    assert.equal(paymentsToAccount0, AMOUNT);
   });
 
-  it("can add multiple balances on one account", function(done) {
-    var ppce;
-    return PullPaymentMock.new()
-      .then(function(_ppce) {
-        ppce = _ppce;
-        return ppce.callSend(accounts[0], 200)
-      })
-      .then(function() {
-        return ppce.callSend(accounts[0], 300)
-      })
-      .then(function() {
-        return ppce.payments(accounts[0]);
-      })
-      .then(function(paymentsToAccount0) {
-        assert.equal(paymentsToAccount0, 500);
-      })
-      .then(done);
+  it("can add multiple balances on one account", async function() {
+    let ppce = await PullPaymentMock.new();
+    let call1 = await ppce.callSend(accounts[0], 200);
+    let call2 = await ppce.callSend(accounts[0], 300);
+    let paymentsToAccount0 = await ppce.payments(accounts[0]);
+
+    assert.equal(paymentsToAccount0, 500);
   });
 
-  it("can add balances on multiple accounts", function(done) {
-    var ppce;
-    return PullPaymentMock.new()
-      .then(function(_ppce) {
-        ppce = _ppce;
-        return ppce.callSend(accounts[0], 200)
-      })
-      .then(function() {
-        return ppce.callSend(accounts[1], 300)
-      })
-      .then(function() {
-        return ppce.payments(accounts[0]);
-      })
-      .then(function(paymentsToAccount0) {
-        assert.equal(paymentsToAccount0, 200);
-      })
-      .then(function() {
-        return ppce.payments(accounts[1]);
-      })
-      .then(function(paymentsToAccount0) {
-        assert.equal(paymentsToAccount0, 300);
-      })
-      .then(done);
+  it("can add balances on multiple accounts", async function() {
+    let ppce = await PullPaymentMock.new();
+    let call1 = await ppce.callSend(accounts[0], 200);
+    let call2 = await ppce.callSend(accounts[1], 300);
+
+    let paymentsToAccount0 = await ppce.payments(accounts[0]);
+    assert.equal(paymentsToAccount0, 200);
+
+    let paymentsToAccount1 = await ppce.payments(accounts[1]);
+    assert.equal(paymentsToAccount1, 300);
   });
 
-  it("can withdraw payment", function(done) {
-    var ppce;
-    var AMOUNT = 17*1e18;
-    var payee = accounts[1];
-    var initialBalance = web3.eth.getBalance(payee);
-    return PullPaymentMock.new({value: AMOUNT})
-      .then(function(_ppce) {
-        ppce = _ppce;
-        return ppce.callSend(payee, AMOUNT);
-      })
-      .then(function() {
-        return ppce.payments(payee);
-      })
-      .then(function(paymentsToAccount0) {
-        assert.equal(paymentsToAccount0, AMOUNT);
-      })
-      .then(function() {
-        return ppce.withdrawPayments({from: payee});
-      })
-      .then(function() {
-        return ppce.payments(payee);
-      })
-      .then(function(paymentsToAccount0) {
-        assert.equal(paymentsToAccount0, 0);
-        var balance = web3.eth.getBalance(payee);
-        assert(Math.abs(balance-initialBalance-AMOUNT) < 1e16);
-      })
-      .then(done);
+  it("can withdraw payment", async function() {
+    let AMOUNT = 17*1e18;
+    let payee = accounts[1];
+    let initialBalance = web3.eth.getBalance(payee);
+
+    let ppce = await PullPaymentMock.new({value: AMOUNT});
+    let call1 = await ppce.callSend(payee, AMOUNT);
+
+    let payment1 = await ppce.payments(payee);
+    assert.equal(payment1, AMOUNT);
+
+    let withdraw = await ppce.withdrawPayments({from: payee});
+    let payment2 = await ppce.payments(payee);
+    assert.equal(payment2, 0);
+
+    let balance = web3.eth.getBalance(payee);
+    assert(Math.abs(balance-initialBalance-AMOUNT) < 1e16);
   });
 
 });

test/SafeMath.js

+const assertJump = require('./helpers/assertJump');
 
 contract('SafeMath', function(accounts) {
 
-  var safeMath;
+  let safeMath;
 
-  before(function() {
-    return SafeMathMock.new()
-      .then(function(_safeMath) {
-        safeMath = _safeMath;
-      });
+  before(async function() {
+    safeMath = await SafeMathMock.new();
   });
 
-  it("multiplies correctly", function(done) {
-    var a = 5678;
-    var b = 1234;
-    return safeMath.multiply(a, b)
-      .then(function() {
-        return safeMath.result();
-      })
-      .then(function(result) {
-        assert.equal(result, a*b);
-      })
-      .then(done);
+  it("multiplies correctly", async function() {
+    let a = 5678;
+    let b = 1234;
+    let mult = await safeMath.multiply(a, b);
+    let result = await safeMath.result();
+    assert.equal(result, a*b);
   });
 
-  it("adds correctly", function(done) {
-    var a = 5678;
-    var b = 1234;
-    return safeMath.add(a, b)
-      .then(function() {
-        return safeMath.result();
-      })
-      .then(function(result) {
-        assert.equal(result, a+b);
-      })
-      .then(done);
+  it("adds correctly", async function() {
+    let a = 5678;
+    let b = 1234;
+    let add = await safeMath.add(a, b);
+    let result = await safeMath.result();
+
+    assert.equal(result, a+b);
   });
 
-  it("subtracts correctly", function(done) {
-    var a = 5678;
-    var b = 1234;
-    return safeMath.subtract(a, b)
-      .then(function() {
-        return safeMath.result();
-      })
-      .then(function(result) {
-        assert.equal(result, a-b);
-      })
-      .then(done);
+  it("subtracts correctly", async function() {
+    let a = 5678;
+    let b = 1234;
+    let subtract = await safeMath.subtract(a, b);
+    let result = await safeMath.result();
+
+    assert.equal(result, a-b);
   });
 
-  it("should throw an error if subtraction result would be negative", function (done) {
-    var a = 1234;
-    var b = 5678;
-    return safeMath.subtract(a, b)
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done);
+  it("should throw an error if subtraction result would be negative", async function () {
+    let a = 1234;
+    let b = 5678;
+    try {
+      let subtract = await safeMath.subtract(a, b);
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
-  it("should throw an error on addition overflow", function(done) {
-    var a = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
-    var b = 1;
-    return safeMath.add(a, b)
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done);
+  it("should throw an error on addition overflow", async function() {
+    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
+    let b = 1;
+    try {
+      let add = await safeMath.add(a, b);
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
-  it("should throw an error on multiplication overflow", function(done) {
-    var a = 115792089237316195423570985008687907853269984665640564039457584007913129639933;
-    var b = 2;
-    return safeMath.multiply(a, b)
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done);
+  it("should throw an error on multiplication overflow", async function() {
+    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639933;
+    let b = 2;
+    try {
+      let multiply = await safeMath.multiply(a, b);
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
 });

test/StandardToken.js

+const assertJump = require('./helpers/assertJump');
+
 contract('StandardToken', function(accounts) {
 
-  it("should return the correct totalSupply after construction", function(done) {
-    return StandardTokenMock.new(accounts[0], 100)
-      .then(function(token) {
-        return token.totalSupply();
-      })
-      .then(function(totalSupply) {
-        assert.equal(totalSupply, 100);
-      })
-      .then(done);
+  it("should return the correct totalSupply after construction", async function() {
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    let totalSupply = await token.totalSupply();
+
+    assert.equal(totalSupply, 100);
   })
 
-  it("should return the correct allowance amount after approval", function(done) {
-    var token;
-    return StandardTokenMock.new()
-      .then(function(_token) {
-        token = _token;
-        return token.approve(accounts[1], 100);
-      })
-      .then(function() {
-        return token.allowance(accounts[0], accounts[1]);
-      })
-      .then(function(allowance) {
-        assert.equal(allowance, 100);
-      })
-      .then(done);
+  it("should return the correct allowance amount after approval", async function() {
+    let token = await StandardTokenMock.new();
+    let approve = await token.approve(accounts[1], 100);
+    let allowance = await token.allowance(accounts[0], accounts[1]);
+
+    assert.equal(allowance, 100);
   });
 
-  it("should return correct balances after transfer", function(done) {
-    var token;
-    return StandardTokenMock.new(accounts[0], 100)
-      .then(function(_token) {
-        token = _token;
-        return token.transfer(accounts[1], 100);
-      })
-      .then(function() {
-        return token.balanceOf(accounts[0]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 0);
-      })
-      .then(function() {
-        return token.balanceOf(accounts[1]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 100);
-      })
-      .then(done);
+  it("should return correct balances after transfer", async function() {
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    let transfer = await token.transfer(accounts[1], 100);
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert.equal(balance0, 0);
+
+    let balance1 = await token.balanceOf(accounts[1]);
+    assert.equal(balance1, 100);
   });
 
-  it("should throw an error when trying to transfer more than balance", function(done) {
-    var token;
-    return StandardTokenMock.new(accounts[0], 100)
-      .then(function(_token) {
-        token = _token;
-        return token.transfer(accounts[1], 101);
-      })
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done);
+  it("should throw an error when trying to transfer more than balance", async function() {
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    try {
+      let transfer = await token.transfer(accounts[1], 101);
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
-  it("should return correct balances after transfering from another account", function(done) {
-    var token;
-    return StandardTokenMock.new(accounts[0], 100)
-      .then(function(_token) {
-        token = _token;
-        return token.approve(accounts[1], 100);
-      })
-      .then(function() {
-        return token.transferFrom(accounts[0], accounts[2], 100, {from: accounts[1]});
-      })
-      .then(function() {
-        return token.balanceOf(accounts[0]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 0);
-        return token.balanceOf(accounts[2]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 100)
-        return token.balanceOf(accounts[1]);
-      })
-      .then(function(balance) {
-        assert.equal(balance, 0);
-      })
-      .then(done);
+  it("should return correct balances after transfering from another account", async function() {
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    let approve = await token.approve(accounts[1], 100);
+    let transferFrom = await token.transferFrom(accounts[0], accounts[2], 100, {from: accounts[1]});
+
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert.equal(balance0, 0);
+
+    let balance1 = await token.balanceOf(accounts[2]);
+    assert.equal(balance1, 100);
+
+    let balance2 = await token.balanceOf(accounts[1]);
+    assert.equal(balance2, 0);
   });
 
-  it("should throw an error when trying to transfer more than allowed", function(done) {
-    var token;
-    return StandardTokenMock.new(accounts[0], 100)
-      .then(function(_token) {
-        token = _token;
-        return token.approve(accounts[1], 99);
-      })
-      .then(function() {
-        return token.transferFrom(accounts[0], accounts[2], 100, {from: accounts[1]});
-      })
-      .catch(function(error) {
-        if (error.message.search('invalid JUMP') == -1) throw error
-      })
-      .then(done);
+  it("should throw an error when trying to transfer more than allowed", async function() {
+    let token = await StandardTokenMock.new();
+    let approve = await token.approve(accounts[1], 99);
+    try {
+      let transfer = await token.transferFrom(accounts[0], accounts[2], 100, {from: accounts[1]});
+    } catch (error) {
+      assertJump(error);
+    }
   });
 
 });

test/Stoppable.js

 contract('Stoppable', function(accounts) {
 
-  it("can perform normal process in non-emergency", function(done) {
-    var stoppable;
-    return StoppableMock.new()
-      .then(function(_stoppable) {
-        stoppable = _stoppable;
-        return stoppable.count();
-      })
-      .then(function(count) {
-        assert.equal(count, 0);
-      })
-      .then(function () {
-        return stoppable.normalProcess();
-      })
-      .then(function() {
-        return stoppable.count();
-      })
-      .then(function(count) {
-        assert.equal(count, 1);
-      })
-      .then(done);
+  it("can perform normal process in non-emergency", async function() {
+    let stoppable = await StoppableMock.new();
+    let count0 = await stoppable.count();
+    assert.equal(count0, 0);
+
+    let normalProcess = await stoppable.normalProcess();
+    let count1 = await stoppable.count();
+    assert.equal(count1, 1);
   });
 
-  it("can not perform normal process in emergency", function(done) {
-    var stoppable;
-    return StoppableMock.new()
-      .then(function(_stoppable) {
-        stoppable = _stoppable;
-        return stoppable.emergencyStop();
-      })
-      .then(function () {
-        return stoppable.count();
-      })
-      .then(function(count) {
-        assert.equal(count, 0);
-      })
-      .then(function () {
-        return stoppable.normalProcess();
-      })
-      .then(function() {
-        return stoppable.count();
-      })
-      .then(function(count) {
-        assert.equal(count, 0);
-      })
-      .then(done);
+  it("can not perform normal process in emergency", async function() {
+    let stoppable = await StoppableMock.new();
+    let emergencyStop = await stoppable.emergencyStop();
+    let count0 = await stoppable.count();
+    assert.equal(count0, 0);
+
+    let normalProcess = await stoppable.normalProcess();
+    let count1 = await stoppable.count();
+    assert.equal(count1, 0);
   });
 
 
-  it("can not take drastic measure in non-emergency", function(done) {
-    var stoppable;
-    return StoppableMock.new()
-      .then(function(_stoppable) {
-        stoppable = _stoppable;
-        return stoppable.drasticMeasure();
-      })
-      .then(function() {
-        return stoppable.drasticMeasureTaken();
-      })
-      .then(function(taken) {
-        assert.isFalse(taken);
-      })
-      .then(done);
+  it("can not take drastic measure in non-emergency", async function() {
+    let stoppable = await StoppableMock.new();
+    let drasticMeasure = await stoppable.drasticMeasure();
+    let drasticMeasureTaken = await stoppable.drasticMeasureTaken();
+
+    assert.isFalse(drasticMeasureTaken);
   });
 
-  it("can take a drastic measure in an emergency", function(done) {
-    var stoppable;
-    return StoppableMock.new()
-      .then(function(_stoppable) {
-        stoppable = _stoppable;
-        return stoppable.emergencyStop();
-      })
-      .then(function() {
-        return stoppable.drasticMeasure();
-      })
-      .then(function() {
-        return stoppable.drasticMeasureTaken();
-      })
-      .then(function(taken) {
-        assert.isTrue(taken);
-      })
-      .then(done);
+  it("can take a drastic measure in an emergency", async function() {
+    let stoppable = await StoppableMock.new();
+    let emergencyStop = await stoppable.emergencyStop();
+    let drasticMeasure = await stoppable.drasticMeasure();
+    let drasticMeasureTaken = await stoppable.drasticMeasureTaken();
+
+    assert.isTrue(drasticMeasureTaken);
   });
 
-  it("should resume allowing normal process after emergency is over", function(done) {
-    var stoppable;
-    return StoppableMock.new()
-      .then(function(_stoppable) {
-        stoppable = _stoppable;
-        return stoppable.emergencyStop();
-      })
-      .then(function () {
-        return stoppable.release();
-      })
-      .then(function() {
-        return stoppable.normalProcess();
-      })
-      .then(function() {
-        return stoppable.count();
-      })
-      .then(function(count) {
-        assert.equal(count, 1);
-      })
-      .then(done);
+  it("should resume allowing normal process after emergency is over", async function() {
+    let stoppable = await StoppableMock.new();
+    let emergencyStop = await stoppable.emergencyStop();
+    let release = await stoppable.release();
+    let normalProcess = await stoppable.normalProcess();
+    let count0 = await stoppable.count();
+
+    assert.equal(count0, 1);
   });
 
 });

test/helpers/assertJump.js

+module.exports = function(error) {
+  assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
+}