changed exxpect to expect wherever applicable

Author: yopereir

test/access/Roles.test.js

@@ -1,6 +1,8 @@
 const { expectRevert, constants } = require('openzeppelin-test-helpers');
 const { ZERO_ADDRESS } = constants;
 
+const { expect } = require('chai');
+
 const RolesMock = artifacts.require('RolesMock');
 
 contract('Roles', function ([_, authorized, otherAuthorized, other]) {
@@ -14,16 +16,16 @@ contract('Roles', function ([_, authorized, otherAuthorized, other]) {
 
   context('initially', function () {
     it('doesn\'t pre-assign roles', async function () {
-      (await this.roles.has(authorized)).should.equal(false);
-      (await this.roles.has(otherAuthorized)).should.equal(false);
-      (await this.roles.has(other)).should.equal(false);
+      expect(await this.roles.has(authorized)).to.equal(false);
+      expect(await this.roles.has(otherAuthorized)).to.equal(false);
+      expect(await this.roles.has(other)).to.equal(false);
     });
 
     describe('adding roles', function () {
       it('adds roles to a single account', async function () {
         await this.roles.add(authorized);
-        (await this.roles.has(authorized)).should.equal(true);
-        (await this.roles.has(other)).should.equal(false);
+        expect(await this.roles.has(authorized)).to.equal(true);
+        expect(await this.roles.has(other)).to.equal(false);
       });
 
       it('reverts when adding roles to an already assigned account', async function () {
@@ -46,8 +48,8 @@ contract('Roles', function ([_, authorized, otherAuthorized, other]) {
     describe('removing roles', function () {
       it('removes a single role', async function () {
         await this.roles.remove(authorized);
-        (await this.roles.has(authorized)).should.equal(false);
-        (await this.roles.has(otherAuthorized)).should.equal(true);
+        expect(await this.roles.has(authorized)).to.equal(false);
+        expect(await this.roles.has(otherAuthorized)).to.equal(true);
       });
 
       it('reverts when removing unassigned roles', async function () {

test/behaviors/access/roles/PublicRole.behavior.js

@@ -1,6 +1,8 @@
 const { expectRevert, constants, expectEvent } = require('openzeppelin-test-helpers');
 const { ZERO_ADDRESS } = constants;
 
+const { expect } = require('chai');
+
 function capitalize (str) {
   return str.replace(/\b\w/g, l => l.toUpperCase());
 }
@@ -25,9 +27,9 @@ function shouldBehaveLikePublicRole (authorized, otherAuthorized, [other], rolen
 
   describe('should behave like public role', function () {
     beforeEach('check preconditions', async function () {
-      (await this.contract[`is${rolename}`](authorized)).should.equal(true);
-      (await this.contract[`is${rolename}`](otherAuthorized)).should.equal(true);
-      (await this.contract[`is${rolename}`](other)).should.equal(false);
+      expect(await this.contract[`is${rolename}`](authorized)).to.equal(true);
+      expect(await this.contract[`is${rolename}`](otherAuthorized)).to.equal(true);
+      expect(await this.contract[`is${rolename}`](other)).to.equal(false);
     });
 
     if (manager === undefined) { // Managed roles are only assigned by the manager, and none are set at construction
@@ -70,7 +72,7 @@ function shouldBehaveLikePublicRole (authorized, otherAuthorized, [other], rolen
       context(`from ${manager ? 'the manager' : 'a role-haver'} account`, function () {
         it('adds role to a new account', async function () {
           await this.contract[`add${rolename}`](other, { from });
-          (await this.contract[`is${rolename}`](other)).should.equal(true);
+          expect(await this.contract[`is${rolename}`](other)).to.equal(true);
         });
 
         it(`emits a ${rolename}Added event`, async function () {
@@ -99,8 +101,8 @@ function shouldBehaveLikePublicRole (authorized, otherAuthorized, [other], rolen
       context(`from ${manager ? 'the manager' : 'any'} account`, function () {
         it('removes role from an already assigned account', async function () {
           await this.contract[`remove${rolename}`](authorized, { from });
-          (await this.contract[`is${rolename}`](authorized)).should.equal(false);
-          (await this.contract[`is${rolename}`](otherAuthorized)).should.equal(true);
+          expect(await this.contract[`is${rolename}`](authorized)).to.equal(false);
+          expect(await this.contract[`is${rolename}`](otherAuthorized)).to.equal(true);
         });
 
         it(`emits a ${rolename}Removed event`, async function () {
@@ -125,7 +127,7 @@ function shouldBehaveLikePublicRole (authorized, otherAuthorized, [other], rolen
     describe('renouncing roles', function () {
       it('renounces an assigned role', async function () {
         await this.contract[`renounce${rolename}`]({ from: authorized });
-        (await this.contract[`is${rolename}`](authorized)).should.equal(false);
+        expect(await this.contract[`is${rolename}`](authorized)).to.equal(false);
       });
 
       it(`emits a ${rolename}Removed event`, async function () {

test/crowdsale/AllowanceCrowdsale.test.js

@@ -1,6 +1,8 @@
 const { balance, BN, constants, ether, expectEvent, expectRevert } = require('openzeppelin-test-helpers');
 const { ZERO_ADDRESS } = constants;
 
+const { expect } = require('chai');
+
 const AllowanceCrowdsaleImpl = artifacts.require('AllowanceCrowdsaleImpl');
 const SimpleToken = artifacts.require('SimpleToken');
 
@@ -18,7 +20,7 @@ contract('AllowanceCrowdsale', function ([_, investor, wallet, purchaser, tokenW
 
   describe('accepting payments', function () {
     it('should have token wallet', async function () {
-      (await this.crowdsale.tokenWallet()).should.be.equal(tokenWallet);
+      expect(await this.crowdsale.tokenWallet()).to.equal(tokenWallet);
     });
 
     it('should accept sends', async function () {
@@ -43,21 +45,21 @@ contract('AllowanceCrowdsale', function ([_, investor, wallet, purchaser, tokenW
 
     it('should assign tokens to sender', async function () {
       await this.crowdsale.sendTransaction({ value: value, from: investor });
-      (await this.token.balanceOf(investor)).should.be.bignumber.equal(expectedTokenAmount);
+      expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(expectedTokenAmount);
     });
 
     it('should forward funds to wallet', async function () {
       const balanceTracker = await balance.tracker(wallet);
       await this.crowdsale.sendTransaction({ value, from: investor });
-      (await balanceTracker.delta()).should.be.bignumber.equal(value);
+      expect(await balanceTracker.delta()).to.be.bignumber.equal(value);
     });
   });
 
   describe('check remaining allowance', function () {
     it('should report correct allowance left', async function () {
       const remainingAllowance = tokenAllowance.sub(expectedTokenAmount);
       await this.crowdsale.buyTokens(investor, { value: value, from: purchaser });
-      (await this.crowdsale.remainingTokens()).should.be.bignumber.equal(remainingAllowance);
+      expect(await this.crowdsale.remainingTokens()).to.be.bignumber.equal(remainingAllowance);
     });
 
     context('when the allowance is larger than the token amount', function () {
@@ -67,7 +69,7 @@ contract('AllowanceCrowdsale', function ([_, investor, wallet, purchaser, tokenW
       });
 
       it('should report the amount instead of the allowance', async function () {
-        (await this.crowdsale.remainingTokens()).should.be.bignumber.equal(await this.token.balanceOf(tokenWallet));
+        expect(await this.crowdsale.remainingTokens()).to.be.bignumber.equal(await this.token.balanceOf(tokenWallet));
       });
     });
   });

test/crowdsale/CappedCrowdsale.test.js

@@ -1,5 +1,7 @@
 const { BN, ether, expectRevert } = require('openzeppelin-test-helpers');
 
+const { expect } = require('chai');
+
 const CappedCrowdsaleImpl = artifacts.require('CappedCrowdsaleImpl');
 const SimpleToken = artifacts.require('SimpleToken');
 
@@ -44,17 +46,17 @@ contract('CappedCrowdsale', function ([_, wallet]) {
     describe('ending', function () {
       it('should not reach cap if sent under cap', async function () {
         await this.crowdsale.send(lessThanCap);
-        (await this.crowdsale.capReached()).should.equal(false);
+        expect(await this.crowdsale.capReached()).to.equal(false);
       });
 
       it('should not reach cap if sent just under cap', async function () {
         await this.crowdsale.send(cap.subn(1));
-        (await this.crowdsale.capReached()).should.equal(false);
+        expect(await this.crowdsale.capReached()).to.equal(false);
       });
 
       it('should reach cap if cap sent', async function () {
         await this.crowdsale.send(cap);
-        (await this.crowdsale.capReached()).should.equal(true);
+        expect(await this.crowdsale.capReached()).to.equal(true);
       });
     });
   });

test/crowdsale/Crowdsale.test.js

@@ -1,6 +1,8 @@
 const { balance, BN, constants, ether, expectEvent, expectRevert } = require('openzeppelin-test-helpers');
 const { ZERO_ADDRESS } = constants;
 
+const { expect } = require('chai');
+
 const Crowdsale = artifacts.require('CrowdsaleMock');
 const SimpleToken = artifacts.require('SimpleToken');
 
@@ -86,13 +88,13 @@ contract('Crowdsale', function ([_, investor, wallet, purchaser]) {
 
         it('should assign tokens to sender', async function () {
           await this.crowdsale.sendTransaction({ value: value, from: investor });
-          (await this.token.balanceOf(investor)).should.be.bignumber.equal(expectedTokenAmount);
+          expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(expectedTokenAmount);
         });
 
         it('should forward funds to wallet', async function () {
           const balanceTracker = await balance.tracker(wallet);
           await this.crowdsale.sendTransaction({ value, from: investor });
-          (await balanceTracker.delta()).should.be.bignumber.equal(value);
+          expect(await balanceTracker.delta()).to.be.bignumber.equal(value);
         });
       });
 
@@ -109,13 +111,13 @@ contract('Crowdsale', function ([_, investor, wallet, purchaser]) {
 
         it('should assign tokens to beneficiary', async function () {
           await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-          (await this.token.balanceOf(investor)).should.be.bignumber.equal(expectedTokenAmount);
+          expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(expectedTokenAmount);
         });
 
         it('should forward funds to wallet', async function () {
           const balanceTracker = await balance.tracker(wallet);
           await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-          (await balanceTracker.delta()).should.be.bignumber.equal(value);
+          expect(await balanceTracker.delta()).to.be.bignumber.equal(value);
         });
       });
     });

test/crowdsale/IncreasingPriceCrowdsale.test.js

@@ -1,5 +1,7 @@
 const { BN, ether, expectRevert, time } = require('openzeppelin-test-helpers');
 
+const { expect } = require('chai');
+
 const IncreasingPriceCrowdsaleImpl = artifacts.require('IncreasingPriceCrowdsaleImpl');
 const SimpleToken = artifacts.require('SimpleToken');
 
@@ -52,8 +54,8 @@ contract('IncreasingPriceCrowdsale', function ([_, investor, wallet, purchaser])
       });
 
       it('should have initial and final rate', async function () {
-        (await this.crowdsale.initialRate()).should.be.bignumber.equal(initialRate);
-        (await this.crowdsale.finalRate()).should.be.bignumber.equal(finalRate);
+        expect(await this.crowdsale.initialRate()).to.be.bignumber.equal(initialRate);
+        expect(await this.crowdsale.finalRate()).to.be.bignumber.equal(finalRate);
       });
 
       it('reverts when the base Crowdsale\'s rate function is called', async function () {
@@ -63,54 +65,54 @@ contract('IncreasingPriceCrowdsale', function ([_, investor, wallet, purchaser])
       });
 
       it('returns a rate of 0 before the crowdsale starts', async function () {
-        (await this.crowdsale.getCurrentRate()).should.be.bignumber.equal('0');
+        expect(await this.crowdsale.getCurrentRate()).to.be.bignumber.equal('0');
       });
 
       it('returns a rate of 0 after the crowdsale ends', async function () {
         await time.increaseTo(this.afterClosingTime);
-        (await this.crowdsale.getCurrentRate()).should.be.bignumber.equal('0');
+        expect(await this.crowdsale.getCurrentRate()).to.be.bignumber.equal('0');
       });
 
       it('at start', async function () {
         await time.increaseTo(this.startTime);
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(initialRate));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(initialRate));
       });
 
       it('at time 150', async function () {
         await time.increaseTo(this.startTime.addn(150));
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(rateAtTime150));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(rateAtTime150));
       });
 
       it('at time 300', async function () {
         await time.increaseTo(this.startTime.addn(300));
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(rateAtTime300));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(rateAtTime300));
       });
 
       it('at time 1500', async function () {
         await time.increaseTo(this.startTime.addn(1500));
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(rateAtTime1500));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(rateAtTime1500));
       });
 
       it('at time 30', async function () {
         await time.increaseTo(this.startTime.addn(30));
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(rateAtTime30));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(rateAtTime30));
       });
 
       it('at time 150000', async function () {
         await time.increaseTo(this.startTime.addn(150000));
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(rateAtTime150000));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(rateAtTime150000));
       });
 
       it('at time 450000', async function () {
         await time.increaseTo(this.startTime.addn(450000));
         await this.crowdsale.buyTokens(investor, { value, from: purchaser });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(value.mul(rateAtTime450000));
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(value.mul(rateAtTime450000));
       });
     });
   });

test/crowdsale/IndividuallyCappedCrowdsale.test.js

@@ -1,5 +1,7 @@
 const { BN, ether, expectRevert } = require('openzeppelin-test-helpers');
 
+const { expect } = require('chai');
+
 const IndividuallyCappedCrowdsaleImpl = artifacts.require('IndividuallyCappedCrowdsaleImpl');
 const SimpleToken = artifacts.require('SimpleToken');
 const { shouldBehaveLikePublicRole } = require('../behaviors/access/roles/PublicRole.behavior');
@@ -30,7 +32,7 @@ contract('IndividuallyCappedCrowdsale', function (
   describe('individual caps', function () {
     it('sets a cap when the sender is a capper', async function () {
       await this.crowdsale.setCap(alice, capAlice, { from: capper });
-      (await this.crowdsale.getCap(alice)).should.be.bignumber.equal(capAlice);
+      expect(await this.crowdsale.getCap(alice)).to.be.bignumber.equal(capAlice);
     });
 
     it('reverts when a non-capper sets a cap', async function () {
@@ -84,12 +86,12 @@ contract('IndividuallyCappedCrowdsale', function (
 
       describe('reporting state', function () {
         it('should report correct cap', async function () {
-          (await this.crowdsale.getCap(alice)).should.be.bignumber.equal(capAlice);
+          expect(await this.crowdsale.getCap(alice)).to.be.bignumber.equal(capAlice);
         });
 
         it('should report actual contribution', async function () {
           await this.crowdsale.buyTokens(alice, { value: lessThanCapAlice });
-          (await this.crowdsale.getContribution(alice)).should.be.bignumber.equal(lessThanCapAlice);
+          expect(await this.crowdsale.getContribution(alice)).to.be.bignumber.equal(lessThanCapAlice);
         });
       });
     });

test/crowdsale/MintedCrowdsale.behavior.js

@@ -1,5 +1,7 @@
 const { balance, expectEvent } = require('openzeppelin-test-helpers');
 
+const { expect } = require('chai');
+
 function shouldBehaveLikeMintedCrowdsale ([_, investor, wallet, purchaser], rate, value) {
   const expectedTokenAmount = rate.mul(value);
 
@@ -24,13 +26,13 @@ function shouldBehaveLikeMintedCrowdsale ([_, investor, wallet, purchaser], rate
 
       it('should assign tokens to sender', async function () {
         await this.crowdsale.sendTransaction({ value: value, from: investor });
-        (await this.token.balanceOf(investor)).should.be.bignumber.equal(expectedTokenAmount);
+        expect(await this.token.balanceOf(investor)).to.be.bignumber.equal(expectedTokenAmount);
       });
 
       it('should forward funds to wallet', async function () {
         const balanceTracker = await balance.tracker(wallet);
         await this.crowdsale.sendTransaction({ value, from: investor });
-        (await balanceTracker.delta()).should.be.bignumber.equal(value);
+        expect(await balanceTracker.delta()).to.be.bignumber.equal(value);
       });
     });
   });

test/crowdsale/MintedCrowdsale.test.js

@@ -1,6 +1,8 @@
 const { BN, ether, expectRevert } = require('openzeppelin-test-helpers');
 const { shouldBehaveLikeMintedCrowdsale } = require('./MintedCrowdsale.behavior');
 
+const { expect } = require('chai');
+
 const MintedCrowdsaleImpl = artifacts.require('MintedCrowdsaleImpl');
 const ERC20Mintable = artifacts.require('ERC20Mintable');
 const ERC20 = artifacts.require('ERC20');
@@ -19,7 +21,7 @@ contract('MintedCrowdsale', function ([_, deployer, investor, wallet, purchaser]
     });
 
     it('crowdsale should be minter', async function () {
-      (await this.token.isMinter(this.crowdsale.address)).should.equal(true);
+      expect(await this.token.isMinter(this.crowdsale.address)).to.equal(true);
     });
 
     shouldBehaveLikeMintedCrowdsale([_, investor, wallet, purchaser], rate, value);