Skip to content

O
openzeppelin-contracts-upgradeable
Commit eb41a81f by Angello Pozo
Options

fix: made code cleaner. added helper. removed done from most tests.

parent 688106e9
Showing with 116 additions and 127 deletions
test/BasicToken.js
const assertJump = require('./helpers/assertJump');
contract('BasicToken', function(accounts) {
it("should return the correct totalSupply after construction", async function(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);
done();
})
it("should return correct balances after transfer", async function(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);
done();
});
it("should throw an error when trying to transfer more than balance", async function(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) {
if (error.message.search('invalid JUMP') === -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
......
test/Bounty.js
......@@ -8,51 +8,51 @@ let sendReward = function(sender, receiver, value){
contract('Bounty', function(accounts) {
it("sets reward", async function(done){
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);
assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
done();
})
it("empties itself when killed", async function(done){
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);
assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
await bounty.kill();
assert.equal(0, web3.eth.getBalance(bounty.address).toNumber());
done();
})
describe("Against secure contract", function(){
it("checkInvariant returns true", async function(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);
done();
})
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 {
......@@ -61,13 +61,14 @@ contract('Bounty', function(accounts) {
} 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())
}
assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
done();
}
}//end of first try catch
});
bounty.createTarget({from:researcher});
......@@ -75,21 +76,19 @@ contract('Bounty', function(accounts) {
})
describe("Against broken contract", function(){
it("checkInvariant returns false", async function(done){
it("checkInvariant returns false", async function(){
let bounty = await InsecureTargetBounty.new();
let target = await bounty.createTarget();
let invarriantCall = await bounty.checkInvariant.call();
assert.isFalse(invarriantCall);
done();
})
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) {
......@@ -97,12 +96,16 @@ contract('Bounty', function(accounts) {
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();
})
......
test/Claimable.js
contract('Claimable', function(accounts) {
let claimable;
beforeEach(async function(done) {
beforeEach(async function() {
claimable = await Claimable.new();
done();
});
it("should have an owner", async function(done) {
it("should have an owner", async function() {
let owner = await claimable.owner();
assert.isTrue(owner != 0);
done();
});
it("changes pendingOwner after transfer", async function(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);
done();
});
it("should prevent to claimOwnership from no pendingOwner", async function(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]);
done();
});
it("should prevent non-owners from transfering", async function(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]);
done();
});
describe("after initiating a transfer", function () {
let newOwner;
beforeEach(async function (done) {
beforeEach(async function () {
newOwner = accounts[1];
await claimable.transfer(newOwner);
done();
});
it("changes allow pending owner to claim ownership", async function(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);
done();
});
});
});
test/Killable.js
......@@ -32,7 +32,7 @@ contract('Killable', function(accounts) {
}
};
it("should send balance to owner after death", async function(done) {
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)
......@@ -49,8 +49,8 @@ contract('Killable', function(accounts) {
txnHash = await killable.kill({from: owner});
receiptMined = await web3.eth.getTransactionReceiptMined(txnHash);
newBalance = web3.eth.getBalance(owner);
assert.isTrue(newBalance > initBalance);
done();
});
});
test/LimitBalance.js
const assertJump = require('./helpers/assertJump');
contract('LimitBalance', function(accounts) {
let lb;
beforeEach(async function(done) {
beforeEach(async function() {
lb = await LimitBalanceMock.new();
done();
});
let LIMIT = 1000;
it("should expose limit", async function(done) {
it("should expose limit", async function() {
let limit = await lb.limit();
assert.equal(limit, LIMIT);
done();
});
it("should allow sending below limit", async function(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);
done();
});
it("shouldnt allow sending above limit", async function(done) {
it("shouldnt allow sending above limit", async function() {
let amount = 1110;
try {
let limDeposit = await lb.limitedDeposit({value: amount});
} catch(error) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
it("should allow multiple sends below limit", async function(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);
done();
});
it("shouldnt allow multiple sends above limit", async function(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) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
......
test/Ownable.js
contract('Ownable', function(accounts) {
let ownable;
beforeEach(async function(done) {
beforeEach(async function() {
ownable = await Ownable.new();
done();
});
it("should have an owner", async function(done) {
it("should have an owner", async function() {
let owner = await ownable.owner();
assert.isTrue(owner != 0);
done();
});
it("changes owner after transfer", async function(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);
done();
});
it("should prevent non-owners from transfering", async function(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);
done();
});
it("should guard ownership against stuck state", async function(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);
done();
});
});
test/PullPayment.js
contract('PullPayment', function(accounts) {
it("can't call asyncSend externally", async function(done) {
it("can't call asyncSend externally", async function() {
let ppc = await PullPaymentMock.new();
assert.isUndefined(ppc.asyncSend);
done();
});
it("can record an async payment correctly", async function(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);
done();
});
it("can add multiple balances on one account", async function(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 call2 = await ppce.callSend(accounts[0], 300);
let paymentsToAccount0 = await ppce.payments(accounts[0]);
assert.equal(paymentsToAccount0, 500);
done();
});
it("can add balances on multiple accounts", async function(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);
done();
});
it("can withdraw payment", async function(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);
done();
});
});
test/SafeMath.js
const assertJump = require('./helpers/assertJump');
contract('SafeMath', function(accounts) {
let safeMath;
before(async function(done) {
before(async function() {
safeMath = await SafeMathMock.new();
done();
});
it("multiplies correctly", async function(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);
done();
});
it("adds correctly", async function(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);
done();
});
it("subtracts correctly", async function(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);
done();
});
it("should throw an error if subtraction result would be negative", async function (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) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
it("should throw an error on addition overflow", async function(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) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
it("should throw an error on multiplication overflow", async function(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) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
......
test/StandardToken.js
const assertJump = require('./helpers/assertJump');
contract('StandardToken', function(accounts) {
it("should return the correct totalSupply after construction", async function(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);
done();
})
it("should return the correct allowance amount after approval", async function(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);
done();
});
it("should return correct balances after transfer", async function(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);
done();
});
it("should throw an error when trying to transfer more than balance", async function(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) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
it("should return correct balances after transfering from another account", async function(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]});
......@@ -49,18 +49,15 @@ contract('StandardToken', function(accounts) {
let balance2 = await token.balanceOf(accounts[1]);
assert.equal(balance2, 0);
done();
});
it("should throw an error when trying to transfer more than allowed", async function(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) {
if (error.message.search('invalid JUMP') == -1) throw error
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
done();
assertJump(error);
}
});
......
test/Stoppable.js
contract('Stoppable', function(accounts) {
it("can perform normal process in non-emergency", async function(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);
done();
});
it("can not perform normal process in emergency", async function(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);
done();
});
it("can not take drastic measure in non-emergency", async function(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);
done();
});
it("can take a drastic measure in an emergency", async function(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);
done();
});
it("should resume allowing normal process after emergency is over", async function(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);
done();
});
});
test/helpers/assertJump.js 0 → 100644
module.exports = function(error) {
assert.isAbove(error.message.search('invalid JUMP'), -1, 'Invalid JUMP error must be returned');
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment