From a4741e97a7f4232718311aa905db460af4a4dd24 Mon Sep 17 00:00:00 2001 From: Fabiano Nascimento Date: Thu, 19 Nov 2020 11:34:10 -0300 Subject: [PATCH] Adding tests powered by solidity-test --- package-lock.json | 2 +- test/BulkTransferTest.js | 115 +++++++++++++++++++++++++++++++++ test/CappedTransferTest.js | 126 +++++++++++++++++++++++++++++++++++++ test/CustomAdminTest.js | 89 ++++++++++++++++++++++++++ test/CustomOwnableTest.js | 103 ++++++++++++++++++++++++++++++ test/CustomPausableTest.js | 77 +++++++++++++++++++++++ test/ReclaimableTest.js | 101 +++++++++++++++++++++++++++++ test/TransferBaseTest.js | 97 ++++++++++++++++++++++++++++ 8 files changed, 709 insertions(+), 1 deletion(-) create mode 100644 test/BulkTransferTest.js create mode 100644 test/CappedTransferTest.js create mode 100644 test/CustomAdminTest.js create mode 100644 test/CustomOwnableTest.js create mode 100644 test/CustomPausableTest.js create mode 100644 test/ReclaimableTest.js create mode 100644 test/TransferBaseTest.js diff --git a/package-lock.json b/package-lock.json index 685317d..b6c77a2 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1520,7 +1520,7 @@ "resolved": "https://registry.npmjs.org/web3/-/web3-0.20.6.tgz", "integrity": "sha1-PpcwauAk+yThCj11yIQwJWIhUSA=", "requires": { - "bignumber.js": "git+https://github.com/frozeman/bignumber.js-nolookahead.git", + "bignumber.js": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", "crypto-js": "^3.1.4", "utf8": "^2.1.1", "xhr2": "*", diff --git a/test/BulkTransferTest.js b/test/BulkTransferTest.js new file mode 100644 index 0000000..95bbf55 --- /dev/null +++ b/test/BulkTransferTest.js @@ -0,0 +1,115 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('BulkTransfer', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail bulkTransfer(address,address[],uint256[]) when NOT comply with: _paused != true', async () => { + await contractBulkTransfer.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractBulkTransfer.bulkTransfer( + contractSimpleToken.address, + [accounts[5], accounts[6], accounts[4]], + [64, 65, 19], + {from: accounts[0]}, + ), + 'revert', + ); + }); + it('Should fail bulkTransfer(address,address[],uint256[]) when NOT comply with: destinations.length == amounts.length', async () => { + let result = await truffleAssert.fails( + contractBulkTransfer.bulkTransfer( + contractSimpleToken.address, + [accounts[5], accounts[4], accounts[0], accounts[7]], + [64, 65, 19], + {from: accounts[0]}, + ), + 'revert', + ); + }); + it('Should fail bulkTransferEther(address[],uint256[]) when NOT comply with: _paused != true', async () => { + await contractBulkTransfer.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractBulkTransfer.bulkTransferEther( + [accounts[8], accounts[6], accounts[2], accounts[2]], + [1532892062, 28, 26, 1532892063], + {from: accounts[0]}, + ), + 'revert', + ); + }); + it('Should fail bulkTransferEther(address[],uint256[]) when NOT comply with: destinations.length == amounts.length', async () => { + let result = await truffleAssert.fails( + contractBulkTransfer.bulkTransferEther( + [accounts[6], accounts[8], accounts[1], accounts[3], accounts[2]], + [1532892062, 28, 26, 1532892063], + {from: accounts[0]}, + ), + 'revert', + ); + }); +}); diff --git a/test/CappedTransferTest.js b/test/CappedTransferTest.js new file mode 100644 index 0000000..d090dd3 --- /dev/null +++ b/test/CappedTransferTest.js @@ -0,0 +1,126 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('CappedTransfer', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail checkIfValidTransfer(uint256) when NOT comply with: amount > 0', async () => { + await contractCappedTransfer.setCap(95, 255, {from: accounts[0]}); + let result = await truffleAssert.fails( + contractCappedTransfer.checkIfValidTransfer(0, {from: accounts[0]}), + 'revert', + ); + }); + it('Should fail checkIfValidTransfer(uint256) when NOT comply with: amount <= _maximumTransfer', async () => { + await contractCappedTransfer.setCap(95, 255, {from: accounts[0]}); + let result = await truffleAssert.fails( + contractCappedTransfer.checkIfValidTransfer(96, {from: accounts[0]}), + 'revert', + ); + }); + it('Should fail checkIfValidTransfer(uint256) when NOT comply with: amount > 0', async () => { + let result = await truffleAssert.fails( + contractCappedTransfer.checkIfValidTransfer(0, {from: accounts[0]}), + 'revert', + ); + }); + it('Should fail checkIfValidWeiTransfer(uint256) when NOT comply with: amount > 0', async () => { + await contractCappedTransfer.setCap(0, 1532892062, {from: accounts[0]}); + let result = await truffleAssert.fails( + contractCappedTransfer.checkIfValidWeiTransfer(0, {from: accounts[0]}), + 'revert', + ); + }); + it('Should fail checkIfValidWeiTransfer(uint256) when NOT comply with: amount <= _maximumTransferWei', async () => { + await contractCappedTransfer.setCap(0, 1532892062, {from: accounts[0]}); + let result = await truffleAssert.fails( + contractCappedTransfer.checkIfValidWeiTransfer(1532892063, { + from: accounts[0], + }), + 'revert', + ); + }); + it('Should fail checkIfValidWeiTransfer(uint256) when NOT comply with: amount > 0', async () => { + let result = await truffleAssert.fails( + contractCappedTransfer.checkIfValidWeiTransfer(0, {from: accounts[0]}), + 'revert', + ); + }); + it('Should fail setCap(uint256,uint256) when NOT comply with: msg.sender == _owner', async () => { + let result = await truffleAssert.fails( + contractCappedTransfer.setCap(2014223716, 26, {from: accounts[9]}), + 'revert', + ); + }); + it('Should fail setCap(uint256,uint256) when NOT comply with: _paused != true', async () => { + await contractCappedTransfer.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractCappedTransfer.setCap(2014223716, 26, {from: accounts[0]}), + 'revert', + ); + }); +}); diff --git a/test/CustomAdminTest.js b/test/CustomAdminTest.js new file mode 100644 index 0000000..77d7df2 --- /dev/null +++ b/test/CustomAdminTest.js @@ -0,0 +1,89 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('CustomAdmin', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail addAdmin(address) when NOT comply with: account != 0x0000000000000000000000000000000000000000', async () => { + let result = await truffleAssert.fails( + contractCustomAdmin.addAdmin( + '0x0000000000000000000000000000000000000000', + {from: accounts[0]}, + ), + 'revert', + ); + }); + it('Should fail removeAdmin(address) when NOT comply with: account != 0x0000000000000000000000000000000000000000', async () => { + let result = await truffleAssert.fails( + contractCustomAdmin.removeAdmin( + '0x0000000000000000000000000000000000000000', + {from: accounts[0]}, + ), + 'revert', + ); + }); +}); diff --git a/test/CustomOwnableTest.js b/test/CustomOwnableTest.js new file mode 100644 index 0000000..0f092f2 --- /dev/null +++ b/test/CustomOwnableTest.js @@ -0,0 +1,103 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('CustomOwnable', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail assignTrustee(address) when NOT comply with: msg.sender == _owner', async () => { + let result = await truffleAssert.fails( + contractCustomOwnable.assignTrustee(accounts[9], {from: accounts[9]}), + 'revert', + ); + }); + it('Should fail assignTrustee(address) when NOT comply with: account != 0x0000000000000000000000000000000000000000', async () => { + let result = await truffleAssert.fails( + contractCustomOwnable.assignTrustee( + '0x0000000000000000000000000000000000000000', + {from: accounts[0]}, + ), + 'revert', + ); + }); + it('Should fail reassignOwner(address) when NOT comply with: msg.sender == _trustee', async () => { + await contractCustomOwnable.assignTrustee(accounts[6], {from: accounts[0]}); + let result = await truffleAssert.fails( + contractCustomOwnable.reassignOwner(accounts[1], {from: accounts[9]}), + 'revert', + ); + }); + it('Should fail reassignOwner(address) when NOT comply with: newOwner != 0x0000000000000000000000000000000000000000', async () => { + await contractCustomOwnable.assignTrustee(accounts[6], {from: accounts[0]}); + let result = await truffleAssert.fails( + contractCustomOwnable.reassignOwner( + '0x0000000000000000000000000000000000000000', + {from: accounts[6]}, + ), + 'revert', + ); + }); +}); diff --git a/test/CustomPausableTest.js b/test/CustomPausableTest.js new file mode 100644 index 0000000..ef5081d --- /dev/null +++ b/test/CustomPausableTest.js @@ -0,0 +1,77 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('CustomPausable', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail unpause() when NOT comply with: _paused == true', async () => { + let result = await truffleAssert.fails( + contractCustomPausable.unpause({from: accounts[0]}), + 'revert', + ); + }); +}); diff --git a/test/ReclaimableTest.js b/test/ReclaimableTest.js new file mode 100644 index 0000000..e201793 --- /dev/null +++ b/test/ReclaimableTest.js @@ -0,0 +1,101 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('Reclaimable', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail reclaimEther() when NOT comply with: _paused != true', async () => { + await contractReclaimable.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractReclaimable.reclaimEther({from: accounts[0]}), + 'revert', + ); + }); + it('Should fail reclaimEther() when NOT comply with: msg.sender == _owner', async () => { + let result = await truffleAssert.fails( + contractReclaimable.reclaimEther({from: accounts[9]}), + 'revert', + ); + }); + it('Should fail reclaimToken(address) when NOT comply with: _paused != true', async () => { + await contractReclaimable.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractReclaimable.reclaimToken(contractSimpleToken.address, { + from: accounts[0], + }), + 'revert', + ); + }); + it('Should fail reclaimToken(address) when NOT comply with: msg.sender == _owner', async () => { + let result = await truffleAssert.fails( + contractReclaimable.reclaimToken(contractSimpleToken.address, { + from: accounts[9], + }), + 'revert', + ); + }); +}); diff --git a/test/TransferBaseTest.js b/test/TransferBaseTest.js new file mode 100644 index 0000000..a28b04c --- /dev/null +++ b/test/TransferBaseTest.js @@ -0,0 +1,97 @@ +const truffleAssert = require('truffle-assertions'); +const BulkTransfer = artifacts.require('BulkTransfer'); +const CappedTransfer = artifacts.require('CappedTransfer'); +const CustomAdmin = artifacts.require('CustomAdmin'); +const CustomOwnable = artifacts.require('CustomOwnable'); +const CustomPausable = artifacts.require('CustomPausable'); +const ForceEther = artifacts.require('ForceEther'); +const Reclaimable = artifacts.require('Reclaimable'); +const SimpleToken = artifacts.require('SimpleToken'); +const TransferBase = artifacts.require('TransferBase'); +const SafeMath = artifacts.require( + 'openzeppelin-solidity/contracts/math/SafeMath.sol', +); +const ERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/ERC20.sol', +); +const SafeERC20 = artifacts.require( + 'openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol', +); +const Address = artifacts.require( + 'openzeppelin-solidity/contracts/utils/Address.sol', +); + +contract('TransferBase', (accounts) => { + let trace = false; + let contractAddress = null; + let contractSafeERC20 = null; + let contractSafeMath = null; + let contractERC20 = null; + let contractCustomPausable = null; + let contractBulkTransfer = null; + let contractCappedTransfer = null; + let contractCustomAdmin = null; + let contractTransferBase = null; + let contractCustomOwnable = null; + let contractReclaimable = null; + let contractSimpleToken = null; + let contractForceEther = null; + beforeEach(async () => { + contractAddress = await Address.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Address.new({from: accounts[0]}'); + contractSafeERC20 = await SafeERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeERC20.new({from: accounts[0]}'); + contractSafeMath = await SafeMath.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: SafeMath.new({from: accounts[0]}'); + ERC20.link('SafeMath', contractSafeMath.address); + contractERC20 = await ERC20.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ERC20.new({from: accounts[0]}'); + contractCustomPausable = await CustomPausable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomPausable.new({from: accounts[0]}'); + contractBulkTransfer = await BulkTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: BulkTransfer.new({from: accounts[0]}'); + contractCappedTransfer = await CappedTransfer.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CappedTransfer.new({from: accounts[0]}'); + contractCustomAdmin = await CustomAdmin.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomAdmin.new({from: accounts[0]}'); + TransferBase.link('SafeERC20', contractSafeERC20.address); + contractTransferBase = await TransferBase.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: TransferBase.new({from: accounts[0]}'); + contractCustomOwnable = await CustomOwnable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: CustomOwnable.new({from: accounts[0]}'); + Reclaimable.link('SafeERC20', contractSafeERC20.address); + contractReclaimable = await Reclaimable.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: Reclaimable.new({from: accounts[0]}'); + contractSimpleToken = await SimpleToken.new({from: accounts[8]}); + if (trace) console.log('SUCESSO: SimpleToken.new({from:accounts[8]}'); + contractForceEther = await ForceEther.new({from: accounts[0]}); + if (trace) console.log('SUCESSO: ForceEther.new({from:accounts[0]}'); + }); + + it('Should fail transferTokens(address,address,uint256) when NOT comply with: _paused != true', async () => { + await contractTransferBase.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractTransferBase.transferTokens( + contractSimpleToken.address, + accounts[6], + 64, + {from: accounts[0]}, + ), + 'revert', + ); + }); + it('Should fail transferEthers(address,uint256) when NOT comply with: _paused != true', async () => { + await contractTransferBase.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractTransferBase.transferEthers(accounts[4], 1, {from: accounts[0]}), + 'revert', + ); + }); + it('Should fail fallback() when NOT comply with: _paused != true', async () => { + await contractTransferBase.pause({from: accounts[0]}); + let result = await truffleAssert.fails( + contractTransferBase.sendTransaction({from: accounts[0]}), + 'revert', + ); + }); +});