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

Increase testing coverage (#1195)

Browse Source 
* Added non-target bounty test

* Increased ERC721 testing coverage.

* Addressed review comments.

* fix linter error

* Fixed linter error

* Removed unnecessary bouncer require

* Improved Crowdsale tests.

* Added missing SuperUser test.

* Improved payment tests.

* Improved token tests.

* Fixed ERC721 test.

* Reviewed phrasing.
This commit is contained in:
Nicolás Venturo
2018-08-14 19:37:30 -03:00
committed by GitHub
parent d51e38758e
commit 8d11dcc0e5
11 changed files with 404 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
test/token/ERC20/TokenVesting.test.js
View File

@ -15,110 +15,134 @@ const TokenVesting = artifacts.require('TokenVesting');
contract('TokenVesting', function ([_, owner, beneficiary]) {
const amount = new BigNumber(1000);
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
beforeEach(async function () {
this.token = await MintableToken.new({ from: owner });
this.start = (await latestTime()) + duration.minutes(1); // +1 minute so it starts after contract instantiation
this.cliff = duration.years(1);
this.duration = duration.years(2);
this.vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, true, { from: owner });
await this.token.mint(this.vesting.address, amount, { from: owner });
});
it('cannot be released before cliff', async function () {
it('rejects a duration shorter than the cliff', async function () {
const cliff = this.duration;
const duration = this.cliff;
cliff.should.be.gt(duration);
await expectThrow(
this.vesting.release(this.token.address),
EVMRevert,
TokenVesting.new(beneficiary, this.start, cliff, duration, true, { from: owner })
);
});
it('can be released after cliff', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(1));
await this.vesting.release(this.token.address);
it('requires a valid beneficiary', async function () {
await expectThrow(
TokenVesting.new(ZERO_ADDRESS, this.start, this.cliff, this.duration, true, { from: owner })
);
});
it('should release proper amount after cliff', async function () {
await increaseTimeTo(this.start + this.cliff);
context('once deployed', function () {
beforeEach(async function () {
this.vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, true, { from: owner });
const { receipt } = await this.vesting.release(this.token.address);
const block = await ethGetBlock(receipt.blockNumber);
const releaseTime = block.timestamp;
this.token = await MintableToken.new({ from: owner });
await this.token.mint(this.vesting.address, amount, { from: owner });
});
const balance = await this.token.balanceOf(beneficiary);
balance.should.bignumber.eq(amount.mul(releaseTime - this.start).div(this.duration).floor());
});
it('cannot be released before cliff', async function () {
await expectThrow(
this.vesting.release(this.token.address),
EVMRevert,
);
});
it('should linearly release tokens during vesting period', async function () {
const vestingPeriod = this.duration - this.cliff;
const checkpoints = 4;
it('can be released after cliff', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(1));
await this.vesting.release(this.token.address);
});
for (let i = 1; i <= checkpoints; i++) {
const now = this.start + this.cliff + i * (vestingPeriod / checkpoints);
await increaseTimeTo(now);
it('should release proper amount after cliff', async function () {
await increaseTimeTo(this.start + this.cliff);
const { receipt } = await this.vesting.release(this.token.address);
const block = await ethGetBlock(receipt.blockNumber);
const releaseTime = block.timestamp;
const balance = await this.token.balanceOf(beneficiary);
balance.should.bignumber.eq(amount.mul(releaseTime - this.start).div(this.duration).floor());
});
it('should linearly release tokens during vesting period', async function () {
const vestingPeriod = this.duration - this.cliff;
const checkpoints = 4;
for (let i = 1; i <= checkpoints; i++) {
const now = this.start + this.cliff + i * (vestingPeriod / checkpoints);
await increaseTimeTo(now);
await this.vesting.release(this.token.address);
const balance = await this.token.balanceOf(beneficiary);
const expectedVesting = amount.mul(now - this.start).div(this.duration).floor();
balance.should.bignumber.eq(expectedVesting);
}
});
it('should have released all after end', async function () {
await increaseTimeTo(this.start + this.duration);
await this.vesting.release(this.token.address);
const balance = await this.token.balanceOf(beneficiary);
const expectedVesting = amount.mul(now - this.start).div(this.duration).floor();
balance.should.bignumber.eq(amount);
});
balance.should.bignumber.eq(expectedVesting);
}
});
it('should be revoked by owner if revocable is set', async function () {
await this.vesting.revoke(this.token.address, { from: owner });
});
it('should have released all after end', async function () {
await increaseTimeTo(this.start + this.duration);
await this.vesting.release(this.token.address);
const balance = await this.token.balanceOf(beneficiary);
balance.should.bignumber.eq(amount);
});
it('should fail to be revoked by owner if revocable not set', async function () {
const vesting = await TokenVesting.new(
beneficiary, this.start, this.cliff, this.duration, false, { from: owner }
);
it('should be revoked by owner if revocable is set', async function () {
await this.vesting.revoke(this.token.address, { from: owner });
});
await expectThrow(
vesting.revoke(this.token.address, { from: owner }),
EVMRevert,
);
});
it('should fail to be revoked by owner if revocable not set', async function () {
const vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, false, { from: owner });
await expectThrow(
vesting.revoke(this.token.address, { from: owner }),
EVMRevert,
);
});
it('should return the non-vested tokens when revoked by owner', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
it('should return the non-vested tokens when revoked by owner', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
const vested = await this.vesting.vestedAmount(this.token.address);
const vested = await this.vesting.vestedAmount(this.token.address);
await this.vesting.revoke(this.token.address, { from: owner });
await this.vesting.revoke(this.token.address, { from: owner });
const ownerBalance = await this.token.balanceOf(owner);
ownerBalance.should.bignumber.eq(amount.sub(vested));
});
const ownerBalance = await this.token.balanceOf(owner);
ownerBalance.should.bignumber.eq(amount.sub(vested));
});
it('should keep the vested tokens when revoked by owner', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
it('should keep the vested tokens when revoked by owner', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
const vestedPre = await this.vesting.vestedAmount(this.token.address);
const vestedPre = await this.vesting.vestedAmount(this.token.address);
await this.vesting.revoke(this.token.address, { from: owner });
await this.vesting.revoke(this.token.address, { from: owner });
const vestedPost = await this.vesting.vestedAmount(this.token.address);
const vestedPost = await this.vesting.vestedAmount(this.token.address);
vestedPre.should.bignumber.eq(vestedPost);
});
vestedPre.should.bignumber.eq(vestedPost);
});
it('should fail to be revoked a second time', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
it('should fail to be revoked a second time', async function () {
await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
await this.vesting.vestedAmount(this.token.address);
await this.vesting.vestedAmount(this.token.address);
await this.vesting.revoke(this.token.address, { from: owner });
await this.vesting.revoke(this.token.address, { from: owner });
await expectThrow(
this.vesting.revoke(this.token.address, { from: owner }),
EVMRevert,
);
await expectThrow(
this.vesting.revoke(this.token.address, { from: owner }),
EVMRevert,
);
});
});
});