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

Migrate Contracts to Solidity v0.6 (#2080)

Browse Source 
* Initial migration to Solidity 0.6.x - v3.0 first steps (#2063)

* Initial migration, missing GSN, 721, 777 and Crowdsales.

* Add _beforeTokenOperation and _afterTokenOperation.

* Add documentation for hooks.

* Add hooks doc

* Add missing drafts

* Add back ERC721 with hooks

* Bring back ERC777

* Notes on hooks

* Bring back GSN

* Make functions virtual

* Make GSN overrides explicit

* Fix ERC20Pausable tests

* Remove virtual from some view functions

* Update linter

* Delete examples

* Remove unnecessary virtual

* Remove roles from Pausable

* Remove roles

* Remove users of roles

* Adapt ERC20 tests

* Fix ERC721 tests

* Add all ERC721 hooks

* Add ERC777 hooks

* Fix remaining tests

* Bump compiler version

* Move 721BurnableMock into mocks directory

* Remove _before hooks

* Fix tests

* Upgrade linter

* Put modifiers last

* Remove _beforeTokenApproval and _beforeOperatorApproval hooks
This commit is contained in:
Nicolás Venturo
2020-02-14 11:12:32 -03:00
committed by GitHub
parent 04a1b21874
commit 5dfe7215a9
201 changed files with 1561 additions and 5006 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
test/lifecycle/Pausable.test.js
View File

@ -1,26 +1,16 @@
const { accounts, contract } = require('@openzeppelin/test-environment');
const { expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
const { shouldBehaveLikePublicRole } = require('../behaviors/access/roles/PublicRole.behavior');
const { expect } = require('chai');
const PausableMock = contract.fromArtifact('PausableMock');
describe('Pausable', function () {
const [ pauser, otherPauser, other, ...otherAccounts ] = accounts;
const [ pauser ] = accounts;
beforeEach(async function () {
this.pausable = await PausableMock.new({ from: pauser });
});
describe('pauser role', function () {
beforeEach(async function () {
this.contract = this.pausable;
await this.contract.addPauser(otherPauser, { from: pauser });
});
shouldBehaveLikePublicRole(pauser, otherPauser, otherAccounts, 'pauser');
this.pausable = await PausableMock.new();
});
context('when unpaused', function () {
@ -31,87 +21,68 @@ describe('Pausable', function () {
it('can perform normal process in non-pause', async function () {
expect(await this.pausable.count()).to.be.bignumber.equal('0');
await this.pausable.normalProcess({ from: other });
await this.pausable.normalProcess();
expect(await this.pausable.count()).to.be.bignumber.equal('1');
});
it('cannot take drastic measure in non-pause', async function () {
await expectRevert(this.pausable.drasticMeasure({ from: other }),
await expectRevert(this.pausable.drasticMeasure(),
'Pausable: not paused'
);
expect(await this.pausable.drasticMeasureTaken()).to.equal(false);
});
describe('pausing', function () {
it('is pausable by the pauser', async function () {
await this.pausable.pause({ from: pauser });
expect(await this.pausable.paused()).to.equal(true);
context('when paused', function () {
beforeEach(async function () {
({ logs: this.logs } = await this.pausable.pause({ from: pauser }));
});
it('reverts when pausing from non-pauser', async function () {
await expectRevert(this.pausable.pause({ from: other }),
'PauserRole: caller does not have the Pauser role'
);
it('emits a Paused event', function () {
expectEvent.inLogs(this.logs, 'Paused', { account: pauser });
});
context('when paused', function () {
beforeEach(async function () {
({ logs: this.logs } = await this.pausable.pause({ from: pauser }));
it('cannot perform normal process in pause', async function () {
await expectRevert(this.pausable.normalProcess(), 'Pausable: paused');
});
it('can take a drastic measure in a pause', async function () {
await this.pausable.drasticMeasure();
expect(await this.pausable.drasticMeasureTaken()).to.equal(true);
});
it('reverts when re-pausing', async function () {
await expectRevert(this.pausable.pause(), 'Pausable: paused');
});
describe('unpausing', function () {
it('is unpausable by the pauser', async function () {
await this.pausable.unpause();
expect(await this.pausable.paused()).to.equal(false);
});
it('emits a Paused event', function () {
expectEvent.inLogs(this.logs, 'Paused', { account: pauser });
});
it('cannot perform normal process in pause', async function () {
await expectRevert(this.pausable.normalProcess({ from: other }), 'Pausable: paused');
});
it('can take a drastic measure in a pause', async function () {
await this.pausable.drasticMeasure({ from: other });
expect(await this.pausable.drasticMeasureTaken()).to.equal(true);
});
it('reverts when re-pausing', async function () {
await expectRevert(this.pausable.pause({ from: pauser }), 'Pausable: paused');
});
describe('unpausing', function () {
it('is unpausable by the pauser', async function () {
await this.pausable.unpause({ from: pauser });
expect(await this.pausable.paused()).to.equal(false);
context('when unpaused', function () {
beforeEach(async function () {
({ logs: this.logs } = await this.pausable.unpause({ from: pauser }));
});
it('reverts when unpausing from non-pauser', async function () {
await expectRevert(this.pausable.unpause({ from: other }),
'PauserRole: caller does not have the Pauser role'
it('emits an Unpaused event', function () {
expectEvent.inLogs(this.logs, 'Unpaused', { account: pauser });
});
it('should resume allowing normal process', async function () {
expect(await this.pausable.count()).to.be.bignumber.equal('0');
await this.pausable.normalProcess();
expect(await this.pausable.count()).to.be.bignumber.equal('1');
});
it('should prevent drastic measure', async function () {
await expectRevert(this.pausable.drasticMeasure(),
'Pausable: not paused'
);
});
context('when unpaused', function () {
beforeEach(async function () {
({ logs: this.logs } = await this.pausable.unpause({ from: pauser }));
});
it('emits an Unpaused event', function () {
expectEvent.inLogs(this.logs, 'Unpaused', { account: pauser });
});
it('should resume allowing normal process', async function () {
expect(await this.pausable.count()).to.be.bignumber.equal('0');
await this.pausable.normalProcess({ from: other });
expect(await this.pausable.count()).to.be.bignumber.equal('1');
});
it('should prevent drastic measure', async function () {
await expectRevert(this.pausable.drasticMeasure({ from: other }),
'Pausable: not paused'
);
});
it('reverts when re-unpausing', async function () {
await expectRevert(this.pausable.unpause({ from: pauser }), 'Pausable: not paused');
});
it('reverts when re-unpausing', async function () {
await expectRevert(this.pausable.unpause(), 'Pausable: not paused');
});
});
});