NoBey/openzeppelin-contracts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'release-v2.0.0' of github.com:OpenZeppelin/openzeppelin-solidity into release-v2.0.0

Browse Source
This commit is contained in:
Francisco Giordano
2018-09-26 18:19:41 -03:00
parent e6252d511c fa5ecd03cb
commit 838509c0a4
15 changed files with 174 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
test/access/roles/PublicRole.behavior.js
View File

@ -89,6 +89,11 @@ function shouldBehaveLikePublicRole (authorized, otherAuthorized, [anyone], role
(await this.contract[`is${rolename}`](authorized)).should.equal(false);
});
it(`emits a ${rolename}Removed event`, async function () {
const { logs } = await this.contract[`renounce${rolename}`]({ from: authorized });
expectEvent.inLogs(logs, `${rolename}Removed`, { account: authorized });
});
it('doesn\'t revert when renouncing unassigned role', async function () {
await this.contract[`renounce${rolename}`]({ from: anyone });
});

159
test/drafts/BreakInvariantBounty.test.js
View File

@ -2,97 +2,104 @@ const { ethGetBalance, ethSendTransaction } = require('../helpers/web3');
const expectEvent = require('../helpers/expectEvent');
const { assertRevert } = require('../helpers/assertRevert');
const SecureInvariantTargetBounty = artifacts.require('SecureInvariantTargetBounty');
const InsecureInvariantTargetBounty = artifacts.require('InsecureInvariantTargetBounty');
const BreakInvariantBountyMock = artifacts.require('BreakInvariantBountyMock');
const TargetMock = artifacts.require('TargetMock');
require('chai')
.use(require('chai-bignumber')(web3.BigNumber))
.should();
const sendReward = async (from, to, value) => ethSendTransaction({
from,
to,
value,
});
const reward = new web3.BigNumber(web3.toWei(1, 'ether'));
contract('BreakInvariantBounty', function ([_, owner, researcher, nonTarget]) {
context('against secure contract', function () {
beforeEach(async function () {
this.bounty = await SecureInvariantTargetBounty.new({ from: owner });
});
it('can set reward', async function () {
await sendReward(owner, this.bounty.address, reward);
const balance = await ethGetBalance(this.bounty.address);
balance.should.be.bignumber.equal(reward);
});
context('with reward', function () {
beforeEach(async function () {
const result = await this.bounty.createTarget({ from: researcher });
const event = expectEvent.inLogs(result.logs, 'TargetCreated');
this.targetAddress = event.args.createdAddress;
await sendReward(owner, this.bounty.address, reward);
const balance = await ethGetBalance(this.bounty.address);
balance.should.be.bignumber.equal(reward);
});
it('cannot claim reward', async function () {
await assertRevert(
this.bounty.claim(this.targetAddress, { from: researcher }),
);
});
});
contract('BreakInvariantBounty', function ([_, owner, researcher, anyone, nonTarget]) {
beforeEach(async function () {
this.bounty = await BreakInvariantBountyMock.new({ from: owner });
});
context('against broken contract', function () {
it('can set reward', async function () {
await ethSendTransaction({ from: owner, to: this.bounty.address, value: reward });
(await ethGetBalance(this.bounty.address)).should.be.bignumber.equal(reward);
});
context('with reward', function () {
beforeEach(async function () {
this.bounty = await InsecureInvariantTargetBounty.new();
const result = await this.bounty.createTarget({ from: researcher });
const event = expectEvent.inLogs(result.logs, 'TargetCreated');
this.targetAddress = event.args.createdAddress;
await sendReward(owner, this.bounty.address, reward);
await ethSendTransaction({ from: owner, to: this.bounty.address, value: reward });
});
it('can claim reward', async function () {
await this.bounty.claim(this.targetAddress, { from: researcher });
const claim = await this.bounty.claimed();
describe('destroy', function () {
it('returns all balance to the owner', async function () {
const ownerPreBalance = await ethGetBalance(owner);
await this.bounty.destroy({ from: owner, gasPrice: 0 });
const ownerPostBalance = await ethGetBalance(owner);
claim.should.equal(true);
const researcherPrevBalance = await ethGetBalance(researcher);
await this.bounty.withdrawPayments(researcher, { gasPrice: 0 });
const updatedBalance = await ethGetBalance(this.bounty.address);
updatedBalance.should.be.bignumber.equal(0);
const researcherCurrBalance = await ethGetBalance(researcher);
researcherCurrBalance.sub(researcherPrevBalance).should.be.bignumber.equal(reward);
});
it('cannot claim reward from non-target', async function () {
await assertRevert(
this.bounty.claim(nonTarget, { from: researcher })
);
});
context('reward claimed', function () {
beforeEach(async function () {
await this.bounty.claim(this.targetAddress, { from: researcher });
(await ethGetBalance(this.bounty.address)).should.be.bignumber.equal(0);
ownerPostBalance.sub(ownerPreBalance).should.be.bignumber.equal(reward);
});
it('should no longer be payable', async function () {
await assertRevert(
sendReward(owner, this.bounty.address, reward)
);
it('reverts when called by anyone', async function () {
await assertRevert(this.bounty.destroy({ from: anyone }));
});
});
describe('claim', function () {
it('is initially unclaimed', async function () {
(await this.bounty.claimed()).should.equal(false);
});
it('can create claimable target', async function () {
const { logs } = await this.bounty.createTarget({ from: researcher });
expectEvent.inLogs(logs, 'TargetCreated');
});
context('with target', async function () {
beforeEach(async function () {
const { logs } = await this.bounty.createTarget({ from: researcher });
const event = expectEvent.inLogs(logs, 'TargetCreated');
this.target = TargetMock.at(event.args.createdAddress);
});
context('before exploiting vulnerability', async function () {
it('reverts when claiming reward', async function () {
await assertRevert(this.bounty.claim(this.target.address, { from: researcher }));
});
});
context('after exploiting vulnerability', async function () {
beforeEach(async function () {
await this.target.exploitVulnerability({ from: researcher });
});
it('sends the reward to the researcher', async function () {
await this.bounty.claim(this.target.address, { from: anyone });
const researcherPreBalance = await ethGetBalance(researcher);
await this.bounty.withdrawPayments(researcher);
const researcherPostBalance = await ethGetBalance(researcher);
researcherPostBalance.sub(researcherPreBalance).should.be.bignumber.equal(reward);
(await ethGetBalance(this.bounty.address)).should.be.bignumber.equal(0);
});
context('after claiming', async function () {
beforeEach(async function () {
await this.bounty.claim(this.target.address, { from: researcher });
});
it('is claimed', async function () {
(await this.bounty.claimed()).should.equal(true);
});
it('no longer accepts rewards', async function () {
await assertRevert(ethSendTransaction({ from: owner, to: this.bounty.address, value: reward }));
});
});
});
});
context('with non-target', function () {
it('reverts when claiming reward', async function () {
await assertRevert(this.bounty.claim(nonTarget, { from: researcher }));
});
});
});
});

134
test/token/ERC20/behaviors/ERC20Mintable.behavior.js
View File

@ -11,136 +11,44 @@ function shouldBehaveLikeERC20Mintable (minter, [anyone]) {
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
describe('as a mintable token', function () {
describe('mintingFinished', function () {
context('when token minting is not finished', function () {
it('returns false', async function () {
(await this.token.mintingFinished()).should.equal(false);
});
});
context('when token minting is finished', function () {
beforeEach(async function () {
await this.token.finishMinting({ from: minter });
});
it('returns true', async function () {
(await this.token.mintingFinished()).should.equal(true);
});
});
});
describe('finishMinting', function () {
context('when the sender has minting permission', function () {
const from = minter;
context('when token minting was not finished', function () {
it('finishes token minting', async function () {
await this.token.finishMinting({ from });
(await this.token.mintingFinished()).should.equal(true);
});
it('emits a mint finished event', async function () {
const { logs } = await this.token.finishMinting({ from });
await expectEvent.inLogs(logs, 'MintingFinished');
});
});
context('when token minting was already finished', function () {
beforeEach(async function () {
await this.token.finishMinting({ from });
});
it('reverts', async function () {
await assertRevert(this.token.finishMinting({ from }));
});
});
});
context('when the sender doesn\'t have minting permission', function () {
const from = anyone;
context('when token minting was not finished', function () {
it('reverts', async function () {
await assertRevert(this.token.finishMinting({ from }));
});
});
context('when token minting was already finished', function () {
beforeEach(async function () {
await this.token.finishMinting({ from: minter });
});
it('reverts', async function () {
await assertRevert(this.token.finishMinting({ from }));
});
});
});
});
describe('mint', function () {
const amount = 100;
context('when the sender has minting permission', function () {
const from = minter;
context('when token minting is not finished', function () {
context('for a zero amount', function () {
shouldMint(0);
});
context('for a non-zero amount', function () {
shouldMint(amount);
});
function shouldMint (amount) {
beforeEach(async function () {
({ logs: this.logs } = await this.token.mint(anyone, amount, { from }));
});
it('mints the requested amount', async function () {
(await this.token.balanceOf(anyone)).should.be.bignumber.equal(amount);
});
it('emits a mint and a transfer event', async function () {
const transferEvent = expectEvent.inLogs(this.logs, 'Transfer', {
from: ZERO_ADDRESS,
to: anyone,
});
transferEvent.args.value.should.be.bignumber.equal(amount);
});
}
context('for a zero amount', function () {
shouldMint(0);
});
context('when token minting is finished', function () {
context('for a non-zero amount', function () {
shouldMint(amount);
});
function shouldMint (amount) {
beforeEach(async function () {
await this.token.finishMinting({ from: minter });
({ logs: this.logs } = await this.token.mint(anyone, amount, { from }));
});
it('reverts', async function () {
await assertRevert(this.token.mint(anyone, amount, { from }));
it('mints the requested amount', async function () {
(await this.token.balanceOf(anyone)).should.be.bignumber.equal(amount);
});
});
it('emits a mint and a transfer event', async function () {
const transferEvent = expectEvent.inLogs(this.logs, 'Transfer', {
from: ZERO_ADDRESS,
to: anyone,
});
transferEvent.args.value.should.be.bignumber.equal(amount);
});
}
});
context('when the sender doesn\'t have minting permission', function () {
const from = anyone;
context('when token minting is not finished', function () {
it('reverts', async function () {
await assertRevert(this.token.mint(anyone, amount, { from }));
});
});
context('when token minting is already finished', function () {
beforeEach(async function () {
await this.token.finishMinting({ from: minter });
});
it('reverts', async function () {
await assertRevert(this.token.mint(anyone, amount, { from }));
});
it('reverts', async function () {
await assertRevert(this.token.mint(anyone, amount, { from }));
});
});
});

19
test/token/ERC721/ERC721Holder.test.js Normal file
View File

@ -0,0 +1,19 @@
const ERC721Holder = artifacts.require('ERC721Holder.sol');
const ERC721Mintable = artifacts.require('ERC721MintableBurnableImpl.sol');
require('chai')
.should();
contract('ERC721Holder', function ([creator]) {
it('receives an ERC721 token', async function () {
const token = await ERC721Mintable.new({ from: creator });
const tokenId = 1;
await token.mint(creator, tokenId, { from: creator });
const receiver = await ERC721Holder.new();
await token.approve(receiver.address, tokenId, { from: creator });
await token.safeTransferFrom(creator, receiver.address, tokenId);
(await token.ownerOf(tokenId)).should.be.equal(receiver.address);
});
});

29
test/token/ERC721/ERC721MintBurn.behavior.js
View File

@ -117,35 +117,6 @@ function shouldBehaveLikeMintAndBurnERC721 (
});
});
});
describe('finishMinting', function () {
it('allows the minter to finish minting', async function () {
const { logs } = await this.token.finishMinting({ from: minter });
expectEvent.inLogs(logs, 'MintingFinished');
});
});
context('mintingFinished', function () {
beforeEach(async function () {
await this.token.finishMinting({ from: minter });
});
describe('mint', function () {
it('reverts', async function () {
await assertRevert(
this.token.mint(owner, thirdTokenId, { from: minter })
);
});
});
describe('mintWithTokenURI', function () {
it('reverts', async function () {
await assertRevert(
this.token.mintWithTokenURI(owner, thirdTokenId, MOCK_URI, { from: minter })
);
});
});
});
});
}