Commit 8c9ac5f5 authored by smartcontracts's avatar smartcontracts Committed by GitHub

maint(ct): clean up TeleportrDisburser tests (#2512)

Cleans up the TeleportrDisburser tests using the same techniques as in
previous cleanup PRs.
Co-authored-by: default avatarmergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
parent c799535d
/* External Imports */
import { ethers } from 'hardhat' import { ethers } from 'hardhat'
import { Signer, Contract, BigNumber } from 'ethers' import { Contract, BigNumber } from 'ethers'
import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
/* Internal Imports */
import { expect } from '../../../setup' import { expect } from '../../../setup'
import { deploy } from '../../../helpers'
const zeroETH = ethers.utils.parseEther('0.0')
const oneETH = ethers.utils.parseEther('1.0')
const twoETH = ethers.utils.parseEther('2.0')
describe('TeleportrDisburser', async () => { describe('TeleportrDisburser', async () => {
const zeroETH = ethers.utils.parseEther('0.0') let signer1: SignerWithAddress
const oneETH = ethers.utils.parseEther('1.0') let signer2: SignerWithAddress
const twoETH = ethers.utils.parseEther('2.0') before(async () => {
;[signer1, signer2] = await ethers.getSigners()
let teleportrDisburser: Contract })
let failingReceiver: Contract
let signer: Signer let TeleportrDisburser: Contract
let signer2: Signer let FailingReceiver: Contract
let contractAddress: string
let failingReceiverAddress: string
let signerAddress: string
let signer2Address: string
before(async () => { before(async () => {
;[signer, signer2] = await ethers.getSigners() TeleportrDisburser = await deploy('TeleportrDisburser')
teleportrDisburser = await ( FailingReceiver = await deploy('FailingReceiver')
await ethers.getContractFactory('TeleportrDisburser')
).deploy()
failingReceiver = await (
await ethers.getContractFactory('FailingReceiver')
).deploy()
contractAddress = teleportrDisburser.address
failingReceiverAddress = failingReceiver.address
signerAddress = await signer.getAddress()
signer2Address = await signer2.getAddress()
}) })
describe('disburse checks', async () => { describe('disburse checks', async () => {
it('should revert if called by non-owner', async () => { it('should revert if called by non-owner', async () => {
await expect( await expect(
teleportrDisburser.connect(signer2).disburse(0, [], { value: oneETH }) TeleportrDisburser.connect(signer2).disburse(0, [], { value: oneETH })
).to.be.revertedWith('Ownable: caller is not the owner') ).to.be.revertedWith('Ownable: caller is not the owner')
}) })
it('should revert if no disbursements is zero length', async () => { it('should revert if no disbursements is zero length', async () => {
await expect( await expect(
teleportrDisburser.disburse(0, [], { value: oneETH }) TeleportrDisburser.disburse(0, [], { value: oneETH })
).to.be.revertedWith('No disbursements') ).to.be.revertedWith('No disbursements')
}) })
it('should revert if nextDepositId does not match expected value', async () => { it('should revert if nextDepositId does not match expected value', async () => {
await expect( await expect(
teleportrDisburser.disburse(1, [[oneETH, signer2Address]], { TeleportrDisburser.disburse(1, [[oneETH, signer2.address]], {
value: oneETH, value: oneETH,
}) })
).to.be.revertedWith('Unexpected next deposit id') ).to.be.revertedWith('Unexpected next deposit id')
}) })
it('should revert if msg.value does not match total to disburse', async () => { it('should revert if msg.value does not match total to disburse', async () => {
await expect( await expect(
teleportrDisburser.disburse(0, [[oneETH, signer2Address]], { TeleportrDisburser.disburse(0, [[oneETH, signer2.address]], {
value: zeroETH, value: zeroETH,
}) })
).to.be.revertedWith('Disbursement total != amount sent') ).to.be.revertedWith('Disbursement total != amount sent')
}) })
}) })
describe('disburse single success', async () => { describe('disburse single success', async () => {
let signerInitialBalance: BigNumber let signer1InitialBalance: BigNumber
let signer2InitialBalance: BigNumber let signer2InitialBalance: BigNumber
before(async () => {
signer1InitialBalance = await ethers.provider.getBalance(signer1.address)
signer2InitialBalance = await ethers.provider.getBalance(signer2.address)
})
it('should emit DisbursementSuccess for successful disbursement', async () => { it('should emit DisbursementSuccess for successful disbursement', async () => {
signerInitialBalance = await ethers.provider.getBalance(signerAddress)
signer2InitialBalance = await ethers.provider.getBalance(signer2Address)
await expect( await expect(
teleportrDisburser.disburse(0, [[oneETH, signer2Address]], { TeleportrDisburser.disburse(0, [[oneETH, signer2.address]], {
value: oneETH, value: oneETH,
}) })
) )
.to.emit(teleportrDisburser, 'DisbursementSuccess') .to.emit(TeleportrDisburser, 'DisbursementSuccess')
.withArgs(BigNumber.from(0), signer2Address, oneETH) .withArgs(BigNumber.from(0), signer2.address, oneETH)
}) })
it('should show one total disbursement', async () => { it('should show one total disbursement', async () => {
await expect(await teleportrDisburser.totalDisbursements()).to.be.equal( expect(await TeleportrDisburser.totalDisbursements()).to.be.equal(
BigNumber.from(1) BigNumber.from(1)
) )
}) })
it('should leave contract balance at zero ETH', async () => { it('should leave contract balance at zero ETH', async () => {
await expect( expect(
await ethers.provider.getBalance(contractAddress) await ethers.provider.getBalance(TeleportrDisburser.address)
).to.be.equal(zeroETH) ).to.be.equal(zeroETH)
}) })
it('should increase recipients balance by disbursement amount', async () => { it('should increase recipients balance by disbursement amount', async () => {
await expect( expect(await ethers.provider.getBalance(signer2.address)).to.be.equal(
await ethers.provider.getBalance(signer2Address) signer2InitialBalance.add(oneETH)
).to.be.equal(signer2InitialBalance.add(oneETH)) )
}) })
it('should decrease owners balance by disbursement amount - fees', async () => { it('should decrease owners balance by disbursement amount - fees', async () => {
await expect( expect(await ethers.provider.getBalance(signer1.address)).to.be.closeTo(
await ethers.provider.getBalance(signerAddress) signer1InitialBalance.sub(oneETH),
).to.be.closeTo(signerInitialBalance.sub(oneETH), 10 ** 15) 10 ** 15
)
}) })
}) })
describe('disburse single failure', async () => { describe('disburse single failure', async () => {
let signerInitialBalance: BigNumber let signer1InitialBalance: BigNumber
before(async () => {
signer1InitialBalance = await ethers.provider.getBalance(signer1.address)
})
it('should emit DisbursementFailed for failed disbursement', async () => { it('should emit DisbursementFailed for failed disbursement', async () => {
signerInitialBalance = await ethers.provider.getBalance(signerAddress)
await expect( await expect(
teleportrDisburser.disburse(1, [[oneETH, failingReceiverAddress]], { TeleportrDisburser.disburse(1, [[oneETH, FailingReceiver.address]], {
value: oneETH, value: oneETH,
}) })
) )
.to.emit(teleportrDisburser, 'DisbursementFailed') .to.emit(TeleportrDisburser, 'DisbursementFailed')
.withArgs(BigNumber.from(1), failingReceiverAddress, oneETH) .withArgs(BigNumber.from(1), FailingReceiver.address, oneETH)
}) })
it('should show two total disbursements', async () => { it('should show two total disbursements', async () => {
await expect(await teleportrDisburser.totalDisbursements()).to.be.equal( expect(await TeleportrDisburser.totalDisbursements()).to.be.equal(
BigNumber.from(2) BigNumber.from(2)
) )
}) })
it('should leave contract with disbursement amount', async () => { it('should leave contract with disbursement amount', async () => {
await expect( expect(
await ethers.provider.getBalance(contractAddress) await ethers.provider.getBalance(TeleportrDisburser.address)
).to.be.equal(oneETH) ).to.be.equal(oneETH)
}) })
it('should leave recipients balance at zero ETH', async () => { it('should leave recipients balance at zero ETH', async () => {
await expect( expect(
await ethers.provider.getBalance(failingReceiverAddress) await ethers.provider.getBalance(FailingReceiver.address)
).to.be.equal(zeroETH) ).to.be.equal(zeroETH)
}) })
it('should decrease owners balance by disbursement amount - fees', async () => { it('should decrease owners balance by disbursement amount - fees', async () => {
await expect( expect(await ethers.provider.getBalance(signer1.address)).to.be.closeTo(
await ethers.provider.getBalance(signerAddress) signer1InitialBalance.sub(oneETH),
).to.be.closeTo(signerInitialBalance.sub(oneETH), 10 ** 15) 10 ** 15
)
}) })
}) })
describe('withdrawBalance', async () => { describe('withdrawBalance', async () => {
let initialContractBalance: BigNumber let signer1InitialBalance: BigNumber
let initialSignerBalance: BigNumber let disburserInitialBalance: BigNumber
before(async () => {
signer1InitialBalance = await ethers.provider.getBalance(signer1.address)
disburserInitialBalance = await ethers.provider.getBalance(
TeleportrDisburser.address
)
})
it('should revert if called by non-owner', async () => { it('should revert if called by non-owner', async () => {
await expect( await expect(
teleportrDisburser.connect(signer2).withdrawBalance() TeleportrDisburser.connect(signer2).withdrawBalance()
).to.be.revertedWith('Ownable: caller is not the owner') ).to.be.revertedWith('Ownable: caller is not the owner')
}) })
it('should emit BalanceWithdrawn if called by owner', async () => { it('should emit BalanceWithdrawn if called by owner', async () => {
initialContractBalance = await ethers.provider.getBalance(contractAddress) await expect(TeleportrDisburser.withdrawBalance())
initialSignerBalance = await ethers.provider.getBalance(signerAddress) .to.emit(TeleportrDisburser, 'BalanceWithdrawn')
await expect(teleportrDisburser.withdrawBalance()) .withArgs(signer1.address, oneETH)
.to.emit(teleportrDisburser, 'BalanceWithdrawn')
.withArgs(signerAddress, oneETH)
}) })
it('should leave contract with zero balance', async () => { it('should leave contract with zero balance', async () => {
await expect(await ethers.provider.getBalance(contractAddress)).to.equal( expect(
zeroETH await ethers.provider.getBalance(TeleportrDisburser.address)
) ).to.equal(zeroETH)
}) })
it('should credit owner with contract balance - fees', async () => { it('should credit owner with contract balance - fees', async () => {
const expSignerBalance = initialSignerBalance.add(initialContractBalance) expect(await ethers.provider.getBalance(signer1.address)).to.be.closeTo(
await expect( signer1InitialBalance.add(disburserInitialBalance),
await ethers.provider.getBalance(signerAddress) 10 ** 15
).to.be.closeTo(expSignerBalance, 10 ** 15) )
}) })
}) })
describe('disburse multiple', async () => { describe('disburse multiple', async () => {
let signerInitialBalance: BigNumber let signer1InitialBalance: BigNumber
let signer2InitialBalance: BigNumber let signer2InitialBalance: BigNumber
before(async () => {
signer1InitialBalance = await ethers.provider.getBalance(signer1.address)
signer2InitialBalance = await ethers.provider.getBalance(signer2.address)
})
it('should emit DisbursementSuccess for successful disbursement', async () => { it('should emit DisbursementSuccess for successful disbursement', async () => {
signerInitialBalance = await ethers.provider.getBalance(signerAddress)
signer2InitialBalance = await ethers.provider.getBalance(signer2Address)
await expect( await expect(
teleportrDisburser.disburse( TeleportrDisburser.disburse(
2, 2,
[ [
[oneETH, signer2Address], [oneETH, signer2.address],
[oneETH, failingReceiverAddress], [oneETH, FailingReceiver.address],
], ],
{ value: twoETH } { value: twoETH }
) )
).to.not.be.reverted ).to.not.be.reverted
}) })
it('should show four total disbursements', async () => { it('should show four total disbursements', async () => {
await expect(await teleportrDisburser.totalDisbursements()).to.be.equal( expect(await TeleportrDisburser.totalDisbursements()).to.be.equal(
BigNumber.from(4) BigNumber.from(4)
) )
}) })
it('should leave contract balance with failed disbursement amount', async () => { it('should leave contract balance with failed disbursement amount', async () => {
await expect( expect(
await ethers.provider.getBalance(contractAddress) await ethers.provider.getBalance(TeleportrDisburser.address)
).to.be.equal(oneETH) ).to.be.equal(oneETH)
}) })
it('should increase success recipients balance by disbursement amount', async () => { it('should increase success recipients balance by disbursement amount', async () => {
await expect( expect(await ethers.provider.getBalance(signer2.address)).to.be.equal(
await ethers.provider.getBalance(signer2Address) signer2InitialBalance.add(oneETH)
).to.be.equal(signer2InitialBalance.add(oneETH)) )
}) })
it('should leave failed recipients balance at zero ETH', async () => { it('should leave failed recipients balance at zero ETH', async () => {
await expect( expect(
await ethers.provider.getBalance(failingReceiverAddress) await ethers.provider.getBalance(FailingReceiver.address)
).to.be.equal(zeroETH) ).to.be.equal(zeroETH)
}) })
it('should decrease owners balance by disbursement 2*amount - fees', async () => { it('should decrease owners balance by disbursement 2*amount - fees', async () => {
await expect( expect(await ethers.provider.getBalance(signer1.address)).to.be.closeTo(
await ethers.provider.getBalance(signerAddress) signer1InitialBalance.sub(twoETH),
).to.be.closeTo(signerInitialBalance.sub(twoETH), 10 ** 15) 10 ** 15
)
}) })
}) })
}) })
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